forked from farhoodlabs/paperclip
Devin Foley
08af830430
## Thinking Path > - Paperclip is a control plane for autonomous agent companies, so its local and authenticated deployment behavior has to stay predictable under port rebinding and worktree isolation. > - This change sits in the server/worktree configuration path that derives runtime URLs and auth origins from `auth.publicBaseUrl`. > - The original hostname-port rewrite change fixed one real gap for private/tailnet host:port worktree setups, but it widened the rewrite rule too far. > - Rewriting every explicit `auth.publicBaseUrl` can corrupt public or reverse-proxy URLs by turning a stable origin like `https://paperclip.example` into a local listen-port URL. > - Paperclip's auth and trusted-origin handling depend on that URL staying semantically correct, so this had to be narrowed before merge. > - This pull request tightens the rewrite rule to explicit-port URLs only and adds regression coverage across the CLI helper, worktree config persistence, and server startup path. > - The benefit is that private host:port worktree flows still work, while public/default-port URLs remain stable and safe. ## What Changed - Tightened `rewriteLocalUrlPort` in `cli/src/commands/worktree-lib.ts`, `server/src/worktree-config.ts`, and `server/src/index.ts` so it only rewrites URLs that already include an explicit port. - Removed the old loopback-only hostname gate from the CLI/worktree helpers and replaced it with the more precise `parsed.port` guard. - Updated CLI helper coverage to assert that explicit-port non-loopback URLs still rewrite while no-port public URLs stay unchanged. - Expanded `server/src/__tests__/worktree-config.test.ts` to cover explicit-port rewrite and no-port stability for both persisted worktree config and in-memory runtime port selection. - Added startup-path coverage in `server/src/__tests__/server-startup-feedback-export.test.ts` for `detect-port` rebinding with both explicit-port and no-port `auth.publicBaseUrl` values. ## Verification - `pnpm --filter @paperclipai/plugin-sdk build` - `npx vitest run server/src/__tests__/server-startup-feedback-export.test.ts` - `npx vitest run cli/src/__tests__/worktree.test.ts server/src/__tests__/worktree-config.test.ts` - All of the above were run locally in this issue worktree and passed. ## Risks - Low risk. The behavior change is deliberately narrower than the reviewed broad-host rewrite and is guarded by regression coverage for both the explicit-port and no-port cases. - The main remaining risk is behavioral only if another code path starts depending on port rewriting for URLs that never declared a port, which would be a separate bug. > For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and discuss it in `#dev` before opening the PR. Feature PRs that overlap with planned core work may need to be redirected — check the roadmap first. See `CONTRIBUTING.md`. ## Model Used - OpenAI Codex local agent using `gpt-5.4` with high reasoning effort, tool use, shell execution, and file editing. - Anthropic Claude local agent using `claude-opus-4-6` for follow-up code review approval on the implementation issue. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] If this change affects the UI, I have included before/after screenshots - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] I will address all Greptile and reviewer comments before requesting merge
640 lines
23 KiB
TypeScript
640 lines
23 KiB
TypeScript
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
import {
|
|
applyRuntimePortSelectionToConfig,
|
|
maybePersistWorktreeRuntimePorts,
|
|
maybeRepairLegacyWorktreeConfigAndEnvFiles,
|
|
} from "../worktree-config.js";
|
|
|
|
const ORIGINAL_ENV = { ...process.env };
|
|
const ORIGINAL_CWD = process.cwd();
|
|
|
|
afterEach(() => {
|
|
process.chdir(ORIGINAL_CWD);
|
|
|
|
for (const key of Object.keys(process.env)) {
|
|
if (!(key in ORIGINAL_ENV)) {
|
|
delete process.env[key];
|
|
}
|
|
}
|
|
for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
|
|
process.env[key] = value;
|
|
}
|
|
});
|
|
|
|
function buildLegacyConfig(sharedRoot: string, publicBaseUrl = "http://127.0.0.1:3100") {
|
|
return {
|
|
$meta: {
|
|
version: 1,
|
|
updatedAt: "2026-03-26T00:00:00.000Z",
|
|
source: "configure",
|
|
},
|
|
database: {
|
|
mode: "embedded-postgres" as const,
|
|
embeddedPostgresDataDir: path.join(sharedRoot, "db"),
|
|
embeddedPostgresPort: 54329,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(sharedRoot, "data", "backups"),
|
|
},
|
|
},
|
|
logging: {
|
|
mode: "file" as const,
|
|
logDir: path.join(sharedRoot, "logs"),
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted" as const,
|
|
exposure: "private" as const,
|
|
host: "127.0.0.1",
|
|
port: 3100,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
auth: {
|
|
baseUrlMode: "explicit" as const,
|
|
publicBaseUrl,
|
|
disableSignUp: false,
|
|
},
|
|
storage: {
|
|
provider: "local_disk" as const,
|
|
localDisk: {
|
|
baseDir: path.join(sharedRoot, "data", "storage"),
|
|
},
|
|
s3: {
|
|
bucket: "paperclip",
|
|
region: "us-east-1",
|
|
prefix: "",
|
|
forcePathStyle: false,
|
|
},
|
|
},
|
|
secrets: {
|
|
provider: "local_encrypted" as const,
|
|
strictMode: false,
|
|
localEncrypted: {
|
|
keyFilePath: path.join(sharedRoot, "secrets", "master.key"),
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("worktree config repair", () => {
|
|
it("repairs legacy repo-local worktree config and env files into an isolated instance", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-repair-"));
|
|
const worktreeRoot = path.join(tempRoot, "PAP-884-ai-commits-component");
|
|
const paperclipDir = path.join(worktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const envPath = path.join(paperclipDir, ".env");
|
|
const sharedRoot = path.join(tempRoot, ".paperclip", "instances", "default");
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.writeFile(configPath, JSON.stringify(buildLegacyConfig(sharedRoot), null, 2) + "\n", "utf8");
|
|
await fs.writeFile(
|
|
envPath,
|
|
[
|
|
"# Paperclip environment variables",
|
|
"PAPERCLIP_IN_WORKTREE=true",
|
|
"PAPERCLIP_WORKTREE_NAME=PAP-884-ai-commits-component",
|
|
"PAPERCLIP_AGENT_JWT_SECRET=shared-secret",
|
|
"",
|
|
].join("\n"),
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(worktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-884-ai-commits-component";
|
|
process.env.PAPERCLIP_WORKTREES_DIR = isolatedHome;
|
|
delete process.env.PAPERCLIP_HOME;
|
|
delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
delete process.env.PAPERCLIP_CONFIG;
|
|
delete process.env.PAPERCLIP_CONTEXT;
|
|
|
|
const result = maybeRepairLegacyWorktreeConfigAndEnvFiles();
|
|
|
|
expect(result).toEqual({
|
|
repairedConfig: true,
|
|
repairedEnv: true,
|
|
});
|
|
|
|
const repairedConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
const repairedEnv = await fs.readFile(envPath, "utf8");
|
|
const instanceRoot = path.join(isolatedHome, "instances", "pap-884-ai-commits-component");
|
|
|
|
expect(repairedConfig.database.embeddedPostgresDataDir).toBe(path.join(instanceRoot, "db"));
|
|
expect(repairedConfig.database.backup.dir).toBe(path.join(instanceRoot, "data", "backups"));
|
|
expect(repairedConfig.logging.logDir).toBe(path.join(instanceRoot, "logs"));
|
|
expect(repairedConfig.storage.localDisk.baseDir).toBe(path.join(instanceRoot, "data", "storage"));
|
|
expect(repairedConfig.secrets.localEncrypted.keyFilePath).toBe(path.join(instanceRoot, "secrets", "master.key"));
|
|
expect(repairedEnv).toContain(`PAPERCLIP_HOME=${JSON.stringify(isolatedHome)}`);
|
|
expect(repairedEnv).toContain('PAPERCLIP_INSTANCE_ID="pap-884-ai-commits-component"');
|
|
expect(repairedEnv).toContain(`PAPERCLIP_CONFIG=${JSON.stringify(await fs.realpath(configPath))}`);
|
|
expect(repairedEnv).toContain(`PAPERCLIP_CONTEXT=${JSON.stringify(path.join(isolatedHome, "context.json"))}`);
|
|
expect(repairedEnv).toContain('PAPERCLIP_AGENT_JWT_SECRET="shared-secret"');
|
|
expect(process.env.PAPERCLIP_HOME).toBe(isolatedHome);
|
|
expect(process.env.PAPERCLIP_INSTANCE_ID).toBe("pap-884-ai-commits-component");
|
|
});
|
|
|
|
it("avoids sibling worktree ports when repairing legacy configs", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-repair-ports-"));
|
|
const worktreeRoot = path.join(tempRoot, "PAP-880-thumbs-capture-for-evals-feature");
|
|
const paperclipDir = path.join(worktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const envPath = path.join(paperclipDir, ".env");
|
|
const sharedRoot = path.join(tempRoot, ".paperclip", "instances", "default");
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
const siblingInstanceRoot = path.join(isolatedHome, "instances", "pap-878-create-a-mine-tab-in-inbox");
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.mkdir(siblingInstanceRoot, { recursive: true });
|
|
await fs.writeFile(configPath, JSON.stringify(buildLegacyConfig(sharedRoot), null, 2) + "\n", "utf8");
|
|
await fs.writeFile(
|
|
envPath,
|
|
[
|
|
"# Paperclip environment variables",
|
|
"PAPERCLIP_IN_WORKTREE=true",
|
|
"PAPERCLIP_WORKTREE_NAME=PAP-880-thumbs-capture-for-evals-feature",
|
|
"",
|
|
].join("\n"),
|
|
"utf8",
|
|
);
|
|
await fs.writeFile(
|
|
path.join(siblingInstanceRoot, "config.json"),
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(siblingInstanceRoot),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(siblingInstanceRoot, "db"),
|
|
embeddedPostgresPort: 54330,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(siblingInstanceRoot, "data", "backups"),
|
|
},
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3101,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(worktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-880-thumbs-capture-for-evals-feature";
|
|
process.env.PAPERCLIP_WORKTREES_DIR = isolatedHome;
|
|
delete process.env.PAPERCLIP_HOME;
|
|
delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
delete process.env.PAPERCLIP_CONFIG;
|
|
delete process.env.PAPERCLIP_CONTEXT;
|
|
|
|
const result = maybeRepairLegacyWorktreeConfigAndEnvFiles();
|
|
const repairedConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
|
|
expect(result.repairedConfig).toBe(true);
|
|
expect(repairedConfig.server.port).toBe(3102);
|
|
expect(repairedConfig.database.embeddedPostgresPort).toBe(54331);
|
|
});
|
|
|
|
it("does not persist transient runtime home overrides over repo-local worktree env", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-runtime-override-"));
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
const transientHome = path.join(tempRoot, "tests", "e2e", ".tmp", "multiuser-authenticated");
|
|
const worktreeRoot = path.join(tempRoot, "PAP-989-multi-user-implementation-using-plan-from-pap-958");
|
|
const paperclipDir = path.join(worktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const envPath = path.join(paperclipDir, ".env");
|
|
const instanceId = "pap-989-multi-user-implementation-using-plan-from-pap-958";
|
|
const stableInstanceRoot = path.join(isolatedHome, "instances", instanceId);
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.writeFile(
|
|
configPath,
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(transientHome),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(transientHome, "instances", instanceId, "db"),
|
|
embeddedPostgresPort: 54334,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(transientHome, "instances", instanceId, "data", "backups"),
|
|
},
|
|
},
|
|
logging: {
|
|
mode: "file",
|
|
logDir: path.join(transientHome, "instances", instanceId, "logs"),
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3104,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
storage: {
|
|
provider: "local_disk",
|
|
localDisk: {
|
|
baseDir: path.join(transientHome, "instances", instanceId, "data", "storage"),
|
|
},
|
|
s3: {
|
|
bucket: "paperclip",
|
|
region: "us-east-1",
|
|
prefix: "",
|
|
forcePathStyle: false,
|
|
},
|
|
},
|
|
secrets: {
|
|
provider: "local_encrypted",
|
|
strictMode: false,
|
|
localEncrypted: {
|
|
keyFilePath: path.join(transientHome, "instances", instanceId, "secrets", "master.key"),
|
|
},
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
await fs.writeFile(
|
|
envPath,
|
|
[
|
|
"# Paperclip environment variables",
|
|
`PAPERCLIP_HOME=${JSON.stringify(isolatedHome)}`,
|
|
`PAPERCLIP_INSTANCE_ID=${JSON.stringify(instanceId)}`,
|
|
`PAPERCLIP_CONFIG=${JSON.stringify(configPath)}`,
|
|
`PAPERCLIP_CONTEXT=${JSON.stringify(path.join(isolatedHome, "context.json"))}`,
|
|
'PAPERCLIP_IN_WORKTREE="true"',
|
|
'PAPERCLIP_WORKTREE_NAME="PAP-989-multi-user-implementation-using-plan-from-pap-958"',
|
|
"",
|
|
].join("\n"),
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(worktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-989-multi-user-implementation-using-plan-from-pap-958";
|
|
process.env.PAPERCLIP_HOME = transientHome;
|
|
process.env.PAPERCLIP_INSTANCE_ID = instanceId;
|
|
process.env.PAPERCLIP_CONFIG = configPath;
|
|
|
|
const result = maybeRepairLegacyWorktreeConfigAndEnvFiles();
|
|
const repairedConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
const repairedEnv = await fs.readFile(envPath, "utf8");
|
|
|
|
expect(result).toEqual({
|
|
repairedConfig: true,
|
|
repairedEnv: false,
|
|
});
|
|
expect(repairedConfig.database.embeddedPostgresDataDir).toBe(path.join(stableInstanceRoot, "db"));
|
|
expect(repairedConfig.database.backup.dir).toBe(path.join(stableInstanceRoot, "data", "backups"));
|
|
expect(repairedConfig.logging.logDir).toBe(path.join(stableInstanceRoot, "logs"));
|
|
expect(repairedConfig.storage.localDisk.baseDir).toBe(path.join(stableInstanceRoot, "data", "storage"));
|
|
expect(repairedConfig.secrets.localEncrypted.keyFilePath).toBe(
|
|
path.join(stableInstanceRoot, "secrets", "master.key"),
|
|
);
|
|
expect(repairedEnv).toContain(`PAPERCLIP_HOME=${JSON.stringify(isolatedHome)}`);
|
|
expect(repairedEnv).not.toContain(`PAPERCLIP_HOME=${JSON.stringify(transientHome)}`);
|
|
expect(process.env.PAPERCLIP_HOME).toBe(isolatedHome);
|
|
});
|
|
|
|
it("rebalances duplicate ports for already isolated worktree configs", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-rebalance-"));
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
const repoWorktreesRoot = path.join(tempRoot, "repo", ".paperclip", "worktrees");
|
|
const siblingWorktreeRoot = path.join(repoWorktreesRoot, "PAP-878-create-a-mine-tab-in-inbox");
|
|
const siblingInstanceRoot = path.join(isolatedHome, "instances", "pap-878-create-a-mine-tab-in-inbox");
|
|
const currentWorktreeRoot = path.join(repoWorktreesRoot, "PAP-884-ai-commits-component");
|
|
const paperclipDir = path.join(currentWorktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const envPath = path.join(paperclipDir, ".env");
|
|
const currentInstanceRoot = path.join(isolatedHome, "instances", "pap-884-ai-commits-component");
|
|
const siblingConfigPath = path.join(siblingWorktreeRoot, ".paperclip", "config.json");
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.mkdir(path.dirname(siblingConfigPath), { recursive: true });
|
|
await fs.writeFile(
|
|
configPath,
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(currentInstanceRoot),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(currentInstanceRoot, "db"),
|
|
embeddedPostgresPort: 54330,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(currentInstanceRoot, "data", "backups"),
|
|
},
|
|
},
|
|
logging: {
|
|
mode: "file",
|
|
logDir: path.join(currentInstanceRoot, "logs"),
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3101,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
storage: {
|
|
provider: "local_disk",
|
|
localDisk: {
|
|
baseDir: path.join(currentInstanceRoot, "data", "storage"),
|
|
},
|
|
s3: {
|
|
bucket: "paperclip",
|
|
region: "us-east-1",
|
|
prefix: "",
|
|
forcePathStyle: false,
|
|
},
|
|
},
|
|
secrets: {
|
|
provider: "local_encrypted",
|
|
strictMode: false,
|
|
localEncrypted: {
|
|
keyFilePath: path.join(currentInstanceRoot, "secrets", "master.key"),
|
|
},
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
await fs.writeFile(
|
|
envPath,
|
|
[
|
|
"# Paperclip environment variables",
|
|
"PAPERCLIP_IN_WORKTREE=true",
|
|
"PAPERCLIP_WORKTREE_NAME=PAP-884-ai-commits-component",
|
|
"",
|
|
].join("\n"),
|
|
"utf8",
|
|
);
|
|
await fs.writeFile(
|
|
siblingConfigPath,
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(siblingInstanceRoot),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(siblingInstanceRoot, "db"),
|
|
embeddedPostgresPort: 54330,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(siblingInstanceRoot, "data", "backups"),
|
|
},
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3101,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(currentWorktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-884-ai-commits-component";
|
|
process.env.PAPERCLIP_WORKTREES_DIR = isolatedHome;
|
|
|
|
const result = maybeRepairLegacyWorktreeConfigAndEnvFiles();
|
|
const repairedConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
|
|
expect(result.repairedConfig).toBe(true);
|
|
expect(repairedConfig.server.port).toBe(3102);
|
|
expect(repairedConfig.database.embeddedPostgresPort).toBe(54331);
|
|
});
|
|
|
|
it("persists runtime-selected worktree ports back into explicit-port auth URLs", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-ports-"));
|
|
const worktreeRoot = path.join(tempRoot, "PAP-878-create-a-mine-tab-in-inbox");
|
|
const paperclipDir = path.join(worktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
const instanceRoot = path.join(isolatedHome, "instances", "pap-878-create-a-mine-tab-in-inbox");
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.writeFile(
|
|
configPath,
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(instanceRoot, "http://my-host.ts.net:3100"),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(instanceRoot, "db"),
|
|
embeddedPostgresPort: 54331,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(instanceRoot, "data", "backups"),
|
|
},
|
|
},
|
|
logging: {
|
|
mode: "file",
|
|
logDir: path.join(instanceRoot, "logs"),
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3101,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
storage: {
|
|
provider: "local_disk",
|
|
localDisk: {
|
|
baseDir: path.join(instanceRoot, "data", "storage"),
|
|
},
|
|
s3: {
|
|
bucket: "paperclip",
|
|
region: "us-east-1",
|
|
prefix: "",
|
|
forcePathStyle: false,
|
|
},
|
|
},
|
|
secrets: {
|
|
provider: "local_encrypted",
|
|
strictMode: false,
|
|
localEncrypted: {
|
|
keyFilePath: path.join(instanceRoot, "secrets", "master.key"),
|
|
},
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(worktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-878-create-a-mine-tab-in-inbox";
|
|
process.env.PAPERCLIP_HOME = isolatedHome;
|
|
process.env.PAPERCLIP_INSTANCE_ID = "pap-878-create-a-mine-tab-in-inbox";
|
|
process.env.PAPERCLIP_CONFIG = configPath;
|
|
|
|
maybePersistWorktreeRuntimePorts({
|
|
serverPort: 3103,
|
|
databasePort: 54335,
|
|
});
|
|
|
|
const writtenConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
|
|
expect(writtenConfig.server.port).toBe(3103);
|
|
expect(writtenConfig.database.embeddedPostgresPort).toBe(54335);
|
|
expect(writtenConfig.auth.publicBaseUrl).toBe("http://my-host.ts.net:3103/");
|
|
});
|
|
|
|
it("does not rewrite no-port public auth URLs when persisting runtime-selected ports", async () => {
|
|
const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-worktree-public-ports-"));
|
|
const worktreeRoot = path.join(tempRoot, "PAP-125-public-base-url");
|
|
const paperclipDir = path.join(worktreeRoot, ".paperclip");
|
|
const configPath = path.join(paperclipDir, "config.json");
|
|
const isolatedHome = path.join(tempRoot, ".paperclip-worktrees");
|
|
const instanceRoot = path.join(isolatedHome, "instances", "pap-125-public-base-url");
|
|
|
|
await fs.mkdir(paperclipDir, { recursive: true });
|
|
await fs.writeFile(
|
|
configPath,
|
|
JSON.stringify(
|
|
{
|
|
...buildLegacyConfig(instanceRoot, "https://paperclip.example"),
|
|
database: {
|
|
mode: "embedded-postgres",
|
|
embeddedPostgresDataDir: path.join(instanceRoot, "db"),
|
|
embeddedPostgresPort: 54331,
|
|
backup: {
|
|
enabled: true,
|
|
intervalMinutes: 60,
|
|
retentionDays: 30,
|
|
dir: path.join(instanceRoot, "data", "backups"),
|
|
},
|
|
},
|
|
logging: {
|
|
mode: "file",
|
|
logDir: path.join(instanceRoot, "logs"),
|
|
},
|
|
server: {
|
|
deploymentMode: "local_trusted",
|
|
exposure: "private",
|
|
host: "127.0.0.1",
|
|
port: 3101,
|
|
allowedHostnames: [],
|
|
serveUi: true,
|
|
},
|
|
storage: {
|
|
provider: "local_disk",
|
|
localDisk: {
|
|
baseDir: path.join(instanceRoot, "data", "storage"),
|
|
},
|
|
s3: {
|
|
bucket: "paperclip",
|
|
region: "us-east-1",
|
|
prefix: "",
|
|
forcePathStyle: false,
|
|
},
|
|
},
|
|
secrets: {
|
|
provider: "local_encrypted",
|
|
strictMode: false,
|
|
localEncrypted: {
|
|
keyFilePath: path.join(instanceRoot, "secrets", "master.key"),
|
|
},
|
|
},
|
|
},
|
|
null,
|
|
2,
|
|
) + "\n",
|
|
"utf8",
|
|
);
|
|
|
|
process.chdir(worktreeRoot);
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.PAPERCLIP_WORKTREE_NAME = "PAP-125-public-base-url";
|
|
process.env.PAPERCLIP_HOME = isolatedHome;
|
|
process.env.PAPERCLIP_INSTANCE_ID = "pap-125-public-base-url";
|
|
process.env.PAPERCLIP_CONFIG = configPath;
|
|
|
|
maybePersistWorktreeRuntimePorts({
|
|
serverPort: 3103,
|
|
databasePort: 54335,
|
|
});
|
|
|
|
const writtenConfig = JSON.parse(await fs.readFile(configPath, "utf8"));
|
|
|
|
expect(writtenConfig.server.port).toBe(3103);
|
|
expect(writtenConfig.database.embeddedPostgresPort).toBe(54335);
|
|
expect(writtenConfig.auth.publicBaseUrl).toBe("https://paperclip.example");
|
|
});
|
|
|
|
it("can update the in-memory config when auth URL already includes a port", () => {
|
|
const { config, changed } = applyRuntimePortSelectionToConfig(
|
|
buildLegacyConfig("/tmp/shared", "http://my-host.ts.net:3100"),
|
|
{
|
|
serverPort: 3104,
|
|
databasePort: 54340,
|
|
allowServerPortWrite: false,
|
|
allowDatabasePortWrite: true,
|
|
},
|
|
);
|
|
|
|
expect(changed).toBe(true);
|
|
expect(config.server.port).toBe(3100);
|
|
expect(config.database.embeddedPostgresPort).toBe(54340);
|
|
expect(config.auth.publicBaseUrl).toBe("http://my-host.ts.net:3104/");
|
|
});
|
|
|
|
it("does not rewrite the in-memory config when auth URL has no explicit port", () => {
|
|
const { config, changed } = applyRuntimePortSelectionToConfig(
|
|
buildLegacyConfig("/tmp/shared", "https://paperclip.example"),
|
|
{
|
|
serverPort: 3104,
|
|
databasePort: 54340,
|
|
allowServerPortWrite: false,
|
|
allowDatabasePortWrite: true,
|
|
},
|
|
);
|
|
|
|
expect(changed).toBe(true);
|
|
expect(config.server.port).toBe(3100);
|
|
expect(config.database.embeddedPostgresPort).toBe(54340);
|
|
expect(config.auth.publicBaseUrl).toBe("https://paperclip.example");
|
|
});
|
|
});
|