The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
[codex] harden authenticated routes and issue editor reliability (#3741)
Dotta32a9165ddf63
diff --git a/packages/shared/src/validators/approval.ts b/packages/shared/src/validators/approval.tsindex d6a6cf0d57..ae6b2eb3b3 100644--- a/packages/shared/src/validators/approval.ts+++ b/packages/shared/src/validators/approval.ts@@ -12,14 +12,12 @@ export type CreateApproval = z.infer<typeof createApprovalSchema>;export const resolveApprovalSchema = z.object({decisionNote: z.string().optional().nullable(),- decidedByUserId: z.string().optional().default("board"),});export type ResolveApproval = z.infer<typeof resolveApprovalSchema>;export const requestApprovalRevisionSchema = z.object({decisionNote: z.string().optional().nullable(),- decidedByUserId: z.string().optional().default("board"),});export type RequestApprovalRevision = z.infer<typeof requestApprovalRevisionSchema>;diff --git a/server/src/__tests__/activity-routes.test.ts b/server/src/__tests__/activity-routes.test.tsindex e8b50dba1e..974fcb2a09 100644--- a/server/src/__tests__/activity-routes.test.ts+++ b/server/src/__tests__/activity-routes.test.ts@@ -28,7 +28,15 @@ vi.mock("../services/index.js", () => ({heartbeatService: () => mockHeartbeatService,}));-async function createApp() {+async function createApp(+ actor: Record<string, unknown> = {+ type: "board",+ userId: "user-1",+ companyIds: ["company-1"],+ source: "session",+ isInstanceAdmin: false,+ },+) {const [{ errorHandler }, { activityRoutes }] = await Promise.all([import("../middleware/index.js"),import("../routes/activity.js"),@@ -36,13 +44,7 @@ async function createApp() {const app = express();app.use(express.json());app.use((req, _res, next) => {- (req as any).actor = {- type: "board",- userId: "user-1",- companyIds: ["company-1"],- source: "session",- isInstanceAdmin: false,- };+ (req as any).actor = actor;next();});app.use("/api", activityRoutes({} as any));@@ -105,4 +107,13 @@ describe("activity routes", () => {expect(res.status).toBe(403);expect(mockActivityService.issuesForRun).not.toHaveBeenCalled();});++ it("rejects anonymous heartbeat run issue lookups before run existence checks", async () => {+ const app = await createApp({ type: "none", source: "none" });+ const res = await request(app).get("/api/heartbeat-runs/missing-run/issues");++ expect(res.status).toBe(401);+ expect(mockHeartbeatService.getRun).not.toHaveBeenCalled();+ expect(mockActivityService.issuesForRun).not.toHaveBeenCalled();+ });});diff --git a/server/src/__tests__/agent-cross-tenant-authz-routes.test.ts b/server/src/__tests__/agent-cross-tenant-authz-routes.test.tsnew file mode 100644index 0000000000..34b7dec4f4--- /dev/null+++ b/server/src/__tests__/agent-cross-tenant-authz-routes.test.ts@@ -0,0 +1,267 @@+import express from "express";+import request from "supertest";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { errorHandler } from "../middleware/index.js";+import { agentRoutes } from "../routes/agents.js";++const agentId = "11111111-1111-4111-8111-111111111111";+const companyId = "22222222-2222-4222-8222-222222222222";+const keyId = "33333333-3333-4333-8333-333333333333";++const baseAgent = {+ id: agentId,+ companyId,+ name: "Builder",+ urlKey: "builder",+ role: "engineer",+ title: "Builder",+ icon: null,+ status: "idle",+ reportsTo: null,+ capabilities: null,+ adapterType: "process",+ adapterConfig: {},+ runtimeConfig: {},+ budgetMonthlyCents: 0,+ spentMonthlyCents: 0,+ pauseReason: null,+ pausedAt: null,+ permissions: { canCreateAgents: false },+ lastHeartbeatAt: null,+ metadata: null,+ createdAt: new Date("2026-04-11T00:00:00.000Z"),+ updatedAt: new Date("2026-04-11T00:00:00.000Z"),+};++const baseKey = {+ id: keyId,+ agentId,+ companyId,+ name: "exploit",+ createdAt: new Date("2026-04-11T00:00:00.000Z"),+ revokedAt: null,+};++const mockAgentService = vi.hoisted(() => ({+ getById: vi.fn(),+ pause: vi.fn(),+ resume: vi.fn(),+ terminate: vi.fn(),+ remove: vi.fn(),+ listKeys: vi.fn(),+ createApiKey: vi.fn(),+ getKeyById: vi.fn(),+ revokeKey: vi.fn(),+}));++const mockAccessService = vi.hoisted(() => ({+ canUser: vi.fn(),+ hasPermission: vi.fn(),+ getMembership: vi.fn(),+ ensureMembership: vi.fn(),+ listPrincipalGrants: vi.fn(),+ setPrincipalPermission: vi.fn(),+}));++const mockApprovalService = vi.hoisted(() => ({+ create: vi.fn(),+ getById: vi.fn(),+}));++const mockBudgetService = vi.hoisted(() => ({+ upsertPolicy: vi.fn(),+}));++const mockHeartbeatService = vi.hoisted(() => ({+ cancelActiveForAgent: vi.fn(),+}));++const mockIssueApprovalService = vi.hoisted(() => ({+ linkManyForApproval: vi.fn(),+}));++const mockIssueService = vi.hoisted(() => ({+ list: vi.fn(),+}));++const mockSecretService = vi.hoisted(() => ({+ normalizeAdapterConfigForPersistence: vi.fn(),+ resolveAdapterConfigForRuntime: vi.fn(),+}));++const mockAgentInstructionsService = vi.hoisted(() => ({+ materializeManagedBundle: vi.fn(),+}));++const mockCompanySkillService = vi.hoisted(() => ({+ listRuntimeSkillEntries: vi.fn(),+ resolveRequestedSkillKeys: vi.fn(),+}));++const mockWorkspaceOperationService = vi.hoisted(() => ({}));+const mockLogActivity = vi.hoisted(() => vi.fn());+const mockGetTelemetryClient = vi.hoisted(() => vi.fn());++vi.mock("@paperclipai/shared/telemetry", () => ({+ trackAgentCreated: vi.fn(),+ trackErrorHandlerCrash: vi.fn(),+}));++vi.mock("../telemetry.js", () => ({+ getTelemetryClient: mockGetTelemetryClient,+}));++vi.mock("../services/index.js", () => ({+ agentService: () => mockAgentService,+ agentInstructionsService: () => mockAgentInstructionsService,+ accessService: () => mockAccessService,+ approvalService: () => mockApprovalService,+ companySkillService: () => mockCompanySkillService,+ budgetService: () => mockBudgetService,+ heartbeatService: () => mockHeartbeatService,+ issueApprovalService: () => mockIssueApprovalService,+ issueService: () => mockIssueService,+ logActivity: mockLogActivity,+ secretService: () => mockSecretService,+ syncInstructionsBundleConfigFromFilePath: vi.fn((_agent, config) => config),+ workspaceOperationService: () => mockWorkspaceOperationService,+}));++vi.mock("../services/instance-settings.js", () => ({+ instanceSettingsService: () => ({+ getGeneral: vi.fn(async () => ({ censorUsernameInLogs: false })),+ }),+}));++function createApp(actor: Record<string, unknown>) {+ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ (req as any).actor = actor;+ next();+ });+ app.use("/api", agentRoutes({} as any));+ app.use(errorHandler);+ return app;+}++describe("agent cross-tenant route authorization", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ mockGetTelemetryClient.mockReturnValue({ track: vi.fn() });+ mockAgentService.getById.mockResolvedValue(baseAgent);+ mockAgentService.pause.mockResolvedValue(baseAgent);+ mockAgentService.resume.mockResolvedValue(baseAgent);+ mockAgentService.terminate.mockResolvedValue(baseAgent);+ mockAgentService.remove.mockResolvedValue(baseAgent);+ mockAgentService.listKeys.mockResolvedValue([]);+ mockAgentService.createApiKey.mockResolvedValue({+ id: keyId,+ name: baseKey.name,+ token: "pcp_test_token",+ createdAt: baseKey.createdAt,+ });+ mockAgentService.getKeyById.mockResolvedValue(baseKey);+ mockAgentService.revokeKey.mockResolvedValue({+ ...baseKey,+ revokedAt: new Date("2026-04-11T00:05:00.000Z"),+ });+ mockHeartbeatService.cancelActiveForAgent.mockResolvedValue(undefined);+ mockLogActivity.mockResolvedValue(undefined);+ });++ it("rejects cross-tenant board pause before mutating the agent", async () => {+ const app = createApp({+ type: "board",+ userId: "mallory",+ companyIds: [],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app).post(`/api/agents/${agentId}/pause`).send({});++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("User does not have access to this company");+ expect(mockAgentService.getById).toHaveBeenCalledWith(agentId);+ expect(mockAgentService.pause).not.toHaveBeenCalled();+ expect(mockHeartbeatService.cancelActiveForAgent).not.toHaveBeenCalled();+ });++ it("rejects cross-tenant board key listing before reading any keys", async () => {+ const app = createApp({+ type: "board",+ userId: "mallory",+ companyIds: [],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app).get(`/api/agents/${agentId}/keys`);++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("User does not have access to this company");+ expect(mockAgentService.getById).toHaveBeenCalledWith(agentId);+ expect(mockAgentService.listKeys).not.toHaveBeenCalled();+ });++ it("rejects cross-tenant board key creation before minting a token", async () => {+ const app = createApp({+ type: "board",+ userId: "mallory",+ companyIds: [],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app)+ .post(`/api/agents/${agentId}/keys`)+ .send({ name: "exploit" });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("User does not have access to this company");+ expect(mockAgentService.getById).toHaveBeenCalledWith(agentId);+ expect(mockAgentService.createApiKey).not.toHaveBeenCalled();+ });++ it("rejects cross-tenant board key revocation before touching the key", async () => {+ const app = createApp({+ type: "board",+ userId: "mallory",+ companyIds: [],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app).delete(`/api/agents/${agentId}/keys/${keyId}`);++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("User does not have access to this company");+ expect(mockAgentService.getById).toHaveBeenCalledWith(agentId);+ expect(mockAgentService.getKeyById).not.toHaveBeenCalled();+ expect(mockAgentService.revokeKey).not.toHaveBeenCalled();+ });++ it("requires the key to belong to the route agent before revocation", async () => {+ mockAgentService.getKeyById.mockResolvedValue({+ ...baseKey,+ agentId: "44444444-4444-4444-8444-444444444444",+ });+ mockAccessService.canUser.mockResolvedValue(true);++ const app = createApp({+ type: "board",+ userId: "board-user",+ companyIds: [companyId],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app).delete(`/api/agents/${agentId}/keys/${keyId}`);++ expect(res.status).toBe(404);+ expect(res.body.error).toContain("Key not found");+ expect(mockAgentService.getKeyById).toHaveBeenCalledWith(keyId);+ expect(mockAgentService.revokeKey).not.toHaveBeenCalled();+ });+});diff --git a/server/src/__tests__/agent-permissions-routes.test.ts b/server/src/__tests__/agent-permissions-routes.test.tsindex af9f7658df..bbb0c2a9da 100644--- a/server/src/__tests__/agent-permissions-routes.test.ts+++ b/server/src/__tests__/agent-permissions-routes.test.ts@@ -205,6 +205,196 @@ describe("agent permission routes", () => {mockLogActivity.mockResolvedValue(undefined);});+ it("redacts agent detail for authenticated company members without agent admin permission", async () => {+ mockAccessService.canUser.mockResolvedValue(false);++ const app = await createApp({+ type: "board",+ userId: "member-user",+ source: "session",+ isInstanceAdmin: false,+ companyIds: [companyId],+ });++ const res = await request(app).get(`/api/agents/${agentId}`);++ expect(res.status).toBe(200);+ expect(res.body.adapterConfig).toEqual({});+ expect(res.body.runtimeConfig).toEqual({});+ });++ it("redacts company agent list for authenticated company members without agent admin permission", async () => {+ mockAccessService.canUser.mockResolvedValue(false);++ const app = await createApp({+ type: "board",+ userId: "member-user",+ source: "session",+ isInstanceAdmin: false,+ companyIds: [companyId],+ });++ const res = await request(app).get(`/api/companies/${companyId}/agents`);++ expect(res.status).toBe(200);+ expect(res.body).toEqual([+ expect.objectContaining({+ id: agentId,+ adapterConfig: {},+ runtimeConfig: {},+ }),+ ]);+ });++ it("blocks agent updates for authenticated company members without agent admin permission", async () => {+ mockAccessService.canUser.mockResolvedValue(false);++ const app = await createApp({+ type: "board",+ userId: "member-user",+ source: "session",+ isInstanceAdmin: false,+ companyIds: [companyId],+ });++ const res = await request(app)+ .patch(`/api/agents/${agentId}`)+ .send({ title: "Compromised" });++ expect(res.status).toBe(403);+ });++ it("blocks api key creation for authenticated company members without agent admin permission", async () => {+ mockAccessService.canUser.mockResolvedValue(false);++ const app = await createApp({+ type: "board",+ userId: "member-user",+ source: "session",+ isInstanceAdmin: false,+ companyIds: [companyId],+ });++ const res = await request(app)+ .post(`/api/agents/${agentId}/keys`)+ .send({ name: "backdoor" });++ expect(res.status).toBe(403);+ });++ it("blocks wakeups for authenticated company members without agent admin permission", async () => {+ mockAccessService.canUser.mockResolvedValue(false);++ const app = await createApp({+ type: "board",+ userId: "member-user",+ source: "session",+ isInstanceAdmin: false,+ companyIds: [companyId],+ });++ const res = await request(app)+ .post(`/api/agents/${agentId}/wakeup`)+ .send({});++ expect(res.status).toBe(403);+ });++ it("blocks agent-authenticated self-updates that set host-executed workspace commands", async () => {+ const app = await createApp({+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/agents/${agentId}`)+ .send({+ adapterConfig: {+ workspaceStrategy: {+ type: "git_worktree",+ provisionCommand: "touch /tmp/paperclip-rce",+ },+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it("blocks agent-authenticated self-updates that set instructions bundle roots", async () => {+ const app = await createApp({+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/agents/${agentId}`)+ .send({+ adapterConfig: {+ instructionsRootPath: "/etc",+ instructionsEntryFile: "passwd",+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("instructions path or bundle configuration");+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it("blocks agent-authenticated instructions-path updates", async () => {+ const app = await createApp({+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/agents/${agentId}/instructions-path`)+ .send({ path: "/etc/passwd" });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("instructions path or bundle configuration");+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it("blocks agent-authenticated hires that set instructions bundle config", async () => {+ mockAccessService.hasPermission.mockResolvedValue(true);++ const app = await createApp({+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .post(`/api/companies/${companyId}/agent-hires`)+ .send({+ name: "Injected",+ role: "engineer",+ adapterType: "codex_local",+ adapterConfig: {+ instructionsRootPath: "/etc",+ instructionsEntryFile: "passwd",+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("instructions path or bundle configuration");+ expect(mockAgentService.create).not.toHaveBeenCalled();+ expect(mockLogActivity).not.toHaveBeenCalled();+ });+it("grants tasks:assign by default when board creates a new agent", async () => {const app = await createApp({type: "board",diff --git a/server/src/__tests__/app-private-hostname-gate.test.ts b/server/src/__tests__/app-private-hostname-gate.test.tsnew file mode 100644index 0000000000..cf60a1b542--- /dev/null+++ b/server/src/__tests__/app-private-hostname-gate.test.ts@@ -0,0 +1,32 @@+import { describe, expect, it } from "vitest";+import { shouldEnablePrivateHostnameGuard } from "../app.ts";++describe("shouldEnablePrivateHostnameGuard", () => {+ it("enables the hostname guard for local_trusted private deployments", () => {+ expect(shouldEnablePrivateHostnameGuard({+ deploymentMode: "local_trusted",+ deploymentExposure: "private",+ })).toBe(true);+ });++ it("does not enable the hostname guard for local_trusted public deployments", () => {+ expect(shouldEnablePrivateHostnameGuard({+ deploymentMode: "local_trusted",+ deploymentExposure: "public",+ })).toBe(false);+ });++ it("enables the hostname guard for authenticated private deployments", () => {+ expect(shouldEnablePrivateHostnameGuard({+ deploymentMode: "authenticated",+ deploymentExposure: "private",+ })).toBe(true);+ });++ it("does not enable the hostname guard for authenticated public deployments", () => {+ expect(shouldEnablePrivateHostnameGuard({+ deploymentMode: "authenticated",+ deploymentExposure: "public",+ })).toBe(false);+ });+});diff --git a/server/src/__tests__/approval-routes-idempotency.test.ts b/server/src/__tests__/approval-routes-idempotency.test.tsindex 338bfe3279..d87561a9a0 100644--- a/server/src/__tests__/approval-routes-idempotency.test.ts+++ b/server/src/__tests__/approval-routes-idempotency.test.ts@@ -196,6 +196,90 @@ describe("approval routes idempotent retries", () => {expect(mockApprovalService.requestRevision).not.toHaveBeenCalled();});+ it("derives approval attribution from the authenticated actor on approve", async () => {+ mockApprovalService.getById.mockResolvedValue({+ id: "approval-4",+ companyId: "company-1",+ type: "hire_agent",+ status: "pending",+ payload: {},+ requestedByAgentId: null,+ });+ mockApprovalService.approve.mockResolvedValue({+ approval: {+ id: "approval-4",+ companyId: "company-1",+ type: "hire_agent",+ status: "approved",+ payload: {},+ requestedByAgentId: null,+ },+ applied: true,+ });++ const res = await request(await createApp())+ .post("/api/approvals/approval-4/approve")+ .send({ decidedByUserId: "forged-user", decisionNote: "ship it" });++ expect(res.status).toBe(200);+ expect(mockApprovalService.approve).toHaveBeenCalledWith("approval-4", "user-1", "ship it");+ });++ it("derives approval attribution from the authenticated actor on reject", async () => {+ mockApprovalService.getById.mockResolvedValue({+ id: "approval-5",+ companyId: "company-1",+ type: "hire_agent",+ status: "pending",+ payload: {},+ });+ mockApprovalService.reject.mockResolvedValue({+ approval: {+ id: "approval-5",+ companyId: "company-1",+ type: "hire_agent",+ status: "rejected",+ payload: {},+ },+ applied: true,+ });++ const res = await request(await createApp())+ .post("/api/approvals/approval-5/reject")+ .send({ decidedByUserId: "forged-user", decisionNote: "not now" });++ expect(res.status).toBe(200);+ expect(mockApprovalService.reject).toHaveBeenCalledWith("approval-5", "user-1", "not now");+ });++ it("derives approval attribution from the authenticated actor on request revision", async () => {+ mockApprovalService.getById.mockResolvedValue({+ id: "approval-6",+ companyId: "company-1",+ type: "hire_agent",+ status: "pending",+ payload: {},+ });+ mockApprovalService.requestRevision.mockResolvedValue({+ id: "approval-6",+ companyId: "company-1",+ type: "hire_agent",+ status: "revision_requested",+ payload: {},+ });++ const res = await request(await createApp())+ .post("/api/approvals/approval-6/request-revision")+ .send({ decidedByUserId: "forged-user", decisionNote: "Need changes" });++ expect(res.status).toBe(200);+ expect(mockApprovalService.requestRevision).toHaveBeenCalledWith(+ "approval-6",+ "user-1",+ "Need changes",+ );+ });+it("lets agents create generic issue-linked board approval requests", async () => {mockApprovalService.create.mockResolvedValue({id: "approval-1",diff --git a/server/src/__tests__/cli-auth-routes.test.ts b/server/src/__tests__/cli-auth-routes.test.tsindex 006321d279..121d959d70 100644--- a/server/src/__tests__/cli-auth-routes.test.ts+++ b/server/src/__tests__/cli-auth-routes.test.ts@@ -45,7 +45,7 @@ function registerModuleMocks() {}));}-async function createApp(actor: any) {+async function createApp(actor: any, db: any = {} as any) {const [{ accessRoutes }, { errorHandler }] = await Promise.all([vi.importActual<typeof import("../routes/access.js")>("../routes/access.js"),vi.importActual<typeof import("../middleware/index.js")>("../middleware/index.js"),@@ -58,7 +58,7 @@ async function createApp(actor: any) {});app.use("/api",- accessRoutes({} as any, {+ accessRoutes(db, {deploymentMode: "authenticated",deploymentExposure: "private",bindHost: "127.0.0.1",@@ -101,14 +101,56 @@ describe("cli auth routes", () => {expect(res.body).toMatchObject({id: "challenge-1",token: "pcp_cli_auth_secret",- boardApiToken: "pcp_board_token",approvalPath: "/cli-auth/challenge-1?token=pcp_cli_auth_secret",pollPath: "/cli-auth/challenges/challenge-1",expiresAt: "2026-03-23T13:00:00.000Z",});+ expect(res.body.boardApiToken).toBe("pcp_board_token");expect(res.body.approvalUrl).toContain("/cli-auth/challenge-1?token=pcp_cli_auth_secret");});+ it("rejects anonymous access to generic skill documents", async () => {+ const app = await createApp({ type: "none", source: "none" });+ const [indexRes, skillRes] = await Promise.all([+ request(app).get("/api/skills/index"),+ request(app).get("/api/skills/paperclip"),+ ]);++ expect(indexRes.status).toBe(401);+ expect(skillRes.status).toBe(401);+ });++ it("serves the invite-scoped paperclip skill anonymously for active invites", async () => {+ const invite = {+ id: "invite-1",+ companyId: "company-1",+ inviteType: "company_join",+ allowedJoinTypes: "agent",+ tokenHash: "hash",+ defaultsPayload: null,+ expiresAt: new Date(Date.now() + 60_000),+ invitedByUserId: null,+ revokedAt: null,+ acceptedAt: null,+ createdAt: new Date(),+ updatedAt: new Date(),+ };+ const db = {+ select: vi.fn(() => ({+ from: vi.fn(() => ({+ where: vi.fn().mockResolvedValue([invite]),+ })),+ })),+ };++ const app = await createApp({ type: "none", source: "none" }, db);+ const res = await request(app).get("/api/invites/token-123/skills/paperclip");++ expect(res.status).toBe(200);+ expect(res.headers["content-type"]).toContain("text/markdown");+ expect(res.text).toContain("# Paperclip Skill");+ });+it("marks challenge status as requiring sign-in for anonymous viewers", async () => {mockBoardAuthService.describeCliAuthChallenge.mockResolvedValue({id: "challenge-1",diff --git a/server/src/__tests__/company-portability.test.ts b/server/src/__tests__/company-portability.test.tsindex b43f7b4482..f7a6e88be1 100644--- a/server/src/__tests__/company-portability.test.ts+++ b/server/src/__tests__/company-portability.test.ts@@ -59,6 +59,11 @@ const assetSvc = {create: vi.fn(),};+const secretSvc = {+ normalizeAdapterConfigForPersistence: vi.fn(async (_companyId: string, config: Record<string, unknown>) => config),+ resolveAdapterConfigForRuntime: vi.fn(async (_companyId: string, config: Record<string, unknown>) => ({ config, secretKeys: new Set<string>() })),+};+const agentInstructionsSvc = {exportFiles: vi.fn(),materializeManagedBundle: vi.fn(),@@ -96,6 +101,10 @@ vi.mock("../services/assets.js", () => ({assetService: () => assetSvc,}));+vi.mock("../services/secrets.js", () => ({+ secretService: () => secretSvc,+}));+vi.mock("../services/agent-instructions.js", () => ({agentInstructionsService: () => agentInstructionsSvc,}));@@ -117,6 +126,11 @@ describe("company portability", () => {beforeEach(() => {vi.clearAllMocks();+ secretSvc.normalizeAdapterConfigForPersistence.mockImplementation(async (_companyId, config) => config);+ secretSvc.resolveAdapterConfigForRuntime.mockImplementation(async (_companyId, config) => ({+ config,+ secretKeys: new Set<string>(),+ }));companySvc.getById.mockResolvedValue({id: "company-1",name: "Paperclip",@@ -127,6 +141,11 @@ describe("company portability", () => {logoUrl: null,requireBoardApprovalForNewAgents: true,});+ companySvc.create.mockResolvedValue({+ id: "company-imported",+ name: "Imported Paperclip",+ requireBoardApprovalForNewAgents: true,+ });agentSvc.list.mockResolvedValue([{id: "agent-1",@@ -1509,7 +1528,7 @@ describe("company portability", () => {}),]);- await portability.importBundle({+ const result = await portability.importBundle({source: { type: "inline", rootPath: "paperclip-demo", files },include: { company: true, agents: true, projects: true, issues: true, skills: false },target: { mode: "new_company", newCompanyName: "Imported Paperclip" },@@ -1520,12 +1539,15 @@ describe("company portability", () => {expect(routineSvc.create).toHaveBeenCalledWith("company-imported", expect.objectContaining({projectId: "project-created",title: "Monday Review",- assigneeAgentId: "agent-created",+ assigneeAgentId: null,priority: "high",status: "paused",concurrencyPolicy: "always_enqueue",catchUpPolicy: "enqueue_missed_with_cap",}), expect.any(Object));+ expect(result.warnings).toContain(+ "Task monday-review assignee claudecoder is pending_approval; imported work was left unassigned.",+ );expect(routineSvc.createTrigger).toHaveBeenCalledTimes(2);expect(routineSvc.createTrigger).toHaveBeenCalledWith("routine-created", expect.objectContaining({kind: "schedule",@@ -2418,4 +2440,178 @@ describe("company portability", () => {expect(nestedMaterializedFiles?.["AGENTS.md"]).not.toMatch(/^---\n/);expect(nestedMaterializedFiles?.["AGENTS.md"]).not.toContain('name: "ClaudeCoder"');});++ it("rejects dangerous adapter types on agent-safe imports", async () => {+ const portability = companyPortabilityService({} as any);+ const exported = await portability.exportBundle("company-1", {+ include: {+ company: true,+ agents: true,+ projects: false,+ issues: false,+ },+ });++ agentSvc.list.mockResolvedValue([]);++ await expect(portability.importBundle({+ source: {+ type: "inline",+ rootPath: exported.rootPath,+ files: exported.files,+ },+ include: {+ company: false,+ agents: true,+ projects: false,+ issues: false,+ },+ target: {+ mode: "existing_company",+ companyId: "company-1",+ },+ agents: ["claudecoder"],+ collisionStrategy: "rename",+ adapterOverrides: {+ claudecoder: {+ adapterType: "process",+ adapterConfig: {+ command: "/bin/sh",+ args: ["-c", "id"],+ },+ },+ },+ }, "user-1", {+ mode: "agent_safe",+ sourceCompanyId: "company-1",+ })).rejects.toThrow('Adapter type "process" is not allowed in safe imports');++ expect(agentSvc.create).not.toHaveBeenCalled();+ });++ it("imports new agents through approval and adapter-config normalization", async () => {+ const portability = companyPortabilityService({} as any);+ const exported = await portability.exportBundle("company-1", {+ include: {+ company: true,+ agents: true,+ projects: false,+ issues: false,+ },+ });++ agentSvc.list.mockResolvedValue([]);+ secretSvc.normalizeAdapterConfigForPersistence.mockResolvedValueOnce({+ normalized: true,+ env: {+ OPENAI_API_KEY: {+ type: "secret_ref",+ secretId: "secret-1",+ version: "latest",+ },+ },+ });+ agentSvc.create.mockImplementation(async (_companyId: string, input: Record<string, unknown>) => ({+ id: "agent-created",+ name: String(input.name),+ adapterType: input.adapterType,+ adapterConfig: input.adapterConfig,+ status: input.status,+ }));++ await portability.importBundle({+ source: {+ type: "inline",+ rootPath: exported.rootPath,+ files: exported.files,+ },+ include: {+ company: true,+ agents: true,+ projects: false,+ issues: false,+ },+ target: {+ mode: "new_company",+ newCompanyName: "Imported Paperclip",+ },+ agents: ["claudecoder"],+ collisionStrategy: "rename",+ }, "user-1");++ expect(secretSvc.normalizeAdapterConfigForPersistence).toHaveBeenCalledWith(+ "company-imported",+ expect.any(Object),+ { strictMode: false },+ );+ expect(agentSvc.create).toHaveBeenCalledWith("company-imported", expect.objectContaining({+ adapterType: "claude_local",+ adapterConfig: expect.objectContaining({+ normalized: true,+ }),+ status: "pending_approval",+ }));+ });++ it("normalizes adapter config on replace imports before updating existing agents", async () => {+ const portability = companyPortabilityService({} as any);+ const exported = await portability.exportBundle("company-1", {+ include: {+ company: true,+ agents: true,+ projects: false,+ issues: false,+ },+ });++ secretSvc.normalizeAdapterConfigForPersistence.mockResolvedValueOnce({+ normalized: "updated",+ });+ agentSvc.update.mockImplementation(async (id: string, patch: Record<string, unknown>) => ({+ id,+ name: "ClaudeCoder",+ adapterType: patch.adapterType,+ adapterConfig: patch.adapterConfig,+ }));++ await portability.importBundle({+ source: {+ type: "inline",+ rootPath: exported.rootPath,+ files: exported.files,+ },+ include: {+ company: false,+ agents: true,+ projects: false,+ issues: false,+ },+ target: {+ mode: "existing_company",+ companyId: "company-1",+ },+ agents: ["claudecoder"],+ collisionStrategy: "replace",+ adapterOverrides: {+ claudecoder: {+ adapterType: "codex_local",+ adapterConfig: {+ model: "gpt-5.4",+ },+ },+ },+ }, "user-1");++ expect(secretSvc.normalizeAdapterConfigForPersistence).toHaveBeenCalledWith(+ "company-1",+ expect.any(Object),+ { strictMode: false },+ );+ expect(agentSvc.update).toHaveBeenCalledWith("agent-1", expect.objectContaining({+ adapterType: "codex_local",+ adapterConfig: {+ normalized: "updated",+ },+ }));+ });});diff --git a/server/src/__tests__/health.test.ts b/server/src/__tests__/health.test.tsindex ce3c002a0e..e941776ee8 100644--- a/server/src/__tests__/health.test.ts+++ b/server/src/__tests__/health.test.ts@@ -34,7 +34,7 @@ describe("GET /health", () => {const res = await request(app).get("/health");expect(res.status).toBe(200);expect(res.body).toEqual({ status: "ok", version: serverVersion });- });+ }, 15_000);it("returns 200 when the database probe succeeds", async () => {const db = {@@ -63,4 +63,120 @@ describe("GET /health", () => {error: "database_unreachable",});});++ it("redacts detailed metadata for anonymous requests in authenticated mode", async () => {+ const devServerStatus = await import("../dev-server-status.js");+ vi.spyOn(devServerStatus, "readPersistedDevServerStatus").mockReturnValue(undefined);+ const { healthRoutes } = await import("../routes/health.js");+ const db = {+ execute: vi.fn().mockResolvedValue([{ "?column?": 1 }]),+ select: vi.fn(() => ({+ from: vi.fn(() => ({+ where: vi.fn().mockResolvedValue([{ count: 1 }]),+ })),+ })),+ } as unknown as Db;+ const app = express();+ app.use((req, _res, next) => {+ (req as any).actor = { type: "none", source: "none" };+ next();+ });+ app.use(+ "/health",+ healthRoutes(db, {+ deploymentMode: "authenticated",+ deploymentExposure: "public",+ authReady: true,+ companyDeletionEnabled: false,+ }),+ );++ const res = await request(app).get("/health");++ expect(res.status).toBe(200);+ expect(res.body).toEqual({+ status: "ok",+ deploymentMode: "authenticated",+ bootstrapStatus: "ready",+ bootstrapInviteActive: false,+ });+ });++ it("redacts detailed metadata when authenticated mode is reached without auth middleware", async () => {+ const devServerStatus = await import("../dev-server-status.js");+ vi.spyOn(devServerStatus, "readPersistedDevServerStatus").mockReturnValue(undefined);+ const { healthRoutes } = await import("../routes/health.js");+ const db = {+ execute: vi.fn().mockResolvedValue([{ "?column?": 1 }]),+ select: vi.fn(() => ({+ from: vi.fn(() => ({+ where: vi.fn().mockResolvedValue([{ count: 1 }]),+ })),+ })),+ } as unknown as Db;+ const app = express();+ app.use(+ "/health",+ healthRoutes(db, {+ deploymentMode: "authenticated",+ deploymentExposure: "public",+ authReady: true,+ companyDeletionEnabled: false,+ }),+ );++ const res = await request(app).get("/health");++ expect(res.status).toBe(200);+ expect(res.body).toEqual({+ status: "ok",+ deploymentMode: "authenticated",+ bootstrapStatus: "ready",+ bootstrapInviteActive: false,+ });+ });++ it("keeps detailed metadata for authenticated requests in authenticated mode", async () => {+ const devServerStatus = await import("../dev-server-status.js");+ vi.spyOn(devServerStatus, "readPersistedDevServerStatus").mockReturnValue(undefined);+ const { healthRoutes } = await import("../routes/health.js");+ const db = {+ execute: vi.fn().mockResolvedValue([{ "?column?": 1 }]),+ select: vi.fn(() => ({+ from: vi.fn(() => ({+ where: vi.fn().mockResolvedValue([{ count: 1 }]),+ })),+ })),+ } as unknown as Db;+ const app = express();+ app.use((req, _res, next) => {+ (req as any).actor = { type: "board", userId: "user-1", source: "session" };+ next();+ });+ app.use(+ "/health",+ healthRoutes(db, {+ deploymentMode: "authenticated",+ deploymentExposure: "public",+ authReady: true,+ companyDeletionEnabled: false,+ }),+ );++ const res = await request(app).get("/health");++ expect(res.status).toBe(200);+ expect(res.body).toMatchObject({+ status: "ok",+ version: serverVersion,+ deploymentMode: "authenticated",+ deploymentExposure: "public",+ authReady: true,+ bootstrapStatus: "ready",+ bootstrapInviteActive: false,+ features: {+ companyDeletionEnabled: false,+ },+ });+ });});diff --git a/server/src/__tests__/invite-onboarding-text.test.ts b/server/src/__tests__/invite-onboarding-text.test.tsindex 8ba30115bc..fae84a6371 100644--- a/server/src/__tests__/invite-onboarding-text.test.ts+++ b/server/src/__tests__/invite-onboarding-text.test.ts@@ -41,6 +41,7 @@ describe("buildInviteOnboardingTextDocument", () => {expect(text).toContain("/api/invites/token-123/accept");expect(text).toContain("/api/join-requests/{requestId}/claim-api-key");expect(text).toContain("/api/invites/token-123/onboarding.txt");+ expect(text).toContain("/api/invites/token-123/skills/paperclip");expect(text).toContain("Suggested Paperclip base URLs to try");expect(text).toContain("http://localhost:3100");expect(text).toContain("host.docker.internal");diff --git a/server/src/__tests__/issue-comment-reopen-routes.test.ts b/server/src/__tests__/issue-comment-reopen-routes.test.tsindex 1c887138f5..2ef3388634 100644--- a/server/src/__tests__/issue-comment-reopen-routes.test.ts+++ b/server/src/__tests__/issue-comment-reopen-routes.test.ts@@ -148,7 +148,7 @@ async function normalizePolicy(input: {return normalizeIssueExecutionPolicy(input);}-function makeIssue(status: "todo" | "done") {+function makeIssue(status: "todo" | "done" | "blocked") {return {id: "11111111-1111-4111-8111-111111111111",companyId: "company-1",@@ -430,6 +430,34 @@ describe("issue comment reopen routes", () => {expect(res.status).toBe(201);expect(mockIssueService.update).not.toHaveBeenCalled();});++ it("wakes the assignee when an assigned blocked issue moves back to todo", async () => {+ const issue = makeIssue("blocked");+ mockIssueService.getById.mockResolvedValue(issue);+ mockIssueService.update.mockImplementation(async (_id: string, patch: Record<string, unknown>) => ({+ ...issue,+ ...patch,+ updatedAt: new Date(),+ }));++ const res = await request(await installActor(createApp()))+ .patch("/api/issues/11111111-1111-4111-8111-111111111111")+ .send({ status: "todo" });++ expect(res.status).toBe(200);+ expect(mockHeartbeatService.wakeup).toHaveBeenCalledWith(+ "22222222-2222-4222-8222-222222222222",+ expect.objectContaining({+ source: "automation",+ triggerDetail: "system",+ reason: "issue_status_changed",+ payload: expect.objectContaining({+ issueId: "11111111-1111-4111-8111-111111111111",+ mutation: "update",+ }),+ }),+ );+ });it("interrupts an active run before a combined comment update", async () => {const issue = {...makeIssue("todo"),diff --git a/server/src/__tests__/issue-workspace-command-authz.test.ts b/server/src/__tests__/issue-workspace-command-authz.test.tsnew file mode 100644index 0000000000..cf9a7847b0--- /dev/null+++ b/server/src/__tests__/issue-workspace-command-authz.test.ts@@ -0,0 +1,165 @@+import express from "express";+import request from "supertest";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { errorHandler } from "../middleware/index.js";+import { issueRoutes } from "../routes/issues.js";++const mockIssueService = vi.hoisted(() => ({+ addComment: vi.fn(),+ assertCheckoutOwner: vi.fn(),+ create: vi.fn(),+ findMentionedAgents: vi.fn(),+ getByIdentifier: vi.fn(),+ getById: vi.fn(),+ getRelationSummaries: vi.fn(),+ getWakeableParentAfterChildCompletion: vi.fn(),+ listWakeableBlockedDependents: vi.fn(),+ update: vi.fn(),+}));++vi.mock("../services/index.js", () => ({+ accessService: () => ({+ canUser: vi.fn(async () => true),+ hasPermission: vi.fn(async () => true),+ }),+ agentService: () => ({+ getById: vi.fn(async () => null),+ }),+ documentService: () => ({}),+ executionWorkspaceService: () => ({+ getById: vi.fn(async () => null),+ }),+ feedbackService: () => ({+ listIssueVotesForUser: vi.fn(async () => []),+ saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })),+ }),+ goalService: () => ({}),+ heartbeatService: () => ({+ wakeup: vi.fn(async () => undefined),+ reportRunActivity: vi.fn(async () => undefined),+ getRun: vi.fn(async () => null),+ getActiveRunForAgent: vi.fn(async () => null),+ cancelRun: vi.fn(async () => null),+ }),+ instanceSettingsService: () => ({+ get: vi.fn(async () => ({+ id: "instance-settings-1",+ general: {+ censorUsernameInLogs: false,+ feedbackDataSharingPreference: "prompt",+ },+ })),+ listCompanyIds: vi.fn(async () => ["company-1"]),+ }),+ issueApprovalService: () => ({}),+ issueService: () => mockIssueService,+ logActivity: vi.fn(async () => undefined),+ projectService: () => ({}),+ routineService: () => ({+ syncRunStatusForIssue: vi.fn(async () => undefined),+ }),+ workProductService: () => ({}),+}));++function createApp(actor: Record<string, unknown>) {+ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ (req as any).actor = actor;+ next();+ });+ app.use("/api", issueRoutes({} as any, {} as any));+ app.use(errorHandler);+ return app;+}++function makeIssue(overrides: Record<string, unknown> = {}) {+ return {+ id: "issue-1",+ companyId: "company-1",+ status: "todo",+ priority: "medium",+ projectId: null,+ goalId: null,+ parentId: null,+ assigneeAgentId: null,+ assigneeUserId: null,+ createdByUserId: "board-user",+ identifier: "PAP-1000",+ title: "Workspace authz",+ executionPolicy: null,+ executionState: null,+ executionWorkspaceId: null,+ hiddenAt: null,+ ...overrides,+ };+}++describe("issue workspace command authorization", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ mockIssueService.addComment.mockResolvedValue(null);+ mockIssueService.create.mockResolvedValue(makeIssue());+ mockIssueService.findMentionedAgents.mockResolvedValue([]);+ mockIssueService.getByIdentifier.mockResolvedValue(null);+ mockIssueService.getRelationSummaries.mockResolvedValue({ blockedBy: [], blocks: [] });+ mockIssueService.getWakeableParentAfterChildCompletion.mockResolvedValue(null);+ mockIssueService.listWakeableBlockedDependents.mockResolvedValue([]);+ mockIssueService.assertCheckoutOwner.mockResolvedValue({ adoptedFromRunId: null });+ mockIssueService.update.mockResolvedValue(makeIssue());+ });++ it("rejects agent callers that create issue workspace provision commands", async () => {+ const app = createApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .post("/api/companies/company-1/issues")+ .send({+ title: "Exploit",+ executionWorkspaceSettings: {+ workspaceStrategy: {+ type: "git_worktree",+ provisionCommand: "touch /tmp/paperclip-rce",+ },+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockIssueService.create).not.toHaveBeenCalled();+ });++ it("rejects agent callers that patch assignee adapter workspace teardown commands", async () => {+ mockIssueService.getById.mockResolvedValue(makeIssue());+ const app = createApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch("/api/issues/issue-1")+ .send({+ assigneeAdapterOverrides: {+ adapterConfig: {+ workspaceStrategy: {+ type: "git_worktree",+ teardownCommand: "rm -rf /tmp/paperclip-rce",+ },+ },+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockIssueService.update).not.toHaveBeenCalled();+ });+});diff --git a/server/src/__tests__/plugin-routes-authz.test.ts b/server/src/__tests__/plugin-routes-authz.test.tsnew file mode 100644index 0000000000..3150a18225--- /dev/null+++ b/server/src/__tests__/plugin-routes-authz.test.ts@@ -0,0 +1,168 @@+import express from "express";+import request from "supertest";+import { beforeEach, describe, expect, it, vi } from "vitest";++const mockRegistry = vi.hoisted(() => ({+ getById: vi.fn(),+ getByKey: vi.fn(),+}));++const mockLifecycle = vi.hoisted(() => ({+ load: vi.fn(),+ upgrade: vi.fn(),+}));++vi.mock("../services/plugin-registry.js", () => ({+ pluginRegistryService: () => mockRegistry,+}));++vi.mock("../services/plugin-lifecycle.js", () => ({+ pluginLifecycleManager: () => mockLifecycle,+}));++vi.mock("../services/activity-log.js", () => ({+ logActivity: vi.fn(),+}));++vi.mock("../services/live-events.js", () => ({+ publishGlobalLiveEvent: vi.fn(),+}));++async function createApp(actor: Record<string, unknown>, loaderOverrides: Record<string, unknown> = {}) {+ const [{ pluginRoutes }, { errorHandler }] = await Promise.all([+ import("../routes/plugins.js"),+ import("../middleware/index.js"),+ ]);++ const loader = {+ installPlugin: vi.fn(),+ ...loaderOverrides,+ };++ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ req.actor = actor as typeof req.actor;+ next();+ });+ app.use("/api", pluginRoutes({} as never, loader as never));+ app.use(errorHandler);++ return { app, loader };+}++describe("plugin install and upgrade authz", () => {+ beforeEach(() => {+ vi.resetAllMocks();+ });++ it("rejects plugin installation for non-admin board users", async () => {+ const { app, loader } = await createApp({+ type: "board",+ userId: "user-1",+ source: "session",+ isInstanceAdmin: false,+ companyIds: ["company-1"],+ });++ const res = await request(app)+ .post("/api/plugins/install")+ .send({ packageName: "paperclip-plugin-example" });++ expect(res.status).toBe(403);+ expect(loader.installPlugin).not.toHaveBeenCalled();+ }, 20_000);++ it("allows instance admins to install plugins", async () => {+ const pluginId = "11111111-1111-4111-8111-111111111111";+ const pluginKey = "paperclip.example";+ const discovered = {+ manifest: {+ id: pluginKey,+ },+ };++ mockRegistry.getByKey.mockResolvedValue({+ id: pluginId,+ pluginKey,+ packageName: "paperclip-plugin-example",+ version: "1.0.0",+ });+ mockRegistry.getById.mockResolvedValue({+ id: pluginId,+ pluginKey,+ packageName: "paperclip-plugin-example",+ version: "1.0.0",+ });+ mockLifecycle.load.mockResolvedValue(undefined);++ const { app, loader } = await createApp(+ {+ type: "board",+ userId: "admin-1",+ source: "session",+ isInstanceAdmin: true,+ companyIds: [],+ },+ { installPlugin: vi.fn().mockResolvedValue(discovered) },+ );++ const res = await request(app)+ .post("/api/plugins/install")+ .send({ packageName: "paperclip-plugin-example" });++ expect(res.status).toBe(200);+ expect(loader.installPlugin).toHaveBeenCalledWith({+ packageName: "paperclip-plugin-example",+ version: undefined,+ });+ expect(mockLifecycle.load).toHaveBeenCalledWith(pluginId);+ }, 20_000);++ it("rejects plugin upgrades for non-admin board users", async () => {+ const pluginId = "11111111-1111-4111-8111-111111111111";+ const { app } = await createApp({+ type: "board",+ userId: "user-1",+ source: "session",+ isInstanceAdmin: false,+ companyIds: ["company-1"],+ });++ const res = await request(app)+ .post(`/api/plugins/${pluginId}/upgrade`)+ .send({});++ expect(res.status).toBe(403);+ expect(mockRegistry.getById).not.toHaveBeenCalled();+ expect(mockLifecycle.upgrade).not.toHaveBeenCalled();+ }, 20_000);++ it("allows instance admins to upgrade plugins", async () => {+ const pluginId = "11111111-1111-4111-8111-111111111111";+ mockRegistry.getById.mockResolvedValue({+ id: pluginId,+ pluginKey: "paperclip.example",+ version: "1.0.0",+ });+ mockLifecycle.upgrade.mockResolvedValue({+ id: pluginId,+ version: "1.1.0",+ });++ const { app } = await createApp({+ type: "board",+ userId: "admin-1",+ source: "session",+ isInstanceAdmin: true,+ companyIds: [],+ });++ const res = await request(app)+ .post(`/api/plugins/${pluginId}/upgrade`)+ .send({ version: "1.1.0" });++ expect(res.status).toBe(200);+ expect(mockLifecycle.upgrade).toHaveBeenCalledWith(pluginId, "1.1.0");+ }, 20_000);+});diff --git a/server/src/__tests__/workspace-runtime-routes-authz.test.ts b/server/src/__tests__/workspace-runtime-routes-authz.test.tsnew file mode 100644index 0000000000..de5b490c91--- /dev/null+++ b/server/src/__tests__/workspace-runtime-routes-authz.test.ts@@ -0,0 +1,437 @@+import express from "express";+import request from "supertest";+import { beforeEach, describe, expect, it, vi } from "vitest";++const mockProjectService = vi.hoisted(() => ({+ create: vi.fn(),+ createWorkspace: vi.fn(),+ getById: vi.fn(),+ listWorkspaces: vi.fn(),+ resolveByReference: vi.fn(),+ update: vi.fn(),+ updateWorkspace: vi.fn(),+}));++const mockExecutionWorkspaceService = vi.hoisted(() => ({+ getById: vi.fn(),+ update: vi.fn(),+}));++const mockSecretService = vi.hoisted(() => ({+ normalizeEnvBindingsForPersistence: vi.fn(),+}));++const mockWorkspaceOperationService = vi.hoisted(() => ({}));+const mockLogActivity = vi.hoisted(() => vi.fn());+const mockGetTelemetryClient = vi.hoisted(() => vi.fn());+const mockAssertCanManageProjectWorkspaceRuntimeServices = vi.hoisted(() => vi.fn());+const mockAssertCanManageExecutionWorkspaceRuntimeServices = vi.hoisted(() => vi.fn());++function registerModuleMocks() {+ vi.doMock("../telemetry.js", () => ({+ getTelemetryClient: mockGetTelemetryClient,+ }));++ vi.doMock("../services/index.js", () => ({+ executionWorkspaceService: () => mockExecutionWorkspaceService,+ logActivity: mockLogActivity,+ projectService: () => mockProjectService,+ secretService: () => mockSecretService,+ workspaceOperationService: () => mockWorkspaceOperationService,+ }));++ vi.doMock("../services/workspace-runtime.js", () => ({+ cleanupExecutionWorkspaceArtifacts: vi.fn(),+ startRuntimeServicesForWorkspaceControl: vi.fn(),+ stopRuntimeServicesForExecutionWorkspace: vi.fn(),+ stopRuntimeServicesForProjectWorkspace: vi.fn(),+ }));++ vi.doMock("../routes/workspace-runtime-service-authz.js", () => ({+ assertCanManageProjectWorkspaceRuntimeServices: mockAssertCanManageProjectWorkspaceRuntimeServices,+ assertCanManageExecutionWorkspaceRuntimeServices: mockAssertCanManageExecutionWorkspaceRuntimeServices,+ }));+}++async function createProjectApp(actor: Record<string, unknown>) {+ const { projectRoutes } = await import("../routes/projects.js");+ const { errorHandler } = await import("../middleware/index.js");+ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ (req as any).actor = actor;+ next();+ });+ app.use("/api", projectRoutes({} as any));+ app.use(errorHandler);+ return app;+}++async function createExecutionWorkspaceApp(actor: Record<string, unknown>) {+ const { executionWorkspaceRoutes } = await import("../routes/execution-workspaces.js");+ const { errorHandler } = await import("../middleware/index.js");+ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ (req as any).actor = actor;+ next();+ });+ app.use("/api", executionWorkspaceRoutes({} as any));+ app.use(errorHandler);+ return app;+}++function buildProject(overrides: Record<string, unknown> = {}) {+ return {+ id: "project-1",+ companyId: "company-1",+ urlKey: "project-1",+ goalId: null,+ goalIds: [],+ goals: [],+ name: "Project",+ description: null,+ status: "backlog",+ leadAgentId: null,+ targetDate: null,+ color: null,+ env: null,+ pauseReason: null,+ pausedAt: null,+ executionWorkspacePolicy: null,+ codebase: null,+ workspaces: [],+ primaryWorkspace: null,+ archivedAt: null,+ createdAt: new Date(),+ updatedAt: new Date(),+ ...overrides,+ };+}++function buildExecutionWorkspace(overrides: Record<string, unknown> = {}) {+ return {+ id: "workspace-1",+ companyId: "company-1",+ projectId: "project-1",+ projectWorkspaceId: null,+ sourceIssueId: null,+ mode: "isolated_workspace",+ strategyType: "git_worktree",+ name: "Workspace",+ status: "active",+ cwd: "/tmp/workspace",+ repoUrl: null,+ baseRef: "main",+ branchName: "feature/test",+ providerType: "git_worktree",+ providerRef: null,+ derivedFromExecutionWorkspaceId: null,+ lastUsedAt: new Date(),+ openedAt: new Date(),+ closedAt: null,+ cleanupEligibleAt: null,+ cleanupReason: null,+ config: null,+ metadata: null,+ runtimeServices: [],+ createdAt: new Date(),+ updatedAt: new Date(),+ ...overrides,+ };+}++describe("workspace runtime service route authorization", () => {+ const projectId = "11111111-1111-4111-8111-111111111111";+ const workspaceId = "22222222-2222-4222-8222-222222222222";+ const executionWorkspaceId = "33333333-3333-4333-8333-333333333333";++ beforeEach(() => {+ vi.resetModules();+ registerModuleMocks();+ vi.clearAllMocks();+ mockSecretService.normalizeEnvBindingsForPersistence.mockImplementation(async (_companyId, env) => env);+ mockProjectService.resolveByReference.mockResolvedValue({ ambiguous: false, project: null });+ mockProjectService.create.mockResolvedValue(buildProject());+ mockProjectService.update.mockResolvedValue(buildProject());+ mockProjectService.createWorkspace.mockResolvedValue({+ id: workspaceId,+ companyId: "company-1",+ projectId,+ name: "Workspace",+ sourceType: "local_path",+ cwd: "/tmp/project",+ repoUrl: null,+ repoRef: null,+ defaultRef: null,+ visibility: "default",+ setupCommand: null,+ cleanupCommand: null,+ remoteProvider: null,+ remoteWorkspaceRef: null,+ sharedWorkspaceKey: null,+ metadata: null,+ runtimeConfig: null,+ isPrimary: false,+ runtimeServices: [],+ createdAt: new Date(),+ updatedAt: new Date(),+ });+ mockProjectService.listWorkspaces.mockResolvedValue([{+ id: workspaceId,+ companyId: "company-1",+ projectId,+ name: "Workspace",+ sourceType: "local_path",+ cwd: "/tmp/project",+ repoUrl: null,+ repoRef: null,+ defaultRef: null,+ visibility: "default",+ setupCommand: null,+ cleanupCommand: null,+ remoteProvider: null,+ remoteWorkspaceRef: null,+ sharedWorkspaceKey: null,+ metadata: null,+ runtimeConfig: null,+ isPrimary: false,+ runtimeServices: [],+ createdAt: new Date(),+ updatedAt: new Date(),+ }]);+ mockProjectService.updateWorkspace.mockResolvedValue({+ id: workspaceId,+ companyId: "company-1",+ projectId,+ name: "Workspace",+ sourceType: "local_path",+ cwd: "/tmp/project",+ repoUrl: null,+ repoRef: null,+ defaultRef: null,+ visibility: "default",+ setupCommand: null,+ cleanupCommand: null,+ remoteProvider: null,+ remoteWorkspaceRef: null,+ sharedWorkspaceKey: null,+ metadata: null,+ runtimeConfig: null,+ isPrimary: false,+ runtimeServices: [],+ createdAt: new Date(),+ updatedAt: new Date(),+ });+ mockExecutionWorkspaceService.update.mockResolvedValue(buildExecutionWorkspace());+ mockAssertCanManageProjectWorkspaceRuntimeServices.mockResolvedValue(undefined);+ mockAssertCanManageExecutionWorkspaceRuntimeServices.mockResolvedValue(undefined);+ });++ it("rejects agent callers for project workspace runtime service mutations when workspace auth denies access", async () => {+ const { forbidden } = await import("../errors.js");+ mockProjectService.getById.mockResolvedValue(buildProject({+ id: projectId,+ workspaces: [{+ id: workspaceId,+ companyId: "company-1",+ projectId,+ name: "Workspace",+ sourceType: "local_path",+ cwd: "/tmp/project",+ repoUrl: null,+ repoRef: null,+ defaultRef: null,+ visibility: "default",+ setupCommand: null,+ cleanupCommand: null,+ remoteProvider: null,+ remoteWorkspaceRef: null,+ sharedWorkspaceKey: null,+ metadata: null,+ runtimeConfig: null,+ isPrimary: false,+ runtimeServices: [],+ createdAt: new Date(),+ updatedAt: new Date(),+ }],+ }));+ mockAssertCanManageProjectWorkspaceRuntimeServices.mockRejectedValue(+ forbidden("Missing permission to manage workspace runtime services"),+ );+ const app = await createProjectApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .post(`/api/projects/${projectId}/workspaces/${workspaceId}/runtime-services/start`)+ .send({});++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("Missing permission");+ expect(mockProjectService.getById).toHaveBeenCalledWith(projectId);+ expect(mockAssertCanManageProjectWorkspaceRuntimeServices).toHaveBeenCalled();+ }, 15000);++ it("rejects agent callers that create project execution workspace commands", async () => {+ const app = await createProjectApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .post("/api/companies/company-1/projects")+ .send({+ name: "Exploit",+ executionWorkspacePolicy: {+ enabled: true,+ workspaceStrategy: {+ type: "git_worktree",+ provisionCommand: "touch /tmp/paperclip-rce",+ },+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockProjectService.create).not.toHaveBeenCalled();+ });++ it("rejects agent callers that update project workspace cleanup commands", async () => {+ mockProjectService.getById.mockResolvedValue(buildProject());+ const app = await createProjectApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/projects/${projectId}/workspaces/${workspaceId}`)+ .send({+ cleanupCommand: "rm -rf /tmp/paperclip-rce",+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockProjectService.updateWorkspace).not.toHaveBeenCalled();+ });++ it("allows board callers through the project workspace runtime auth gate", async () => {+ mockProjectService.getById.mockResolvedValue(null);+ const app = await createProjectApp({+ type: "board",+ userId: "board-1",+ companyIds: ["company-1"],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app)+ .post(`/api/projects/${projectId}/workspaces/${workspaceId}/runtime-services/start`)+ .send({});++ expect(res.status).toBe(404);+ expect(res.body.error).toContain("Project not found");+ expect(mockProjectService.getById).toHaveBeenCalledWith(projectId);+ });++ it("rejects agent callers for execution workspace runtime service mutations when workspace auth denies access", async () => {+ const { forbidden } = await import("../errors.js");+ mockExecutionWorkspaceService.getById.mockResolvedValue(buildExecutionWorkspace({ id: executionWorkspaceId }));+ mockAssertCanManageExecutionWorkspaceRuntimeServices.mockRejectedValue(+ forbidden("Missing permission to manage workspace runtime services"),+ );+ const app = await createExecutionWorkspaceApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .post(`/api/execution-workspaces/${executionWorkspaceId}/runtime-services/restart`)+ .send({});++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("Missing permission");+ expect(mockExecutionWorkspaceService.getById).toHaveBeenCalledWith(executionWorkspaceId);+ expect(mockAssertCanManageExecutionWorkspaceRuntimeServices).toHaveBeenCalled();+ }, 15000);++ it("rejects agent callers that patch execution workspace command config", async () => {+ mockExecutionWorkspaceService.getById.mockResolvedValue(buildExecutionWorkspace({ id: executionWorkspaceId }));+ const app = await createExecutionWorkspaceApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/execution-workspaces/${executionWorkspaceId}`)+ .send({+ config: {+ cleanupCommand: "rm -rf /tmp/paperclip-rce",+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockExecutionWorkspaceService.update).not.toHaveBeenCalled();+ });++ it("rejects agent callers that smuggle execution workspace commands through metadata.config", async () => {+ mockExecutionWorkspaceService.getById.mockResolvedValue(buildExecutionWorkspace({ id: executionWorkspaceId }));+ const app = await createExecutionWorkspaceApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ source: "agent_key",+ runId: "run-1",+ });++ const res = await request(app)+ .patch(`/api/execution-workspaces/${executionWorkspaceId}`)+ .send({+ metadata: {+ config: {+ provisionCommand: "touch /tmp/paperclip-rce",+ },+ },+ });++ expect(res.status).toBe(403);+ expect(res.body.error).toContain("host-executed workspace commands");+ expect(mockExecutionWorkspaceService.update).not.toHaveBeenCalled();+ });++ it("allows board callers through the execution workspace runtime auth gate", async () => {+ mockExecutionWorkspaceService.getById.mockResolvedValue(null);+ const app = await createExecutionWorkspaceApp({+ type: "board",+ userId: "board-1",+ companyIds: ["company-1"],+ source: "session",+ isInstanceAdmin: false,+ });++ const res = await request(app)+ .post(`/api/execution-workspaces/${executionWorkspaceId}/runtime-services/restart`)+ .send({});++ expect(res.status).toBe(404);+ expect(res.body.error).toContain("Execution workspace not found");+ expect(mockExecutionWorkspaceService.getById).toHaveBeenCalledWith(executionWorkspaceId);+ });+});diff --git a/server/src/__tests__/workspace-runtime-service-authz.test.ts b/server/src/__tests__/workspace-runtime-service-authz.test.tsnew file mode 100644index 0000000000..87460487df--- /dev/null+++ b/server/src/__tests__/workspace-runtime-service-authz.test.ts@@ -0,0 +1,279 @@+import { randomUUID } from "node:crypto";+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";+import {+ agents,+ companies,+ createDb,+ executionWorkspaces,+ issues,+ projectWorkspaces,+ projects,+} from "@paperclipai/db";+import {+ getEmbeddedPostgresTestSupport,+ startEmbeddedPostgresTestDatabase,+} from "./helpers/embedded-postgres.js";+import {+ assertCanManageExecutionWorkspaceRuntimeServices,+ assertCanManageProjectWorkspaceRuntimeServices,+} from "../routes/workspace-runtime-service-authz.js";++const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();+const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;++if (!embeddedPostgresSupport.supported) {+ console.warn(+ `Skipping embedded Postgres workspace runtime auth tests on this host: ${embeddedPostgresSupport.reason ?? "unsupported environment"}`,+ );+}++describeEmbeddedPostgres("workspace runtime service authz helper", () => {+ let db!: ReturnType<typeof createDb>;+ let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;++ beforeAll(async () => {+ tempDb = await startEmbeddedPostgresTestDatabase("paperclip-workspace-runtime-authz-");+ db = createDb(tempDb.connectionString);+ }, 20_000);++ afterEach(async () => {+ await db.delete(issues);+ await db.delete(executionWorkspaces);+ await db.delete(projectWorkspaces);+ await db.delete(projects);+ await db.delete(agents);+ await db.delete(companies);+ });++ afterAll(async () => {+ await tempDb?.cleanup();+ });++ async function seedCompany() {+ const companyId = randomUUID();+ await db.insert(companies).values({+ id: companyId,+ name: "Paperclip",+ issuePrefix: `PAP-${companyId.slice(0, 8)}`,+ requireBoardApprovalForNewAgents: false,+ });+ return companyId;+ }++ async function seedProjectWorkspace(companyId: string) {+ const projectId = randomUUID();+ const projectWorkspaceId = randomUUID();+ await db.insert(projects).values({+ id: projectId,+ companyId,+ name: "Workspace authz",+ status: "in_progress",+ });+ await db.insert(projectWorkspaces).values({+ id: projectWorkspaceId,+ companyId,+ projectId,+ name: "Primary",+ sourceType: "local_path",+ cwd: "/tmp/paperclip-authz-project",+ isPrimary: true,+ });+ return { projectId, projectWorkspaceId };+ }++ async function seedExecutionWorkspace(companyId: string, projectId: string, projectWorkspaceId: string) {+ const executionWorkspaceId = randomUUID();+ await db.insert(executionWorkspaces).values({+ id: executionWorkspaceId,+ companyId,+ projectId,+ projectWorkspaceId,+ mode: "isolated_workspace",+ strategyType: "git_worktree",+ name: "Execution workspace",+ status: "active",+ providerType: "local_fs",+ cwd: "/tmp/paperclip-authz-execution",+ });+ return executionWorkspaceId;+ }++ async function seedAgent(+ companyId: string,+ input: { role?: string; reportsTo?: string | null; name?: string } = {},+ ) {+ const agentId = randomUUID();+ await db.insert(agents).values({+ id: agentId,+ companyId,+ name: input.name ?? "Agent",+ role: input.role ?? "engineer",+ reportsTo: input.reportsTo ?? null,+ });+ return agentId;+ }++ it("allows board actors to manage project workspace runtime services", async () => {+ const companyId = await seedCompany();+ const { projectWorkspaceId } = await seedProjectWorkspace(companyId);++ await expect(assertCanManageProjectWorkspaceRuntimeServices(db, {+ actor: {+ type: "board",+ userId: "board-1",+ companyIds: [companyId],+ source: "session",+ isInstanceAdmin: false,+ },+ } as any, {+ companyId,+ projectWorkspaceId,+ })).resolves.toBeUndefined();+ });++ it("allows CEO agents to manage any project workspace runtime services in their company", async () => {+ const companyId = await seedCompany();+ const { projectWorkspaceId } = await seedProjectWorkspace(companyId);+ const ceoAgentId = await seedAgent(companyId, { role: "ceo", name: "CEO" });++ await expect(assertCanManageProjectWorkspaceRuntimeServices(db, {+ actor: {+ type: "agent",+ agentId: ceoAgentId,+ companyId,+ source: "agent_key",+ },+ } as any, {+ companyId,+ projectWorkspaceId,+ })).resolves.toBeUndefined();+ });++ it("allows agents with a non-terminal assigned issue in the target project workspace", async () => {+ const companyId = await seedCompany();+ const { projectId, projectWorkspaceId } = await seedProjectWorkspace(companyId);+ const agentId = await seedAgent(companyId, { name: "Engineer" });++ await db.insert(issues).values({+ id: randomUUID(),+ companyId,+ projectId,+ projectWorkspaceId,+ title: "Use this workspace",+ status: "todo",+ priority: "medium",+ assigneeAgentId: agentId,+ });++ await expect(assertCanManageProjectWorkspaceRuntimeServices(db, {+ actor: {+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ },+ } as any, {+ companyId,+ projectWorkspaceId,+ })).resolves.toBeUndefined();+ });++ it("allows managers to manage execution workspace runtime services for their reporting subtree", async () => {+ const companyId = await seedCompany();+ const { projectId, projectWorkspaceId } = await seedProjectWorkspace(companyId);+ const executionWorkspaceId = await seedExecutionWorkspace(companyId, projectId, projectWorkspaceId);+ const managerId = await seedAgent(companyId, { role: "cto", name: "Manager" });+ const reportId = await seedAgent(companyId, { reportsTo: managerId, name: "Report" });++ await db.insert(issues).values({+ id: randomUUID(),+ companyId,+ projectId,+ projectWorkspaceId,+ executionWorkspaceId,+ title: "Use execution workspace",+ status: "in_progress",+ priority: "medium",+ assigneeAgentId: reportId,+ });++ await expect(assertCanManageExecutionWorkspaceRuntimeServices(db, {+ actor: {+ type: "agent",+ agentId: managerId,+ companyId,+ source: "agent_key",+ },+ } as any, {+ companyId,+ executionWorkspaceId,+ })).resolves.toBeUndefined();+ });++ it("rejects unrelated same-company agents without matching workspace assignments", async () => {+ const companyId = await seedCompany();+ const { projectId, projectWorkspaceId } = await seedProjectWorkspace(companyId);+ const executionWorkspaceId = await seedExecutionWorkspace(companyId, projectId, projectWorkspaceId);+ const assignedAgentId = await seedAgent(companyId, { name: "Assigned" });+ const unrelatedAgentId = await seedAgent(companyId, { name: "Unrelated" });++ await db.insert(issues).values({+ id: randomUUID(),+ companyId,+ projectId,+ projectWorkspaceId,+ executionWorkspaceId,+ title: "Assigned issue",+ status: "todo",+ priority: "medium",+ assigneeAgentId: assignedAgentId,+ });++ await expect(assertCanManageExecutionWorkspaceRuntimeServices(db, {+ actor: {+ type: "agent",+ agentId: unrelatedAgentId,+ companyId,+ source: "agent_key",+ },+ } as any, {+ companyId,+ executionWorkspaceId,+ })).rejects.toMatchObject({+ status: 403,+ message: "Missing permission to manage workspace runtime services",+ });+ });++ it("rejects completed workspace assignments so stale issues do not keep access alive", async () => {+ const companyId = await seedCompany();+ const { projectId, projectWorkspaceId } = await seedProjectWorkspace(companyId);+ const agentId = await seedAgent(companyId, { name: "Engineer" });++ await db.insert(issues).values({+ id: randomUUID(),+ companyId,+ projectId,+ projectWorkspaceId,+ title: "Completed issue",+ status: "done",+ priority: "medium",+ assigneeAgentId: agentId,+ });++ await expect(assertCanManageProjectWorkspaceRuntimeServices(db, {+ actor: {+ type: "agent",+ agentId,+ companyId,+ source: "agent_key",+ },+ } as any, {+ companyId,+ projectWorkspaceId,+ })).rejects.toMatchObject({+ status: 403,+ message: "Missing permission to manage workspace runtime services",+ });+ });+});diff --git a/server/src/app.ts b/server/src/app.tsindex 7daf24c1ec..317b87993d 100644--- a/server/src/app.ts+++ b/server/src/app.ts@@ -86,6 +86,16 @@ function shouldServeViteDevHtml(req: ExpressRequest): boolean {return req.accepts(["html"]) === "html";}+export function shouldEnablePrivateHostnameGuard(opts: {+ deploymentMode: DeploymentMode;+ deploymentExposure: DeploymentExposure;+}): boolean {+ return (+ opts.deploymentExposure === "private" &&+ (opts.deploymentMode === "local_trusted" || opts.deploymentMode === "authenticated")+ );+}+export async function createApp(db: Db,opts: {@@ -123,8 +133,10 @@ export async function createApp(},}));app.use(httpLogger);- const privateHostnameGateEnabled =- opts.deploymentMode === "authenticated" && opts.deploymentExposure === "private";+ const privateHostnameGateEnabled = shouldEnablePrivateHostnameGuard({+ deploymentMode: opts.deploymentMode,+ deploymentExposure: opts.deploymentExposure,+ });const privateHostnameAllowSet = resolvePrivateHostnameAllowSet({allowedHostnames: opts.allowedHostnames,bindHost: opts.bindHost,diff --git a/server/src/routes/access.ts b/server/src/routes/access.tsindex e4893765fb..0be3adab1f 100644--- a/server/src/routes/access.ts+++ b/server/src/routes/access.ts@@ -48,7 +48,7 @@ import {logActivity,notifyHireApproved} from "../services/index.js";-import { assertCompanyAccess } from "./authz.js";+import { assertAuthenticated, assertCompanyAccess } from "./authz.js";import {claimBoardOwnership,inspectBoardClaimChallenge@@ -863,6 +863,7 @@ function toInviteSummaryResponse(const baseUrl = requestBaseUrl(req);const onboardingPath = `/api/invites/${token}/onboarding`;const onboardingTextPath = `/api/invites/${token}/onboarding.txt`;+ const skillIndexPath = `/api/invites/${token}/skills/index`;const inviteMessage = extractInviteMessage(invite);return {id: invite.id,@@ -877,10 +878,10 @@ function toInviteSummaryResponse(onboardingTextUrl: baseUrl? `${baseUrl}${onboardingTextPath}`: onboardingTextPath,- skillIndexPath: "/api/skills/index",+ skillIndexPath,skillIndexUrl: baseUrl- ? `${baseUrl}/api/skills/index`- : "/api/skills/index",+ ? `${baseUrl}${skillIndexPath}`+ : skillIndexPath,inviteMessage};}@@ -1004,7 +1005,7 @@ function buildInviteOnboardingManifest(}) {const baseUrl = requestBaseUrl(req);- const skillPath = "/api/skills/paperclip";+ const skillPath = `/api/invites/${token}/skills/paperclip`;const skillUrl = baseUrl ? `${baseUrl}${skillPath}` : skillPath;const registrationEndpointPath = `/api/invites/${token}/accept`;const registrationEndpointUrl = baseUrl@@ -1906,11 +1907,13 @@ export function accessRoutes(return company?.name ?? null;}- router.get("/skills/available", (_req, res) => {+ router.get("/skills/available", (req, res) => {+ assertAuthenticated(req);res.json({ skills: listAvailableSkills() });});- router.get("/skills/index", (_req, res) => {+ router.get("/skills/index", (req, res) => {+ assertAuthenticated(req);res.json({skills: [{ name: "paperclip", path: "/api/skills/paperclip" },@@ -1927,6 +1930,7 @@ export function accessRoutes(});router.get("/skills/:skillName", (req, res) => {+ assertAuthenticated(req);const skillName = (req.params.skillName as string).trim().toLowerCase();const markdown = readSkillMarkdown(skillName);if (!markdown) throw notFound("Skill not found");@@ -2100,6 +2104,47 @@ export function accessRoutes();});+ router.get("/invites/:token/skills/index", async (req, res) => {+ const token = (req.params.token as string).trim();+ if (!token) throw notFound("Invite not found");+ const invite = await db+ .select()+ .from(invites)+ .where(eq(invites.tokenHash, hashToken(token)))+ .then((rows) => rows[0] ?? null);+ if (!invite || invite.revokedAt || inviteExpired(invite)) {+ throw notFound("Invite not found");+ }++ res.json({+ skills: [+ {+ name: "paperclip",+ path: `/api/invites/${token}/skills/paperclip`,+ },+ ],+ });+ });++ router.get("/invites/:token/skills/:skillName", async (req, res) => {+ const token = (req.params.token as string).trim();+ if (!token) throw notFound("Invite not found");+ const invite = await db+ .select()+ .from(invites)+ .where(eq(invites.tokenHash, hashToken(token)))+ .then((rows) => rows[0] ?? null);+ if (!invite || invite.revokedAt || inviteExpired(invite)) {+ throw notFound("Invite not found");+ }++ const skillName = (req.params.skillName as string).trim().toLowerCase();+ if (skillName !== "paperclip") throw notFound("Skill not found");+ const markdown = readSkillMarkdown(skillName);+ if (!markdown) throw notFound("Skill not found");+ res.type("text/markdown").send(markdown);+ });+router.get("/invites/:token/test-resolution", async (req, res) => {const token = (req.params.token as string).trim();if (!token) throw notFound("Invite not found");diff --git a/server/src/routes/activity.ts b/server/src/routes/activity.tsindex 20f2ed534e..53083b1b60 100644--- a/server/src/routes/activity.ts+++ b/server/src/routes/activity.ts@@ -3,7 +3,7 @@ import { z } from "zod";import type { Db } from "@paperclipai/db";import { validate } from "../middleware/validate.js";import { activityService } from "../services/activity.js";-import { assertBoard, assertCompanyAccess } from "./authz.js";+import { assertAuthenticated, assertBoard, assertCompanyAccess } from "./authz.js";import { heartbeatService, issueService } from "../services/index.js";import { sanitizeRecord } from "../redaction.js";@@ -81,6 +81,7 @@ export function activityRoutes(db: Db) {});router.get("/heartbeat-runs/:runId/issues", async (req, res) => {+ assertAuthenticated(req);const runId = req.params.runId as string;const run = await heartbeat.getRun(runId);if (!run) {diff --git a/server/src/routes/agents.ts b/server/src/routes/agents.tsindex faf27f24e9..9511d6d0da 100644--- a/server/src/routes/agents.ts+++ b/server/src/routes/agents.ts@@ -1,4 +1,4 @@-import { Router, type Request } from "express";+import { Router, type Request, type Response } from "express";import { generateKeyPairSync, randomUUID } from "node:crypto";import path from "node:path";import type { Db } from "@paperclipai/db";@@ -46,6 +46,10 @@ import {} from "../services/index.js";import { conflict, forbidden, notFound, unprocessable } from "../errors.js";import { assertBoard, assertCompanyAccess, assertInstanceAdmin, getActorInfo } from "./authz.js";+import {+ assertNoAgentHostWorkspaceCommandMutation,+ collectAgentAdapterWorkspaceCommandPaths,+} from "./workspace-command-authz.js";import {detectAdapterModel,findActiveServerAdapter,@@ -231,10 +235,33 @@ export function agentRoutes(db: Db) {return actorAgent;}+ async function assertBoardCanManageAgentsForCompany(req: Request, companyId: string) {+ assertBoard(req);+ assertCompanyAccess(req, companyId);+ if (req.actor.source === "local_implicit" || req.actor.isInstanceAdmin) return;+ const allowed = await access.canUser(companyId, req.actor.userId, "agents:create");+ if (!allowed) {+ throw forbidden("Missing permission: agents:create");+ }+ }+async function assertCanReadConfigurations(req: Request, companyId: string) {return assertCanCreateAgentsForCompany(req, companyId);}+ async function getAccessibleAgent(req: Request, res: Response, id: string) {+ const agent = await svc.getById(id);+ if (!agent) {+ res.status(404).json({ error: "Agent not found" });+ return null;+ }+ assertCompanyAccess(req, agent.companyId);+ if (req.actor.type === "board") {+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);+ }+ return agent;+ }+async function actorCanReadConfigurationsForCompany(req: Request, companyId: string) {assertCompanyAccess(req, companyId);if (req.actor.type === "board") {@@ -317,7 +344,10 @@ export function agentRoutes(db: Db) {async function assertCanUpdateAgent(req: Request, targetAgent: { id: string; companyId: string }) {assertCompanyAccess(req, targetAgent.companyId);- if (req.actor.type === "board") return;+ if (req.actor.type === "board") {+ await assertBoardCanManageAgentsForCompany(req, targetAgent.companyId);+ return;+ }if (!req.actor.agentId) throw forbidden("Agent authentication required");const actorAgent = await svc.getById(req.actor.agentId);@@ -339,7 +369,10 @@ export function agentRoutes(db: Db) {async function assertCanReadAgent(req: Request, targetAgent: { companyId: string }) {assertCompanyAccess(req, targetAgent.companyId);- if (req.actor.type === "board") return;+ if (req.actor.type === "board") {+ await assertCanReadConfigurations(req, targetAgent.companyId);+ return;+ }if (!req.actor.agentId) throw forbidden("Agent authentication required");const actorAgent = await svc.getById(req.actor.agentId);@@ -610,19 +643,24 @@ export function agentRoutes(db: Db) {async function assertCanManageInstructionsPath(req: Request, targetAgent: { id: string; companyId: string }) {assertCompanyAccess(req, targetAgent.companyId);- if (req.actor.type === "board") return;- if (!req.actor.agentId) throw forbidden("Agent authentication required");-- const actorAgent = await svc.getById(req.actor.agentId);- if (!actorAgent || actorAgent.companyId !== targetAgent.companyId) {- throw forbidden("Agent key cannot access another company");+ if (req.actor.type !== "board") {+ throw forbidden(+ "Only board-authenticated callers can manage instructions path or bundle configuration",+ );}- if (actorAgent.id === targetAgent.id) return;-- const chainOfCommand = await svc.getChainOfCommand(targetAgent.id);- if (chainOfCommand.some((manager) => manager.id === actorAgent.id)) return;+ await assertBoardCanManageAgentsForCompany(req, targetAgent.companyId);+ }- throw forbidden("Only the target agent or an ancestor manager can update instructions path");+ function assertNoAgentInstructionsConfigMutation(+ req: Request,+ adapterConfig: Record<string, unknown> | null | undefined,+ ) {+ if (req.actor.type !== "agent" || !adapterConfig) return;+ const changedSensitiveKeys = KNOWN_INSTRUCTIONS_BUNDLE_KEYS.filter((key) => adapterConfig[key] !== undefined);+ if (changedSensitiveKeys.length === 0) return;+ throw forbidden(+ `Agent-authenticated callers cannot modify instructions path or bundle configuration (${changedSensitiveKeys.join(", ")})`,+ );}function summarizeAgentUpdateDetails(patch: Record<string, unknown>) {@@ -997,7 +1035,7 @@ export function agentRoutes(db: Db) {}const result = await svc.list(companyId);const canReadConfigs = await actorCanReadConfigurationsForCompany(req, companyId);- if (canReadConfigs || req.actor.type === "board") {+ if (canReadConfigs) {res.json(result);return;}@@ -1173,12 +1211,13 @@ export function agentRoutes(db: Db) {return;}assertCompanyAccess(req, agent.companyId);- if (req.actor.type === "agent" && req.actor.agentId !== id) {- const canRead = await actorCanReadConfigurationsForCompany(req, agent.companyId);- if (!canRead) {- res.json(await buildAgentDetail(agent, { restricted: true }));- return;- }+ const isSelf = req.actor.type === "agent" && req.actor.agentId === id;+ const canReadSensitiveDetail = isSelf+ ? true+ : await actorCanReadConfigurationsForCompany(req, agent.companyId);+ if (!canReadSensitiveDetail) {+ res.json(await buildAgentDetail(agent, { restricted: true }));+ return;}res.json(await buildAgentDetail(agent));});@@ -1266,6 +1305,7 @@ export function agentRoutes(db: Db) {res.status(404).json({ error: "Agent not found" });return;}+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);assertCompanyAccess(req, agent.companyId);const state = await heartbeat.getRuntimeState(id);@@ -1280,6 +1320,7 @@ export function agentRoutes(db: Db) {res.status(404).json({ error: "Agent not found" });return;}+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);assertCompanyAccess(req, agent.companyId);const sessions = await heartbeat.listTaskSessions(id);@@ -1299,6 +1340,7 @@ export function agentRoutes(db: Db) {res.status(404).json({ error: "Agent not found" });return;}+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);assertCompanyAccess(req, agent.companyId);const taskKey =@@ -1331,6 +1373,14 @@ export function agentRoutes(db: Db) {...hireInput} = req.body;hireInput.adapterType = assertKnownAdapterType(hireInput.adapterType);+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectAgentAdapterWorkspaceCommandPaths(hireInput.adapterConfig),+ );+ assertNoAgentInstructionsConfigMutation(+ req,+ (hireInput.adapterConfig ?? {}) as Record<string, unknown>,+ );const requestedAdapterConfig = applyCreateDefaultsByAdapterType(hireInput.adapterType,((hireInput.adapterConfig ?? {}) as Record<string, unknown>),@@ -1590,6 +1640,8 @@ export function agentRoutes(db: Db) {res.status(403).json({ error: "Only CEO can manage permissions" });return;}+ } else {+ await assertBoardCanManageAgentsForCompany(req, existing.companyId);}const agent = await svc.updatePermissions(id, req.body);@@ -1890,10 +1942,15 @@ export function agentRoutes(db: Db) {res.status(422).json({ error: "adapterConfig must be an object" });return;}- const changingInstructionsPath = Object.keys(adapterConfig).some((key) =>- KNOWN_INSTRUCTIONS_PATH_KEYS.has(key),+ assertNoAgentInstructionsConfigMutation(req, adapterConfig);+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectAgentAdapterWorkspaceCommandPaths(adapterConfig),+ );+ const changingInstructionsConfig = Object.keys(adapterConfig).some((key) =>+ KNOWN_INSTRUCTIONS_BUNDLE_KEYS.includes(key as (typeof KNOWN_INSTRUCTIONS_BUNDLE_KEYS)[number]),);- if (changingInstructionsPath) {+ if (changingInstructionsConfig) {await assertCanManageInstructionsPath(req, existing);}patchData.adapterConfig = adapterConfig;@@ -1994,6 +2051,9 @@ export function agentRoutes(db: Db) {router.post("/agents/:id/pause", async (req, res) => {assertBoard(req);const id = req.params.id as string;+ if (!(await getAccessibleAgent(req, res, id))) {+ return;+ }const agent = await svc.pause(id);if (!agent) {res.status(404).json({ error: "Agent not found" });@@ -2017,6 +2077,9 @@ export function agentRoutes(db: Db) {router.post("/agents/:id/resume", async (req, res) => {assertBoard(req);const id = req.params.id as string;+ if (!(await getAccessibleAgent(req, res, id))) {+ return;+ }const agent = await svc.resume(id);if (!agent) {res.status(404).json({ error: "Agent not found" });@@ -2038,6 +2101,9 @@ export function agentRoutes(db: Db) {router.post("/agents/:id/terminate", async (req, res) => {assertBoard(req);const id = req.params.id as string;+ if (!(await getAccessibleAgent(req, res, id))) {+ return;+ }const agent = await svc.terminate(id);if (!agent) {res.status(404).json({ error: "Agent not found" });@@ -2061,6 +2127,9 @@ export function agentRoutes(db: Db) {router.delete("/agents/:id", async (req, res) => {assertBoard(req);const id = req.params.id as string;+ if (!(await getAccessibleAgent(req, res, id))) {+ return;+ }const agent = await svc.remove(id);if (!agent) {res.status(404).json({ error: "Agent not found" });@@ -2082,6 +2151,10 @@ export function agentRoutes(db: Db) {router.get("/agents/:id/keys", async (req, res) => {assertBoard(req);const id = req.params.id as string;+ const agent = await getAccessibleAgent(req, res, id);+ if (!agent) {+ return;+ }const keys = await svc.listKeys(id);res.json(keys);});@@ -2089,32 +2162,56 @@ export function agentRoutes(db: Db) {router.post("/agents/:id/keys", validate(createAgentKeySchema), async (req, res) => {assertBoard(req);const id = req.params.id as string;+ const agent = await getAccessibleAgent(req, res, id);+ if (!agent) {+ return;+ }const key = await svc.createApiKey(id, req.body.name);- const agent = await svc.getById(id);- if (agent) {- await logActivity(db, {- companyId: agent.companyId,- actorType: "user",- actorId: req.actor.userId ?? "board",- action: "agent.key_created",- entityType: "agent",- entityId: agent.id,- details: { keyId: key.id, name: key.name },- });- }+ await logActivity(db, {+ companyId: agent.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "agent.key_created",+ entityType: "agent",+ entityId: agent.id,+ details: { keyId: key.id, name: key.name },+ });res.status(201).json(key);});router.delete("/agents/:id/keys/:keyId", async (req, res) => {assertBoard(req);+ const id = req.params.id as string;const keyId = req.params.keyId as string;- const revoked = await svc.revokeKey(keyId);+ const agent = await getAccessibleAgent(req, res, id);+ if (!agent) {+ return;+ }++ const key = await svc.getKeyById(keyId);+ if (!key || key.agentId !== agent.id) {+ res.status(404).json({ error: "Key not found" });+ return;+ }++ const revoked = await svc.revokeKey(agent.id, keyId);if (!revoked) {res.status(404).json({ error: "Key not found" });return;}++ await logActivity(db, {+ companyId: agent.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "agent.key_revoked",+ entityType: "agent",+ entityId: agent.id,+ details: { keyId: key.id, name: key.name },+ });+res.json({ ok: true });});@@ -2127,9 +2224,13 @@ export function agentRoutes(db: Db) {}assertCompanyAccess(req, agent.companyId);- if (req.actor.type === "agent" && req.actor.agentId !== id) {- res.status(403).json({ error: "Agent can only invoke itself" });- return;+ if (req.actor.type === "agent") {+ if (req.actor.agentId !== id) {+ res.status(403).json({ error: "Agent can only invoke itself" });+ return;+ }+ } else {+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);}const run = await heartbeat.wakeup(id, {@@ -2177,9 +2278,13 @@ export function agentRoutes(db: Db) {}assertCompanyAccess(req, agent.companyId);- if (req.actor.type === "agent" && req.actor.agentId !== id) {- res.status(403).json({ error: "Agent can only invoke itself" });- return;+ if (req.actor.type === "agent") {+ if (req.actor.agentId !== id) {+ res.status(403).json({ error: "Agent can only invoke itself" });+ return;+ }+ } else {+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);}const run = await heartbeat.invoke(@@ -2225,6 +2330,7 @@ export function agentRoutes(db: Db) {res.status(404).json({ error: "Agent not found" });return;}+ await assertBoardCanManageAgentsForCompany(req, agent.companyId);assertCompanyAccess(req, agent.companyId);if (agent.adapterType !== "claude_local") {res.status(400).json({ error: "Login is only supported for claude_local agents" });diff --git a/server/src/routes/approvals.ts b/server/src/routes/approvals.tsindex 3ed2037470..d1743cc050 100644--- a/server/src/routes/approvals.ts+++ b/server/src/routes/approvals.ts@@ -134,11 +134,8 @@ export function approvalRoutes(db: Db) {res.status(404).json({ error: "Approval not found" });return;}- const { approval, applied } = await svc.approve(- id,- req.body.decidedByUserId ?? "board",- req.body.decisionNote,- );+ const decidedByUserId = req.actor.userId ?? "board";+ const { approval, applied } = await svc.approve(id, decidedByUserId, req.body.decisionNote);if (applied) {const linkedIssues = await issueApprovalsSvc.listIssuesForApproval(approval.id);@@ -233,11 +230,8 @@ export function approvalRoutes(db: Db) {res.status(404).json({ error: "Approval not found" });return;}- const { approval, applied } = await svc.reject(- id,- req.body.decidedByUserId ?? "board",- req.body.decisionNote,- );+ const decidedByUserId = req.actor.userId ?? "board";+ const { approval, applied } = await svc.reject(id, decidedByUserId, req.body.decisionNote);if (applied) {await logActivity(db, {@@ -264,11 +258,8 @@ export function approvalRoutes(db: Db) {res.status(404).json({ error: "Approval not found" });return;}- const approval = await svc.requestRevision(- id,- req.body.decidedByUserId ?? "board",- req.body.decisionNote,- );+ const decidedByUserId = req.actor.userId ?? "board";+ const approval = await svc.requestRevision(id, decidedByUserId, req.body.decisionNote);await logActivity(db, {companyId: approval.companyId,diff --git a/server/src/routes/authz.ts b/server/src/routes/authz.tsindex a881d4ff05..e9017c93a3 100644--- a/server/src/routes/authz.ts+++ b/server/src/routes/authz.ts@@ -1,6 +1,12 @@import type { Request } from "express";import { forbidden, unauthorized } from "../errors.js";+export function assertAuthenticated(req: Request) {+ if (req.actor.type === "none") {+ throw unauthorized();+ }+}+export function assertBoard(req: Request) {if (req.actor.type !== "board") {throw forbidden("Board access required");@@ -16,9 +22,7 @@ export function assertInstanceAdmin(req: Request) {}export function assertCompanyAccess(req: Request, companyId: string) {- if (req.actor.type === "none") {- throw unauthorized();- }+ assertAuthenticated(req);if (req.actor.type === "agent" && req.actor.companyId !== companyId) {throw forbidden("Agent key cannot access another company");}@@ -31,9 +35,7 @@ export function assertCompanyAccess(req: Request, companyId: string) {}export function getActorInfo(req: Request) {- if (req.actor.type === "none") {- throw unauthorized();- }+ assertAuthenticated(req);if (req.actor.type === "agent") {return {actorType: "agent" as const,diff --git a/server/src/routes/execution-workspaces.ts b/server/src/routes/execution-workspaces.tsindex 963be2ed7b..faabd53c50 100644--- a/server/src/routes/execution-workspaces.ts+++ b/server/src/routes/execution-workspaces.ts@@ -23,6 +23,11 @@ import {stopRuntimeServicesForExecutionWorkspace,} from "../services/workspace-runtime.js";import { assertCompanyAccess, getActorInfo } from "./authz.js";+import {+ assertNoAgentHostWorkspaceCommandMutation,+ collectExecutionWorkspaceCommandPaths,+} from "./workspace-command-authz.js";+import { assertCanManageExecutionWorkspaceRuntimeServices } from "./workspace-runtime-service-authz.js";export function executionWorkspaceRoutes(db: Db) {const router = Router();@@ -96,6 +101,12 @@ export function executionWorkspaceRoutes(db: Db) {}assertCompanyAccess(req, existing.companyId);+ await assertCanManageExecutionWorkspaceRuntimeServices(db, req, {+ companyId: existing.companyId,+ executionWorkspaceId: existing.id,+ sourceIssueId: existing.sourceIssueId,+ });+const workspaceCwd = existing.cwd;if (!workspaceCwd) {res.status(422).json({ error: "Execution workspace needs a local path before Paperclip can run workspace commands" });@@ -428,6 +439,13 @@ export function executionWorkspaceRoutes(db: Db) {return;}assertCompanyAccess(req, existing.companyId);+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectExecutionWorkspaceCommandPaths({+ config: req.body.config,+ metadata: req.body.metadata,+ }),+ );const patch: Record<string, unknown> = {...(req.body.name === undefined ? {} : { name: req.body.name }),...(req.body.cwd === undefined ? {} : { cwd: req.body.cwd }),diff --git a/server/src/routes/health.ts b/server/src/routes/health.tsindex 795eb9a5cb..d5216e72d8 100644--- a/server/src/routes/health.ts+++ b/server/src/routes/health.ts@@ -7,6 +7,14 @@ import { readPersistedDevServerStatus, toDevServerHealthStatus } from "../dev-seimport { instanceSettingsService } from "../services/instance-settings.js";import { serverVersion } from "../version.js";+function shouldExposeFullHealthDetails(+ actorType: "none" | "board" | "agent" | null | undefined,+ deploymentMode: DeploymentMode,+) {+ if (deploymentMode !== "authenticated") return true;+ return actorType === "board" || actorType === "agent";+}+export function healthRoutes(db?: Db,opts: {@@ -23,9 +31,19 @@ export function healthRoutes() {const router = Router();- router.get("/", async (_req, res) => {+ router.get("/", async (req, res) => {+ const actorType = "actor" in req ? req.actor?.type : null;+ const exposeFullDetails = shouldExposeFullHealthDetails(+ actorType,+ opts.deploymentMode,+ );+if (!db) {- res.json({ status: "ok", version: serverVersion });+ res.json(+ exposeFullDetails+ ? { status: "ok", version: serverVersion }+ : { status: "ok", deploymentMode: opts.deploymentMode },+ );return;}@@ -70,7 +88,7 @@ export function healthRoutes(const persistedDevServerStatus = readPersistedDevServerStatus();let devServer: ReturnType<typeof toDevServerHealthStatus> | undefined;- if (persistedDevServerStatus) {+ if (persistedDevServerStatus && typeof (db as { select?: unknown }).select === "function") {const instanceSettings = instanceSettingsService(db);const experimentalSettings = await instanceSettings.getExperimental();const activeRunCount = await db@@ -85,6 +103,16 @@ export function healthRoutes(});}+ if (!exposeFullDetails) {+ res.json({+ status: "ok",+ deploymentMode: opts.deploymentMode,+ bootstrapStatus,+ bootstrapInviteActive,+ });+ return;+ }+res.json({status: "ok",version: serverVersion,diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.tsindex 4f49c31d72..c5d2d40d12 100644--- a/server/src/routes/issues.ts+++ b/server/src/routes/issues.ts@@ -48,6 +48,10 @@ import {import { logger } from "../middleware/logger.js";import { conflict, forbidden, HttpError, notFound, unauthorized } from "../errors.js";import { assertCompanyAccess, getActorInfo } from "./authz.js";+import {+ assertNoAgentHostWorkspaceCommandMutation,+ collectIssueWorkspaceCommandPaths,+} from "./workspace-command-authz.js";import { shouldWakeAssigneeOnCheckout } from "./issues-checkout-wakeup.js";import {isInlineAttachmentContentType,@@ -1323,6 +1327,7 @@ export function issueRoutes(router.post("/companies/:companyId/issues", validate(createIssueSchema), async (req, res) => {const companyId = req.params.companyId as string;assertCompanyAccess(req, companyId);+ assertNoAgentHostWorkspaceCommandMutation(req, collectIssueWorkspaceCommandPaths(req.body));if (req.body.assigneeAgentId || req.body.assigneeUserId) {await assertCanAssignTasks(req, companyId);}@@ -1373,6 +1378,7 @@ export function issueRoutes(return;}assertCompanyAccess(req, existing.companyId);+ assertNoAgentHostWorkspaceCommandMutation(req, collectIssueWorkspaceCommandPaths(req.body));if (!(await assertAgentRunCheckoutOwnership(req, res, existing))) return;const actor = getActorInfo(req);diff --git a/server/src/routes/plugins.ts b/server/src/routes/plugins.tsindex 95215d899a..a6368be9c6 100644--- a/server/src/routes/plugins.ts+++ b/server/src/routes/plugins.ts@@ -11,7 +11,8 @@* - Retrieving UI slot contributions for frontend rendering* - Discovering and executing plugin-contributed agent tools*- * All routes require board-level authentication (assertBoard middleware).+ * All routes require board-level authentication, and sensitive instance-wide+ * mutations such as install/upgrade require instance-admin privileges.** @module server/routes/plugins* @see doc/plugins/PLUGIN_SPEC.md for the full plugin specification@@ -47,7 +48,7 @@ import type { PluginStreamBus } from "../services/plugin-stream-bus.js";import type { PluginToolDispatcher } from "../services/plugin-tool-dispatcher.js";import type { ToolRunContext } from "@paperclipai/plugin-sdk";import { JsonRpcCallError, PLUGIN_RPC_ERROR_CODES } from "@paperclipai/plugin-sdk";-import { assertBoard, assertCompanyAccess, getActorInfo } from "./authz.js";+import { assertBoard, assertCompanyAccess, assertInstanceAdmin, getActorInfo } from "./authz.js";import { validateInstanceConfig } from "../services/plugin-config-validator.js";/** UI slot declaration extracted from plugin manifest */@@ -583,6 +584,9 @@ export function pluginRoutes(** Install a plugin from npm or a local filesystem path.*+ * Instance-wide plugin installation is restricted to instance admins because+ * the install flow fetches and inspects package contents on the host.+ ** Request body:* - packageName: npm package name or local path (required)* - version: Target version for npm packages (optional)@@ -601,7 +605,7 @@ export function pluginRoutes(* - `500` — installation succeeded but manifest is missing (indicates a loader bug)*/router.post("/plugins/install", async (req, res) => {- assertBoard(req);+ assertInstanceAdmin(req);const { packageName, version, isLocalPath } = req.body as PluginInstallRequest;// Input validation@@ -1450,6 +1454,9 @@ export function pluginRoutes(** Upgrade a plugin to a newer version.*+ * Upgrades are restricted to instance admins because they fetch and inspect+ * new package contents on the host before activation.+ ** Request body (optional):* - version: Target version (defaults to latest)*@@ -1461,7 +1468,7 @@ export function pluginRoutes(* Errors: 404 if plugin not found, 400 for lifecycle errors*/router.post("/plugins/:pluginId/upgrade", async (req, res) => {- assertBoard(req);+ assertInstanceAdmin(req);const { pluginId } = req.params;const body = req.body as { version?: string } | undefined;const version = body?.version;diff --git a/server/src/routes/projects.ts b/server/src/routes/projects.tsindex 71cd792b0a..f4d3e84863 100644--- a/server/src/routes/projects.ts+++ b/server/src/routes/projects.ts@@ -22,6 +22,12 @@ import {startRuntimeServicesForWorkspaceControl,stopRuntimeServicesForProjectWorkspace,} from "../services/workspace-runtime.js";+import {+ assertNoAgentHostWorkspaceCommandMutation,+ collectProjectExecutionWorkspaceCommandPaths,+ collectProjectWorkspaceCommandPaths,+} from "./workspace-command-authz.js";+import { assertCanManageProjectWorkspaceRuntimeServices } from "./workspace-runtime-service-authz.js";import { getTelemetryClient } from "../telemetry.js";export function projectRoutes(db: Db) {@@ -93,6 +99,13 @@ export function projectRoutes(db: Db) {};const { workspace, ...projectData } = req.body as CreateProjectPayload;+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ [+ ...collectProjectExecutionWorkspaceCommandPaths(projectData.executionWorkspacePolicy),+ ...collectProjectWorkspaceCommandPaths(workspace, "workspace"),+ ],+ );if (projectData.env !== undefined) {projectData.env = await secretsSvc.normalizeEnvBindingsForPersistence(companyId,@@ -144,6 +157,10 @@ export function projectRoutes(db: Db) {}assertCompanyAccess(req, existing.companyId);const body = { ...req.body };+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectProjectExecutionWorkspaceCommandPaths(body.executionWorkspacePolicy),+ );if (typeof body.archivedAt === "string") {body.archivedAt = new Date(body.archivedAt);}@@ -200,6 +217,10 @@ export function projectRoutes(db: Db) {return;}assertCompanyAccess(req, existing.companyId);+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectProjectWorkspaceCommandPaths(req.body),+ );const workspace = await svc.createWorkspace(id, req.body);if (!workspace) {res.status(422).json({ error: "Invalid project workspace payload" });@@ -238,6 +259,10 @@ export function projectRoutes(db: Db) {return;}assertCompanyAccess(req, existing.companyId);+ assertNoAgentHostWorkspaceCommandMutation(+ req,+ collectProjectWorkspaceCommandPaths(req.body),+ );const workspaceExists = (await svc.listWorkspaces(id)).some((workspace) => workspace.id === workspaceId);if (!workspaceExists) {res.status(404).json({ error: "Project workspace not found" });@@ -290,6 +315,11 @@ export function projectRoutes(db: Db) {return;}+ await assertCanManageProjectWorkspaceRuntimeServices(db, req, {+ companyId: project.companyId,+ projectWorkspaceId: workspace.id,+ });+const workspaceCwd = workspace.cwd;if (!workspaceCwd) {res.status(422).json({ error: "Project workspace needs a local path before Paperclip can run workspace commands" });diff --git a/server/src/routes/workspace-command-authz.ts b/server/src/routes/workspace-command-authz.tsnew file mode 100644index 0000000000..e7999d11d5--- /dev/null+++ b/server/src/routes/workspace-command-authz.ts@@ -0,0 +1,115 @@+import type { Request } from "express";+import { forbidden } from "../errors.js";++function isRecord(value: unknown): value is Record<string, unknown> {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++function hasOwn(value: Record<string, unknown>, key: string) {+ return Object.prototype.hasOwnProperty.call(value, key);+}++function prefixPath(prefix: string, key: string) {+ return prefix.length > 0 ? `${prefix}.${key}` : key;+}++function collectWorkspaceStrategyCommandPaths(raw: unknown, prefix: string): string[] {+ if (!isRecord(raw)) return [];+ const paths: string[] = [];+ if (hasOwn(raw, "provisionCommand")) {+ paths.push(prefixPath(prefix, "provisionCommand"));+ }+ if (hasOwn(raw, "teardownCommand")) {+ paths.push(prefixPath(prefix, "teardownCommand"));+ }+ return paths;+}++function collectExecutionWorkspaceConfigCommandPaths(raw: unknown, prefix: string): string[] {+ if (!isRecord(raw)) return [];+ const paths: string[] = [];+ if (hasOwn(raw, "provisionCommand")) {+ paths.push(prefixPath(prefix, "provisionCommand"));+ }+ if (hasOwn(raw, "teardownCommand")) {+ paths.push(prefixPath(prefix, "teardownCommand"));+ }+ if (hasOwn(raw, "cleanupCommand")) {+ paths.push(prefixPath(prefix, "cleanupCommand"));+ }+ return paths;+}++export function assertNoAgentHostWorkspaceCommandMutation(req: Request, paths: string[]) {+ if (req.actor.type !== "agent" || paths.length === 0) return;+ throw forbidden(+ `Agent keys cannot modify host-executed workspace commands (${paths.join(", ")}).`,+ );+}++export function collectAgentAdapterWorkspaceCommandPaths(adapterConfig: unknown): string[] {+ if (!isRecord(adapterConfig)) return [];+ return collectWorkspaceStrategyCommandPaths(+ adapterConfig.workspaceStrategy,+ "adapterConfig.workspaceStrategy",+ );+}++export function collectProjectExecutionWorkspaceCommandPaths(policy: unknown): string[] {+ if (!isRecord(policy)) return [];+ return collectWorkspaceStrategyCommandPaths(+ policy.workspaceStrategy,+ "executionWorkspacePolicy.workspaceStrategy",+ );+}++export function collectProjectWorkspaceCommandPaths(+ workspacePatch: unknown,+ prefix = "",+): string[] {+ if (!isRecord(workspacePatch)) return [];+ return hasOwn(workspacePatch, "cleanupCommand")+ ? [prefixPath(prefix, "cleanupCommand")]+ : [];+}++export function collectIssueWorkspaceCommandPaths(input: {+ executionWorkspaceSettings?: unknown;+ assigneeAdapterOverrides?: unknown;+}): string[] {+ const paths: string[] = [];+ if (isRecord(input.executionWorkspaceSettings)) {+ paths.push(+ ...collectWorkspaceStrategyCommandPaths(+ input.executionWorkspaceSettings.workspaceStrategy,+ "executionWorkspaceSettings.workspaceStrategy",+ ),+ );+ }+ if (isRecord(input.assigneeAdapterOverrides)) {+ const adapterConfig = input.assigneeAdapterOverrides.adapterConfig;+ if (isRecord(adapterConfig)) {+ paths.push(+ ...collectWorkspaceStrategyCommandPaths(+ adapterConfig.workspaceStrategy,+ "assigneeAdapterOverrides.adapterConfig.workspaceStrategy",+ ),+ );+ }+ }+ return paths;+}++export function collectExecutionWorkspaceCommandPaths(input: {+ config?: unknown;+ metadata?: unknown;+}): string[] {+ const paths: string[] = [];+ if (input.config !== undefined) {+ paths.push(...collectExecutionWorkspaceConfigCommandPaths(input.config, "config"));+ }+ if (isRecord(input.metadata) && hasOwn(input.metadata, "config")) {+ paths.push(...collectExecutionWorkspaceConfigCommandPaths(input.metadata.config, "metadata.config"));+ }+ return paths;+}diff --git a/server/src/routes/workspace-runtime-service-authz.ts b/server/src/routes/workspace-runtime-service-authz.tsnew file mode 100644index 0000000000..16cff277be--- /dev/null+++ b/server/src/routes/workspace-runtime-service-authz.ts@@ -0,0 +1,138 @@+import { and, eq, inArray, isNull, ne, or } from "drizzle-orm";+import type { Db } from "@paperclipai/db";+import { agents, issues } from "@paperclipai/db";+import type { Request } from "express";+import { forbidden } from "../errors.js";+import { assertCompanyAccess } from "./authz.js";++const WORKSPACE_RUNTIME_ELIGIBLE_ISSUE_STATUSES: string[] = [+ "backlog",+ "todo",+ "in_progress",+ "in_review",+ "blocked",+];++async function listReportingSubtreeAgentIds(db: Db, companyId: string, actorAgentId: string) {+ const companyAgents = await db+ .select({+ id: agents.id,+ reportsTo: agents.reportsTo,+ })+ .from(agents)+ .where(and(eq(agents.companyId, companyId), ne(agents.status, "terminated")));++ const reportsByManager = new Map<string, string[]>();+ for (const agent of companyAgents) {+ if (!agent.reportsTo) continue;+ const reports = reportsByManager.get(agent.reportsTo) ?? [];+ reports.push(agent.id);+ reportsByManager.set(agent.reportsTo, reports);+ }++ const visited = new Set<string>([actorAgentId]);+ const queue = [actorAgentId];+ while (queue.length > 0) {+ const current = queue.shift();+ if (!current) continue;+ const reports = reportsByManager.get(current) ?? [];+ for (const reportId of reports) {+ if (visited.has(reportId)) continue;+ visited.add(reportId);+ queue.push(reportId);+ }+ }++ return [...visited];+}++async function assertAgentCanManageRuntimeServicesForWorkspace(+ db: Db,+ req: Request,+ input: {+ companyId: string;+ projectWorkspaceId?: string | null;+ executionWorkspaceId?: string | null;+ sourceIssueId?: string | null;+ },+) {+ if (req.actor.type !== "agent" || !req.actor.agentId) {+ throw forbidden("Agent authentication required");+ }++ const actorAgent = await db+ .select({+ id: agents.id,+ companyId: agents.companyId,+ role: agents.role,+ })+ .from(agents)+ .where(eq(agents.id, req.actor.agentId))+ .then((rows) => rows[0] ?? null);++ if (!actorAgent || actorAgent.companyId !== input.companyId) {+ throw forbidden("Agent key cannot access another company");+ }++ if (actorAgent.role === "ceo") {+ return;+ }++ const eligibleAgentIds = await listReportingSubtreeAgentIds(db, input.companyId, actorAgent.id);+ const workspaceScopeConditions = [+ input.projectWorkspaceId ? eq(issues.projectWorkspaceId, input.projectWorkspaceId) : null,+ input.executionWorkspaceId ? eq(issues.executionWorkspaceId, input.executionWorkspaceId) : null,+ input.sourceIssueId ? eq(issues.id, input.sourceIssueId) : null,+ ].filter((condition): condition is NonNullable<typeof condition> => condition !== null);++ if (workspaceScopeConditions.length === 0) {+ throw forbidden("Missing permission to manage workspace runtime services");+ }++ const linkedIssue = await db+ .select({ id: issues.id })+ .from(issues)+ .where(and(+ eq(issues.companyId, input.companyId),+ isNull(issues.hiddenAt),+ inArray(issues.status, WORKSPACE_RUNTIME_ELIGIBLE_ISSUE_STATUSES),+ inArray(issues.assigneeAgentId, eligibleAgentIds),+ workspaceScopeConditions.length === 1+ ? workspaceScopeConditions[0]!+ : or(...workspaceScopeConditions),+ ))+ .then((rows) => rows[0] ?? null);++ if (linkedIssue) {+ return;+ }++ throw forbidden("Missing permission to manage workspace runtime services");+}++export async function assertCanManageProjectWorkspaceRuntimeServices(+ db: Db,+ req: Request,+ input: {+ companyId: string;+ projectWorkspaceId: string;+ },+) {+ assertCompanyAccess(req, input.companyId);+ if (req.actor.type === "board") return;+ await assertAgentCanManageRuntimeServicesForWorkspace(db, req, input);+}++export async function assertCanManageExecutionWorkspaceRuntimeServices(+ db: Db,+ req: Request,+ input: {+ companyId: string;+ executionWorkspaceId: string;+ sourceIssueId?: string | null;+ },+) {+ assertCompanyAccess(req, input.companyId);+ if (req.actor.type === "board") return;+ await assertAgentCanManageRuntimeServicesForWorkspace(db, req, input);+}diff --git a/server/src/services/agents.ts b/server/src/services/agents.tsindex abba741491..6cacb441f5 100644--- a/server/src/services/agents.ts+++ b/server/src/services/agents.ts@@ -619,11 +619,25 @@ export function agentService(db: Db) {.from(agentApiKeys).where(eq(agentApiKeys.agentId, id)),- revokeKey: async (keyId: string) => {+ getKeyById: async (keyId: string) =>+ db+ .select({+ id: agentApiKeys.id,+ agentId: agentApiKeys.agentId,+ companyId: agentApiKeys.companyId,+ name: agentApiKeys.name,+ createdAt: agentApiKeys.createdAt,+ revokedAt: agentApiKeys.revokedAt,+ })+ .from(agentApiKeys)+ .where(eq(agentApiKeys.id, keyId))+ .then((rows) => rows[0] ?? null),++ revokeKey: async (agentId: string, keyId: string) => {const rows = await db.update(agentApiKeys).set({ revokedAt: new Date() })- .where(eq(agentApiKeys.id, keyId))+ .where(and(eq(agentApiKeys.id, keyId), eq(agentApiKeys.agentId, agentId))).returning();return rows[0] ?? null;},diff --git a/server/src/services/company-portability.ts b/server/src/services/company-portability.tsindex ff29a180b2..305f6a761b 100644--- a/server/src/services/company-portability.ts+++ b/server/src/services/company-portability.ts@@ -47,7 +47,9 @@ import {readPaperclipSkillSyncPreference,writePaperclipSkillSyncPreference,} from "@paperclipai/adapter-utils/server-utils";-import { notFound, unprocessable } from "../errors.js";+import { ensureOpenCodeModelConfiguredAndAvailable } from "@paperclipai/adapter-opencode-local/server";+import { findServerAdapter } from "../adapters/index.js";+import { forbidden, notFound, unprocessable } from "../errors.js";import { ghFetch, gitHubApiBase, resolveRawGitHubUrl } from "./github-fetch.js";import type { StorageService } from "../storage/types.js";import { accessService } from "./access.js";@@ -62,6 +64,7 @@ import { validateCron } from "./cron.js";import { issueService } from "./issues.js";import { projectService } from "./projects.js";import { routineService } from "./routines.js";+import { secretService } from "./secrets.js";/** Build OrgNode tree from manifest agent list (slug + reportsToSlug). */function buildOrgTreeFromManifest(agents: CompanyPortabilityManifest["agents"]): OrgNode[] {@@ -117,6 +120,7 @@ const DEFAULT_INCLUDE: CompanyPortabilityInclude = {};const DEFAULT_COLLISION_STRATEGY: CompanyPortabilityCollisionStrategy = "rename";+const IMPORT_FORBIDDEN_ADAPTER_TYPES = new Set(["process", "http"]);const execFileAsync = promisify(execFile);let bundledSkillsCommitPromise: Promise<string | null> | null = null;@@ -2747,6 +2751,94 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {const projects = projectService(db);const issues = issueService(db);const companySkills = companySkillService(db);+ const secrets = secretService(db);+ const strictSecretsMode = process.env.PAPERCLIP_SECRETS_STRICT_MODE === "true";++ function assertKnownImportAdapterType(type: string | null | undefined): string {+ const adapterType = typeof type === "string" ? type.trim() : "";+ if (!adapterType) {+ throw unprocessable("Adapter type is required");+ }+ if (!findServerAdapter(adapterType)) {+ throw unprocessable(`Unknown adapter type: ${adapterType}`);+ }+ return adapterType;+ }++ async function assertImportAdapterConfigConstraints(+ companyId: string,+ adapterType: string,+ adapterConfig: Record<string, unknown>,+ ) {+ if (adapterType !== "opencode_local") return;+ const { config: runtimeConfig } = await secrets.resolveAdapterConfigForRuntime(companyId, adapterConfig);+ const runtimeEnv = isPlainRecord(runtimeConfig.env) ? runtimeConfig.env : {};+ try {+ await ensureOpenCodeModelConfiguredAndAvailable({+ model: runtimeConfig.model,+ command: runtimeConfig.command,+ cwd: runtimeConfig.cwd,+ env: runtimeEnv,+ });+ } catch (err) {+ const reason = err instanceof Error ? err.message : String(err);+ throw unprocessable(`Invalid opencode_local adapterConfig: ${reason}`);+ }+ }++ async function prepareImportedAgentAdapter(+ companyId: string,+ adapterType: string | null | undefined,+ adapterConfig: Record<string, unknown>,+ desiredSkills: string[],+ mode: ImportMode,+ ) {+ const effectiveAdapterType = assertKnownImportAdapterType(adapterType);+ if (mode === "agent_safe" && IMPORT_FORBIDDEN_ADAPTER_TYPES.has(effectiveAdapterType)) {+ throw forbidden(`Adapter type "${effectiveAdapterType}" is not allowed in safe imports`);+ }+ const nextAdapterConfig = writePaperclipSkillSyncPreference({ ...adapterConfig }, desiredSkills);+ delete nextAdapterConfig.promptTemplate;+ delete nextAdapterConfig.bootstrapPromptTemplate;+ delete nextAdapterConfig.instructionsFilePath;+ delete nextAdapterConfig.instructionsBundleMode;+ delete nextAdapterConfig.instructionsRootPath;+ delete nextAdapterConfig.instructionsEntryFile;+ const normalizedAdapterConfig = await secrets.normalizeAdapterConfigForPersistence(+ companyId,+ nextAdapterConfig,+ { strictMode: strictSecretsMode },+ );+ await assertImportAdapterConfigConstraints(companyId, effectiveAdapterType, normalizedAdapterConfig);+ return {+ adapterType: effectiveAdapterType,+ adapterConfig: normalizedAdapterConfig,+ };+ }++ function resolveImportedAssigneeAgentId(+ assigneeSlug: string | null | undefined,+ importedSlugToAgentId: Map<string, string>,+ existingSlugToAgentId: Map<string, string>,+ agentStatusById: Map<string, string | null | undefined>,+ warnings: string[],+ subjectLabel: string,+ ) {+ if (!assigneeSlug) return null;+ const assigneeAgentId =+ importedSlugToAgentId.get(assigneeSlug)+ ?? existingSlugToAgentId.get(assigneeSlug)+ ?? null;+ if (!assigneeAgentId) return null;+ const assigneeStatus = agentStatusById.get(assigneeAgentId) ?? null;+ if (assigneeStatus === "pending_approval" || assigneeStatus === "terminated") {+ warnings.push(+ `${subjectLabel} assignee ${assigneeSlug} is ${assigneeStatus}; imported work was left unassigned.`,+ );+ return null;+ }+ return assigneeAgentId;+ }async function resolveSource(source: CompanyPortabilityPreview["source"]): Promise<ResolvedSource> {if (source.type === "inline") {@@ -3856,7 +3948,11 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {const warnings = [...plan.preview.warnings];const include = plan.include;- let targetCompany: { id: string; name: string } | null = null;+ let targetCompany: {+ id: string;+ name: string;+ requireBoardApprovalForNewAgents?: boolean | null;+ } | null = null;let companyAction: "created" | "updated" | "unchanged" = "unchanged";if (input.target.mode === "new_company") {@@ -3977,9 +4073,11 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {const resultProjects: CompanyPortabilityImportResult["projects"] = [];const importedSlugToAgentId = new Map<string, string>();const existingSlugToAgentId = new Map<string, string>();+ const agentStatusById = new Map<string, string | null | undefined>();const existingAgents = await agents.list(targetCompany.id);for (const existing of existingAgents) {existingSlugToAgentId.set(normalizeAgentUrlKey(existing.name) ?? existing.id, existing.id);+ agentStatusById.set(existing.id, existing.status);}const importedSlugToProjectId = new Map<string, string>();const importedProjectWorkspaceIdByProjectSlug = new Map<string, Map<string, string>>();@@ -4049,22 +4147,18 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {// Apply adapter overrides from request if presentconst adapterOverride = input.adapterOverrides?.[planAgent.slug];- const effectiveAdapterType = adapterOverride?.adapterType ?? manifestAgent.adapterType;const baseAdapterConfig = adapterOverride?.adapterConfig? { ...adapterOverride.adapterConfig }: { ...manifestAgent.adapterConfig } as Record<string, unknown>;const desiredSkills = (manifestAgent.skills ?? []).map((skillRef) => desiredSkillRefMap.get(skillRef) ?? skillRef);- const adapterConfigWithSkills = writePaperclipSkillSyncPreference(+ const normalizedAdapter = await prepareImportedAgentAdapter(+ targetCompany.id,+ adapterOverride?.adapterType ?? manifestAgent.adapterType,baseAdapterConfig,desiredSkills,+ mode,);- delete adapterConfigWithSkills.promptTemplate;- delete adapterConfigWithSkills.bootstrapPromptTemplate; // deprecated- delete adapterConfigWithSkills.instructionsFilePath;- delete adapterConfigWithSkills.instructionsBundleMode;- delete adapterConfigWithSkills.instructionsRootPath;- delete adapterConfigWithSkills.instructionsEntryFile;const patch = {name: planAgent.plannedName,role: manifestAgent.role,@@ -4072,8 +4166,8 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {icon: manifestAgent.icon,capabilities: manifestAgent.capabilities,reportsTo: null,- adapterType: effectiveAdapterType,- adapterConfig: adapterConfigWithSkills,+ adapterType: normalizedAdapter.adapterType,+ adapterConfig: normalizedAdapter.adapterConfig,runtimeConfig: disableImportedTimerHeartbeat(manifestAgent.runtimeConfig),budgetMonthlyCents: manifestAgent.budgetMonthlyCents,permissions: manifestAgent.permissions,@@ -4102,6 +4196,7 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {} catch (err) {warnings.push(`Failed to materialize instructions bundle for ${manifestAgent.slug}: ${err instanceof Error ? err.message : String(err)}`);}+ agentStatusById.set(updated.id, updated.status ?? agentStatusById.get(updated.id) ?? null);importedSlugToAgentId.set(planAgent.slug, updated.id);existingSlugToAgentId.set(normalizeAgentUrlKey(updated.name) ?? updated.id, updated.id);resultAgents.push({@@ -4114,7 +4209,17 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {continue;}- let created = await agents.create(targetCompany.id, patch);+ const requiresApproval =+ typeof targetCompany.requireBoardApprovalForNewAgents === "boolean"+ ? targetCompany.requireBoardApprovalForNewAgents+ : include.company+ ? (sourceManifest.company?.requireBoardApprovalForNewAgents ?? true)+ : true;+ const createdStatus = requiresApproval ? "pending_approval" : "idle";+ let created = await agents.create(targetCompany.id, {+ ...patch,+ status: createdStatus,+ });await access.ensureMembership(targetCompany.id, "agent", created.id, "member", "active");await access.setPrincipalPermission(targetCompany.id,@@ -4133,6 +4238,7 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {} catch (err) {warnings.push(`Failed to materialize instructions bundle for ${manifestAgent.slug}: ${err instanceof Error ? err.message : String(err)}`);}+ agentStatusById.set(created.id, created.status ?? createdStatus);importedSlugToAgentId.set(planAgent.slug, created.id);existingSlugToAgentId.set(normalizeAgentUrlKey(created.name) ?? created.id, created.id);resultAgents.push({@@ -4275,11 +4381,14 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {const markdownRaw = readPortableTextFile(plan.source.files, manifestIssue.path);const parsed = markdownRaw ? parseFrontmatterMarkdown(markdownRaw) : null;const description = parsed?.body || manifestIssue.description || null;- const assigneeAgentId = manifestIssue.assigneeAgentSlug- ? importedSlugToAgentId.get(manifestIssue.assigneeAgentSlug)- ?? existingSlugToAgentId.get(manifestIssue.assigneeAgentSlug)- ?? null- : null;+ const assigneeAgentId = resolveImportedAssigneeAgentId(+ manifestIssue.assigneeAgentSlug,+ importedSlugToAgentId,+ existingSlugToAgentId,+ agentStatusById,+ warnings,+ `Task ${manifestIssue.slug}`,+ );const projectId = manifestIssue.projectSlug? importedSlugToProjectId.get(manifestIssue.projectSlug)?? existingProjectSlugToId.get(manifestIssue.projectSlug)@@ -4292,8 +4401,8 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {warnings.push(`Task ${manifestIssue.slug} references workspace key ${manifestIssue.projectWorkspaceKey}, but that workspace was not imported.`);}if (manifestIssue.recurring) {- if (!projectId || !assigneeAgentId) {- throw unprocessable(`Recurring task ${manifestIssue.slug} is missing the project or assignee required to create a routine.`);+ if (!projectId) {+ throw unprocessable(`Recurring task ${manifestIssue.slug} is missing the project required to create a routine.`);}const resolvedRoutine = resolvePortableRoutineDefinition(manifestIssue, parsed?.frontmatter.schedule);if (resolvedRoutine.errors.length > 0) {@@ -4373,15 +4482,20 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {}continue;}+ let issueStatus = manifestIssue.status && ISSUE_STATUSES.includes(manifestIssue.status as any)+ ? manifestIssue.status as typeof ISSUE_STATUSES[number]+ : "backlog";+ if (!assigneeAgentId && issueStatus === "in_progress") {+ warnings.push(`Task ${manifestIssue.slug} was downgraded to todo because its assignee could not be imported as assignable work.`);+ issueStatus = "todo";+ }await issues.create(targetCompany.id, {projectId,projectWorkspaceId,title: manifestIssue.title,description,assigneeAgentId,- status: manifestIssue.status && ISSUE_STATUSES.includes(manifestIssue.status as any)- ? manifestIssue.status as typeof ISSUE_STATUSES[number]- : "backlog",+ status: issueStatus,priority: manifestIssue.priority && ISSUE_PRIORITIES.includes(manifestIssue.priority as any)? manifestIssue.priority as typeof ISSUE_PRIORITIES[number]: "medium",diff --git a/ui/src/components/InlineEditor.test.tsx b/ui/src/components/InlineEditor.test.tsxindex 1f474f7b1f..830d2cedc6 100644--- a/ui/src/components/InlineEditor.test.tsx+++ b/ui/src/components/InlineEditor.test.tsx@@ -164,6 +164,62 @@ describe("InlineEditor", () => {});outside.remove();});++ it("syncs a new multiline value while focused when the user has not edited locally", () => {+ const onSave = vi.fn().mockResolvedValue(undefined);+ const root = createRoot(container);++ act(() => {+ root.render(<InlineEditor value="" multiline onSave={onSave} />);+ });++ const textarea = container.querySelector<HTMLTextAreaElement>('[data-testid="multiline-md-mock"]');+ expect(textarea).not.toBeNull();+ expect(textarea?.value).toBe("");++ act(() => {+ textarea!.focus();+ });++ act(() => {+ root.render(<InlineEditor value="Loaded description" multiline onSave={onSave} />);+ });++ expect(textarea?.value).toBe("Loaded description");++ act(() => {+ root.unmount();+ });+ });++ it("preserves focused multiline local edits when the prop value changes underneath them", () => {+ const onSave = vi.fn().mockResolvedValue(undefined);+ const root = createRoot(container);++ act(() => {+ root.render(<InlineEditor value="Original" multiline onSave={onSave} />);+ });++ const textarea = container.querySelector<HTMLTextAreaElement>('[data-testid="multiline-md-mock"]');+ expect(textarea).not.toBeNull();++ act(() => {+ textarea!.focus();+ });+ act(() => {+ setNativeTextareaValue(textarea!, "Local draft");+ });++ act(() => {+ root.render(<InlineEditor value="Remote update" multiline onSave={onSave} />);+ });++ expect(textarea?.value).toBe("Local draft");++ act(() => {+ root.unmount();+ });+ });});describe("queueContainedBlurCommit", () => {diff --git a/ui/src/components/InlineEditor.tsx b/ui/src/components/InlineEditor.tsxindex f509fe7aa6..2c878b3fa2 100644--- a/ui/src/components/InlineEditor.tsx+++ b/ui/src/components/InlineEditor.tsx@@ -54,6 +54,7 @@ export function InlineEditor({const [editing, setEditing] = useState(false);const [multilineFocused, setMultilineFocused] = useState(false);const [draft, setDraft] = useState(value);+ const lastPropValueRef = useRef(value);const inputRef = useRef<HTMLTextAreaElement>(null);const markdownRef = useRef<MarkdownEditorRef>(null);const autosaveDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);@@ -66,8 +67,14 @@ export function InlineEditor({} = useAutosaveIndicator();useEffect(() => {- if (multiline && multilineFocused) return;- setDraft(value);+ const previousValue = lastPropValueRef.current;+ lastPropValueRef.current = value;+ setDraft((currentDraft) => {+ if (multiline && multilineFocused && currentDraft !== previousValue) {+ return currentDraft;+ }+ return value;+ });}, [value, multiline, multilineFocused]);useEffect(() => {diff --git a/ui/src/components/IssueLinkQuicklook.tsx b/ui/src/components/IssueLinkQuicklook.tsxindex b6311eff1a..1d66b2d0f7 100644--- a/ui/src/components/IssueLinkQuicklook.tsx+++ b/ui/src/components/IssueLinkQuicklook.tsx@@ -6,8 +6,7 @@ import { useQuery, useQueryClient } from "@tanstack/react-query";import { timeAgo } from "@/lib/timeAgo";import { createIssueDetailPath, withIssueDetailHeaderSeed } from "@/lib/issueDetailBreadcrumb";import {- fetchIssueDetail,- getCachedIssueDetail,+ getIssueDetailQueryOptions,ISSUE_DETAIL_STALE_TIME_MS,prefetchIssueDetail,} from "@/lib/issueDetailCache";@@ -98,12 +97,9 @@ export const IssueLinkQuicklook = React.forwardRef<const queryClient = useQueryClient();const [open, setOpen] = useState(false);const prefetchedState = issuePrefetch ? withIssueDetailHeaderSeed(state, issuePrefetch) : state;- const cachedIssue = getCachedIssueDetail(queryClient, issuePathId, issuePrefetch ?? undefined);const { data, isLoading } = useQuery({- queryKey: queryKeys.issues.detail(issuePathId),- queryFn: () => fetchIssueDetail(queryClient, issuePathId),+ ...getIssueDetailQueryOptions(queryClient, issuePathId, { placeholderIssue: issuePrefetch ?? undefined }),enabled: open,- initialData: () => cachedIssue,staleTime: ISSUE_DETAIL_STALE_TIME_MS,});diff --git a/ui/src/components/MarkdownBody.test.tsx b/ui/src/components/MarkdownBody.test.tsxindex 814d83b05c..ebbf6953cc 100644--- a/ui/src/components/MarkdownBody.test.tsx+++ b/ui/src/components/MarkdownBody.test.tsx@@ -96,6 +96,13 @@ describe("MarkdownBody", () => {expect(html).toContain('data-mention-kind="skill"');});+ it("sanitizes unsafe javascript markdown links", () => {+ const html = renderMarkdown("[click me](javascript:alert(document.cookie))");++ expect(html).toContain('<a href="" rel="noreferrer">click me</a>');+ expect(html).not.toContain("javascript:");+ });+it("uses soft-break styling by default", () => {const html = renderMarkdown("First line\nSecond line");diff --git a/ui/src/components/MarkdownBody.tsx b/ui/src/components/MarkdownBody.tsxindex c9fdf85988..642fb798e7 100644--- a/ui/src/components/MarkdownBody.tsx+++ b/ui/src/components/MarkdownBody.tsx@@ -1,6 +1,6 @@import { isValidElement, useEffect, useId, useState, type ReactNode } from "react";import { useQuery } from "@tanstack/react-query";-import Markdown, { type Components, type Options } from "react-markdown";+import Markdown, { defaultUrlTransform, type Components, type Options } from "react-markdown";import remarkGfm from "remark-gfm";import { cn } from "../lib/utils";import { useTheme } from "../context/ThemeContext";@@ -71,6 +71,10 @@ function extractMermaidSource(children: ReactNode): string | null {return flattenText(childProps.children).replace(/\n$/, "");}+function safeMarkdownUrlTransform(url: string): string {+ return parseMentionChipHref(url) ? url : defaultUrlTransform(url);+}+function MermaidDiagramBlock({ source, darkMode }: { source: string; darkMode: boolean }) {const renderId = useId().replace(/[^a-zA-Z0-9_-]/g, "");const [svg, setSvg] = useState<string | null>(null);@@ -215,7 +219,11 @@ export function MarkdownBody({)}style={style}>- <Markdown remarkPlugins={remarkPlugins} components={components} urlTransform={(url) => url}>+ <Markdown+ remarkPlugins={remarkPlugins}+ components={components}+ urlTransform={safeMarkdownUrlTransform}+ >{children}</Markdown></div>diff --git a/ui/src/components/MarkdownEditor.test.tsx b/ui/src/components/MarkdownEditor.test.tsxindex 106a394b99..976ad51c56 100644--- a/ui/src/components/MarkdownEditor.test.tsx+++ b/ui/src/components/MarkdownEditor.test.tsx@@ -19,6 +19,7 @@ const mdxEditorMockState = vi.hoisted(() => ({emitMountParseError: false,emitMountSilentEmptyState: false,markdownValues: [] as string[],+ suppressHtmlProcessingValues: [] as boolean[],}));vi.mock("@mdxeditor/editor", async () => {@@ -41,16 +42,19 @@ vi.mock("@mdxeditor/editor", async () => {onChange,onError,className,+ suppressHtmlProcessing,}: {markdown: string;placeholder?: string;onChange?: (value: string) => void;onError?: (error: unknown) => void;+ suppressHtmlProcessing?: boolean;className?: string;},forwardedRef: React.ForwardedRef<{ setMarkdown: (value: string) => void; focus: () => void } | null>,) {mdxEditorMockState.markdownValues.push(markdown);+ mdxEditorMockState.suppressHtmlProcessingValues.push(Boolean(suppressHtmlProcessing));const [content, setContent] = React.useState(markdown);const editableRef = React.useRef<HTMLDivElement>(null);const handle = React.useMemo(() => ({@@ -59,8 +63,16 @@ vi.mock("@mdxeditor/editor", async () => {}), []);React.useEffect(() => {+ if (!suppressHtmlProcessing && markdown.includes("<img ")) {+ setContent("");+ onError?.({+ error: "Error parsing markdown: HTML-like formatting requires suppressHtmlProcessing",+ source: markdown,+ });+ return;+ }setContent(markdown);- }, [markdown]);+ }, [markdown, onError, suppressHtmlProcessing]);React.useEffect(() => {setForwardedRef(forwardedRef, null);@@ -165,6 +177,7 @@ describe("MarkdownEditor", () => {mdxEditorMockState.emitMountParseError = false;mdxEditorMockState.emitMountSilentEmptyState = false;mdxEditorMockState.markdownValues = [];+ mdxEditorMockState.suppressHtmlProcessingValues = [];});it("applies async external value updates once the editor ref becomes ready", async () => {@@ -238,6 +251,7 @@ describe("MarkdownEditor", () => {await flush();expect(mdxEditorMockState.markdownValues.at(-1)).toContain("");expect(mdxEditorMockState.markdownValues.at(-1)).not.toContain("<img");+ expect(mdxEditorMockState.suppressHtmlProcessingValues).toContain(false);expect(container.textContent).toContain("Before");expect(container.textContent).toContain("After");@@ -262,11 +276,9 @@ describe("MarkdownEditor", () => {});await flush();-await vi.waitFor(() => {expect(container.querySelector("textarea")).not.toBeNull();});-const textarea = container.querySelector("textarea");expect(textarea).not.toBeNull();expect(textarea?.value).toBe("Affected versions: <= v0.3.1");@@ -294,11 +306,9 @@ describe("MarkdownEditor", () => {});await flush();-await vi.waitFor(() => {expect(container.querySelector("textarea")).not.toBeNull();});-const textarea = container.querySelector("textarea");expect(textarea).not.toBeNull();expect(textarea?.value).toBe("Affected versions: <= v0.3.1");@@ -309,7 +319,6 @@ describe("MarkdownEditor", () => {root.unmount();});});-it("anchors the mention menu inside the visual viewport when mobile offsets are present", () => {expect(computeMentionMenuPosition(diff --git a/ui/src/lib/issueDetailCache.ts b/ui/src/lib/issueDetailCache.tsindex 8e02e46eb8..a2770b3118 100644--- a/ui/src/lib/issueDetailCache.ts+++ b/ui/src/lib/issueDetailCache.ts@@ -84,6 +84,20 @@ export async function fetchIssueDetail(return seedIssueDetailCache(queryClient, issue, { issueRef });}+export function getIssueDetailQueryOptions(+ queryClient: QueryClient,+ issueRef: string,+ options?: {+ placeholderIssue?: Pick<Issue, "id" | "identifier"> | null;+ },+) {+ return {+ queryKey: queryKeys.issues.detail(issueRef),+ queryFn: () => fetchIssueDetail(queryClient, issueRef),+ placeholderData: getCachedIssueDetail(queryClient, issueRef, options?.placeholderIssue ?? undefined),+ };+}+export function prefetchIssueDetail(queryClient: QueryClient,issueRef: string,diff --git a/ui/src/lib/issueDetailQuery.test.tsx b/ui/src/lib/issueDetailQuery.test.tsxnew file mode 100644index 0000000000..83be05ddb1--- /dev/null+++ b/ui/src/lib/issueDetailQuery.test.tsx@@ -0,0 +1,129 @@+// @vitest-environment jsdom++import { act } from "react";+import { createRoot } from "react-dom/client";+import type { Issue } from "@paperclipai/shared";+import { QueryClient, QueryClientProvider, useQuery, useQueryClient } from "@tanstack/react-query";+import { afterEach, describe, expect, it, vi } from "vitest";+import { issuesApi } from "@/api/issues";+import { queryKeys } from "@/lib/queryKeys";+import { getIssueDetailQueryOptions } from "./issueDetailCache";++vi.mock("@/api/issues", () => ({+ issuesApi: {+ get: vi.fn(),+ },+}));++// eslint-disable-next-line @typescript-eslint/no-explicit-any+(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;++function makeIssue(overrides: Partial<Issue> = {}): Issue {+ const now = new Date("2026-04-13T20:00:00.000Z");+ return {+ id: "issue-1",+ companyId: "company-1",+ projectId: null,+ projectWorkspaceId: null,+ goalId: null,+ parentId: null,+ title: "Issue title",+ description: null,+ status: "todo",+ priority: "medium",+ assigneeAgentId: null,+ assigneeUserId: null,+ checkoutRunId: null,+ executionRunId: null,+ executionAgentNameKey: null,+ executionLockedAt: null,+ createdByAgentId: null,+ createdByUserId: null,+ issueNumber: 1442,+ identifier: "PAP-1442",+ requestDepth: 0,+ billingCode: null,+ assigneeAdapterOverrides: null,+ executionWorkspaceId: null,+ executionWorkspacePreference: null,+ executionWorkspaceSettings: null,+ startedAt: null,+ completedAt: null,+ cancelledAt: null,+ hiddenAt: null,+ createdAt: now,+ updatedAt: now,+ ...overrides,+ };+}++function IssueDetailQueryHarness({+ issueRef,+ placeholderIssue,+}: {+ issueRef: string;+ placeholderIssue?: Pick<Issue, "id" | "identifier"> | null;+}) {+ const queryClient = useQueryClient();+ const query = useQuery({+ ...getIssueDetailQueryOptions(queryClient, issueRef, { placeholderIssue }),+ });++ return <div>{query.data?.description ?? "EMPTY"}</div>;+}++async function flush() {+ // Multiple act cycles to allow React Query to process the async queryFn+ for (let i = 0; i < 5; i++) {+ await act(async () => {+ await new Promise((r) => setTimeout(r, 0));+ });+ }+}++describe("getIssueDetailQueryOptions", () => {+ afterEach(() => {+ vi.clearAllMocks();+ });++ it("treats cached issue data as placeholder and still fetches full detail", async () => {+ const container = document.createElement("div");+ document.body.appendChild(container);+ const root = createRoot(container);+ const queryClient = new QueryClient({+ defaultOptions: {+ queries: {+ retry: false,+ },+ },+ });+ const partialIssue = makeIssue({ description: null });+ const fullIssue = makeIssue({ description: "GitHub Security Advisory body" });++ queryClient.setQueryData(queryKeys.issues.detail("issue-1"), partialIssue);+ queryClient.setQueryData(queryKeys.issues.detail("PAP-1442"), partialIssue);+ vi.mocked(issuesApi.get).mockResolvedValue(fullIssue);++ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <IssueDetailQueryHarness+ issueRef="PAP-1442"+ placeholderIssue={{ id: partialIssue.id, identifier: partialIssue.identifier }}+ />+ </QueryClientProvider>,+ );+ });++ await flush();++ expect(issuesApi.get).toHaveBeenCalledWith("PAP-1442");+ expect(container.textContent).toContain("GitHub Security Advisory body");++ await act(async () => {+ root.unmount();+ });+ queryClient.clear();+ container.remove();+ });+});diff --git a/ui/src/pages/IssueDetail.tsx b/ui/src/pages/IssueDetail.tsxindex 0b2912b828..de2a390db0 100644--- a/ui/src/pages/IssueDetail.tsx+++ b/ui/src/pages/IssueDetail.tsx@@ -28,7 +28,8 @@ import {readIssueDetailHeaderSeed,rememberIssueDetailLocationState,} from "../lib/issueDetailBreadcrumb";-import { fetchIssueDetail, getCachedIssueDetail } from "../lib/issueDetailCache";+import { resolveIssueActiveRun, shouldTrackIssueActiveRun } from "../lib/issueActiveRun";+import { getIssueDetailQueryOptions } from "../lib/issueDetailCache";import {hasBlockingShortcutDialog,resolveIssueDetailGoKeyAction,@@ -882,22 +883,15 @@ export function IssueDetail() {() => readIssueDetailHeaderSeed(location.state) ?? readIssueDetailHeaderSeed(resolvedIssueDetailState),[location.state, resolvedIssueDetailState],);- const cachedIssue = useMemo(- () =>- issueId- ? getCachedIssueDetail(queryClient, issueId, issueHeaderSeed ? {- id: issueHeaderSeed.id,- identifier: issueHeaderSeed.identifier,- } : null)- : undefined,- [issueHeaderSeed, issueId, queryClient],- );const { data: issue, isLoading, error } = useQuery({- queryKey: queryKeys.issues.detail(issueId!),- queryFn: () => fetchIssueDetail(queryClient, issueId!),+ ...getIssueDetailQueryOptions(queryClient, issueId!, {+ placeholderIssue: issueHeaderSeed ? {+ id: issueHeaderSeed.id,+ identifier: issueHeaderSeed.identifier,+ } : null,+ }),enabled: !!issueId,- initialData: () => cachedIssue,});const resolvedCompanyId = issue?.companyId ?? selectedCompanyId;const commentComposerDisabledReason = useMemo(() => {