Skip to content

The open-source app everyone uses to manage agents at work

fix: resolve secret refs before sandbox draft probes (#8256)

Devin Foley04173b341d08
diff --git a/packages/adapter-utils/src/ssh.ts b/packages/adapter-utils/src/ssh.ts
index abf1594012..3a5cc644b4 100644
--- a/packages/adapter-utils/src/ssh.ts
+++ b/packages/adapter-utils/src/ssh.ts
@@ -701,69 +701,89 @@ async function integrateImportedGitHead(input: {
localDir: string;
importedHead: string;
}): Promise<void> {
- const snapshot = await readLocalGitWorkspaceSnapshot(input.localDir);
- if (!snapshot) return;
-
- const currentHead = snapshot.headCommit;
- if (!currentHead || currentHead === input.importedHead) return;
+ const isConcurrentRefUpdateError = (error: unknown) => {
+ const message = error instanceof Error ? error.message : String(error);
+ return message.includes("cannot lock ref") && message.includes("expected");
+ };
- const headRef = snapshot.branchName ? `refs/heads/${snapshot.branchName}` : "HEAD";
- const mergeBase = await runLocalGit(input.localDir, ["merge-base", currentHead, input.importedHead], {
- timeout: 10_000,
- maxBuffer: 16 * 1024,
- }).catch(() => null);
- const mergeBaseHead = mergeBase?.stdout.trim() ?? "";
+ for (let attempt = 0; attempt < 5; attempt += 1) {
+ const snapshot = await readLocalGitWorkspaceSnapshot(input.localDir);
+ if (!snapshot) return;
- if (mergeBaseHead === input.importedHead) {
- return;
- }
+ const currentHead = snapshot.headCommit;
+ if (!currentHead || currentHead === input.importedHead) return;
- if (mergeBaseHead === currentHead) {
- await runLocalGit(input.localDir, ["update-ref", headRef, input.importedHead, currentHead], {
+ const headRef = snapshot.branchName ? `refs/heads/${snapshot.branchName}` : "HEAD";
+ const mergeBase = await runLocalGit(input.localDir, ["merge-base", currentHead, input.importedHead], {
timeout: 10_000,
maxBuffer: 16 * 1024,
- });
- return;
- }
+ }).catch(() => null);
+ const mergeBaseHead = mergeBase?.stdout.trim() ?? "";
- let mergedTree;
- try {
- mergedTree = await runLocalGit(input.localDir, ["merge-tree", "--write-tree", currentHead, input.importedHead], {
- timeout: 60_000,
- maxBuffer: 256 * 1024,
- });
- } catch (error) {
- const reason = error instanceof Error ? error.message : String(error);
- throw new Error(
- `Failed to merge concurrent SSH git histories for ${currentHead.slice(0, 12)} and ${input.importedHead.slice(0, 12)}: ${reason}`,
+ if (mergeBaseHead === input.importedHead) {
+ return;
+ }
+
+ if (mergeBaseHead === currentHead) {
+ try {
+ await runLocalGit(input.localDir, ["update-ref", headRef, input.importedHead, currentHead], {
+ timeout: 10_000,
+ maxBuffer: 16 * 1024,
+ });
+ return;
+ } catch (error) {
+ if (isConcurrentRefUpdateError(error) && attempt < 4) continue;
+ throw error;
+ }
+ }
+
+ let mergedTree;
+ try {
+ mergedTree = await runLocalGit(input.localDir, ["merge-tree", "--write-tree", currentHead, input.importedHead], {
+ timeout: 60_000,
+ maxBuffer: 256 * 1024,
+ });
+ } catch (error) {
+ const reason = error instanceof Error ? error.message : String(error);
+ throw new Error(
+ `Failed to merge concurrent SSH git histories for ${currentHead.slice(0, 12)} and ${input.importedHead.slice(0, 12)}: ${reason}`,
+ );
+ }
+ const mergedTreeId = mergedTree.stdout.trim().split("\n")[0]?.trim() ?? "";
+ if (!mergedTreeId) {
+ throw new Error("Failed to compute a merged git tree for SSH workspace restore.");
+ }
+
+ const mergeCommit = await runLocalGit(
+ input.localDir,
+ [
+ "commit-tree",
+ mergedTreeId,
+ "-p",
+ currentHead,
+ "-p",
+ input.importedHead,
+ "-m",
+ `Paperclip SSH sync merge ${input.importedHead.slice(0, 12)}`,
+ ],
+ {
+ timeout: 60_000,
+ maxBuffer: 64 * 1024,
+ },
);
- }
- const mergedTreeId = mergedTree.stdout.trim().split("\n")[0]?.trim() ?? "";
- if (!mergedTreeId) {
- throw new Error("Failed to compute a merged git tree for SSH workspace restore.");
+ try {
+ await runLocalGit(input.localDir, ["update-ref", headRef, mergeCommit.stdout.trim(), currentHead], {
+ timeout: 10_000,
+ maxBuffer: 16 * 1024,
+ });
+ return;
+ } catch (error) {
+ if (isConcurrentRefUpdateError(error) && attempt < 4) continue;
+ throw error;
+ }
}
- const mergeCommit = await runLocalGit(
- input.localDir,
- [
- "commit-tree",
- mergedTreeId,
- "-p",
- currentHead,
- "-p",
- input.importedHead,
- "-m",
- `Paperclip SSH sync merge ${input.importedHead.slice(0, 12)}`,
- ],
- {
- timeout: 60_000,
- maxBuffer: 64 * 1024,
- },
- );
- await runLocalGit(input.localDir, ["update-ref", headRef, mergeCommit.stdout.trim(), currentHead], {
- timeout: 10_000,
- maxBuffer: 16 * 1024,
- });
+ throw new Error(`Failed to integrate concurrent SSH git history for ${input.importedHead.slice(0, 12)} after multiple retries.`);
}
async function clearRemoteDirectory(input: {
diff --git a/packages/skills-catalog/src/catalog-builder.test.ts b/packages/skills-catalog/src/catalog-builder.test.ts
index 8f0f1bd208..3ef41e552f 100644
--- a/packages/skills-catalog/src/catalog-builder.test.ts
+++ b/packages/skills-catalog/src/catalog-builder.test.ts
@@ -135,6 +135,93 @@ describe("skills catalog manifest", () => {
expect(result.manifest.skills[0]!.contentHash).toMatch(/^sha256:[a-f0-9]{64}$/);
});
+ it("reuses the existing manifest entry when a pinned GitHub reference is temporarily unavailable", async () => {
+ const packageDir = await createCatalogPackage();
+ await writeReference(packageDir, "optional", "research", "remote-research", {
+ source: {
+ type: "github",
+ hostname: "github.com",
+ owner: "example",
+ repo: "remote-skill",
+ ref: "v1.0.0",
+ commit: "0123456789abcdef0123456789abcdef01234567",
+ path: "skills/remote-research",
+ },
+ files: ["SKILL.md", "scripts/**"],
+ recommendedForRoles: ["researcher"],
+ tags: ["research"],
+ });
+ await fs.mkdir(path.join(packageDir, "generated"), { recursive: true });
+ await fs.writeFile(
+ path.join(packageDir, "generated", "catalog.json"),
+ formatCatalogManifest({
+ schemaVersion: 1,
+ packageName: "@paperclipai/skills-catalog",
+ packageVersion: "0.3.1",
+ generatedAt: "2026-05-26T00:00:00.000Z",
+ skills: [{
+ id: "paperclipai:optional:research:remote-research",
+ key: "paperclipai/optional/research/remote-research",
+ kind: "optional",
+ category: "research",
+ slug: "remote-research",
+ name: "Remote Research",
+ description: "Research recent discussion from a pinned upstream skill.",
+ path: "catalog/optional/research/remote-research",
+ entrypoint: "SKILL.md",
+ trustLevel: "scripts_executables",
+ compatibility: "compatible",
+ defaultInstall: false,
+ recommendedForRoles: ["researcher"],
+ requires: [],
+ tags: ["research"],
+ files: [
+ {
+ path: "SKILL.md",
+ kind: "skill",
+ sizeBytes: 128,
+ sha256: "a".repeat(64),
+ },
+ {
+ path: "scripts/run.py",
+ kind: "script",
+ sizeBytes: 14,
+ sha256: "b".repeat(64),
+ },
+ ],
+ contentHash: `sha256:${"c".repeat(64)}`,
+ source: {
+ type: "github",
+ hostname: "github.com",
+ owner: "example",
+ repo: "remote-skill",
+ ref: "v1.0.0",
+ commit: "0123456789abcdef0123456789abcdef01234567",
+ path: "skills/remote-research",
+ url: "https://github.com/example/remote-skill/tree/v1.0.0/skills/remote-research",
+ },
+ }],
+ }),
+ "utf8",
+ );
+ vi.stubGlobal("fetch", vi.fn(async (url: string) => {
+ if (url.includes("/git/trees/")) {
+ return new Response("forbidden", { status: 403 });
+ }
+ return new Response("not found", { status: 404 });
+ }));
+
+ const result = await buildCatalogManifest({
+ packageDir,
+ generatedAt: "2026-05-26T00:00:00.000Z",
+ });
+
+ expect(result.errors).toEqual([]);
+ expect(result.manifest.skills).toHaveLength(1);
+ expect(result.manifest.skills[0]?.name).toBe("Remote Research");
+ expect(result.manifest.skills[0]?.files.map((file) => file.path)).toEqual(["SKILL.md", "scripts/run.py"]);
+ });
+
it("reports frontmatter, directory, uniqueness, and inventory errors together", async () => {
const packageDir = await createCatalogPackage();
await writeSkill(packageDir, "bundled", "Bad_Category", "duplicate", {
diff --git a/packages/skills-catalog/src/catalog-builder.ts b/packages/skills-catalog/src/catalog-builder.ts
index 890b3d5b31..a042e0356e 100644
--- a/packages/skills-catalog/src/catalog-builder.ts
+++ b/packages/skills-catalog/src/catalog-builder.ts
@@ -101,6 +101,8 @@ export async function buildCatalogManifest(
): Promise<BuildCatalogManifestResult> {
const packageDir = path.resolve(options.packageDir);
const packageJson = await readPackageJson(packageDir);
+ const existingManifest = await readExistingManifest(packageDir);
+ const existingSkillsById = new Map(existingManifest?.skills.map((skill) => [skill.id, skill]) ?? []);
const errors: string[] = [];
const candidates = await discoverSkillCandidates(packageDir, errors);
const skills: CatalogSkill[] = [];
@@ -108,7 +110,12 @@ export async function buildCatalogManifest(
collectCandidateUniquenessErrors(candidates, errors);
for (const candidate of candidates) {
- const skill = await buildCatalogSkill(packageDir, candidate, errors);
+ const skill = await buildCatalogSkill(
+ packageDir,
+ candidate,
+ errors,
+ existingSkillsById.get(skillIdForCandidate(candidate)) ?? null,
+ );
if (skill) skills.push(skill);
}
@@ -253,9 +260,10 @@ async function buildCatalogSkill(
packageDir: string,
candidate: SkillCandidate,
errors: string[],
+ existingSkill: CatalogSkill | null,
): Promise<CatalogSkill | null> {
if (candidate.source === "reference") {
- return buildReferencedCatalogSkill(packageDir, candidate, errors);
+ return buildReferencedCatalogSkill(packageDir, candidate, errors, existingSkill);
}
const prefix = relativePackagePath(packageDir, candidate.absolutePath);
@@ -316,10 +324,15 @@ async function buildCatalogSkill(
};
}
+function skillIdForCandidate(candidate: BaseSkillCandidate) {
+ return `paperclipai:${candidate.kind}:${candidate.category}:${candidate.slug}`;
+}
+
async function buildReferencedCatalogSkill(
packageDir: string,
candidate: Extract<SkillCandidate, { source: "reference" }>,
errors: string[],
+ existingSkill: CatalogSkill | null,
): Promise<CatalogSkill | null> {
const prefix = relativePackagePath(packageDir, candidate.absolutePath);
validateSlug("category", candidate.category, prefix, errors);
@@ -332,10 +345,26 @@ async function buildReferencedCatalogSkill(
const key = `paperclipai/${candidate.kind}/${candidate.category}/${candidate.slug}`;
const source = buildCatalogSkillSource(descriptor.source, errors, `${prefix}/${CATALOG_REFERENCE_FILE}`);
if (!source) return null;
+ const fallbackSkill = canReuseExistingReferencedSkill(
+ existingSkill,
+ candidate,
+ source,
+ toPosixPath(path.relative(packageDir, candidate.absolutePath)),
+ )
+ ? existingSkill
+ : null;
+ const errorStart = errors.length;
const files = await collectReferencedSkillFiles(source, descriptor.files ?? [SKILL_ENTRYPOINT], prefix, errors);
const skillMarkdown = await readReferencedFileText(source, SKILL_ENTRYPOINT, prefix, errors);
- if (!skillMarkdown) return null;
+ if (!skillMarkdown) {
+ const nextErrors = errors.slice(errorStart);
+ if (fallbackSkill && canFallbackToExistingReferencedSkill(nextErrors)) {
+ errors.splice(errorStart, nextErrors.length);
+ return fallbackSkill;
+ }
+ return null;
+ }
const parsed = parseFrontmatterMarkdown(skillMarkdown);
if (!parsed.hasFrontmatter) {
@@ -366,7 +395,14 @@ async function buildReferencedCatalogSkill(
if (!files.some((file) => file.path === SKILL_ENTRYPOINT && file.kind === "skill")) {
errors.push(`${prefix} referenced inventory does not contain SKILL.md.`);
}
- if (!name || !description) return null;
+ if (!name || !description) {
+ const nextErrors = errors.slice(errorStart);
+ if (fallbackSkill && canFallbackToExistingReferencedSkill(nextErrors)) {
+ errors.splice(errorStart, nextErrors.length);
+ return fallbackSkill;
+ }
+ return null;
+ }
return {
id,
@@ -390,6 +426,50 @@ async function buildReferencedCatalogSkill(
};
}
+function canReuseExistingReferencedSkill(
+ existingSkill: CatalogSkill | null,
+ candidate: Extract<SkillCandidate, { source: "reference" }>,
+ source: CatalogSkillSource,
+ expectedPath: string,
+) {
+ if (!existingSkill || existingSkill.source?.type !== "github") return false;
+ const existingSource = existingSkill.source;
+ return (
+ existingSkill.id === skillIdForCandidate(candidate) &&
+ existingSkill.path === expectedPath &&
+ existingSource.hostname === source.hostname &&
+ existingSource.owner === source.owner &&
+ existingSource.repo === source.repo &&
+ existingSource.ref === source.ref &&
+ existingSource.commit === source.commit &&
+ existingSource.path === source.path
+ );
+}
+
+function canFallbackToExistingReferencedSkill(errors: string[]) {
+ if (errors.length === 0) return false;
+ const hasRecoverableFetchError = errors.some((error) => isRecoverableReferencedFetchError(error));
+ return (
+ hasRecoverableFetchError &&
+ errors.every((error) =>
+ isReferencedFetchError(error) ||
+ error.includes("referenced inventory does not contain SKILL.md."),
+ )
+ );
+}
+
+function isReferencedFetchError(error: string) {
+ return error.includes("failed to fetch GitHub tree:") || error.includes("failed to fetch pinned GitHub file:");
+}
+
+function isRecoverableReferencedFetchError(error: string) {
+ if (!isReferencedFetchError(error)) return false;
+ const statusMatch = /HTTP (\d+)/.exec(error);
+ if (!statusMatch) return true;
+ const status = Number(statusMatch[1]);
+ return status === 403 || status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
+
async function readReferencedSkillDescriptor(
descriptorPath: string,
prefix: string,
diff --git a/server/src/__tests__/environment-routes.test.ts b/server/src/__tests__/environment-routes.test.ts
index 788726df24..733a44e83c 100644
--- a/server/src/__tests__/environment-routes.test.ts
+++ b/server/src/__tests__/environment-routes.test.ts
@@ -8,6 +8,7 @@ import { errorHandler } from "../middleware/index.js";
const mockAccessService = vi.hoisted(() => ({
canUser: vi.fn(),
hasPermission: vi.fn(),
+ decide: vi.fn(),
}));
const mockAgentService = vi.hoisted(() => ({
@@ -36,6 +37,7 @@ const mockProbeEnvironment = vi.hoisted(() => vi.fn());
const mockSecretService = vi.hoisted(() => ({
create: vi.fn(),
resolveSecretValue: vi.fn(),
+ resolveSecretValueForEphemeralAccess: vi.fn(),
syncSecretRefsForTarget: vi.fn(),
remove: vi.fn(),
}));
@@ -142,6 +144,7 @@ describe("environment routes", () => {
beforeEach(() => {
mockAccessService.canUser.mockReset();
mockAccessService.hasPermission.mockReset();
+ mockAccessService.decide.mockReset();
mockAgentService.getById.mockReset();
mockIssueService.getById.mockReset();
mockProjectService.getById.mockReset();
@@ -156,6 +159,7 @@ describe("environment routes", () => {
mockProbeEnvironment.mockReset();
mockSecretService.create.mockReset();
mockSecretService.resolveSecretValue.mockReset();
+ mockSecretService.resolveSecretValueForEphemeralAccess.mockReset();
mockSecretService.syncSecretRefsForTarget.mockReset();
mockSecretService.remove.mockReset();
mockSecretService.create.mockResolvedValue({
@@ -163,6 +167,7 @@ describe("environment routes", () => {
});
mockSecretService.syncSecretRefsForTarget.mockResolvedValue([]);
mockSecretService.remove.mockResolvedValue(null);
+ mockSecretService.resolveSecretValueForEphemeralAccess.mockResolvedValue("resolved-provider-key");
delete process.env.PAPERCLIP_SECRETS_PROVIDER;
mockValidatePluginEnvironmentDriverConfig.mockReset();
mockValidatePluginEnvironmentDriverConfig.mockImplementation(async ({ config }) => config);
@@ -203,6 +208,10 @@ describe("environment routes", () => {
));
mockListReadyPluginEnvironmentDrivers.mockReset();
mockListReadyPluginEnvironmentDrivers.mockResolvedValue([]);
+ mockAccessService.decide.mockResolvedValue({
+ allowed: true,
+ explanation: "Allowed by test harness",
+ });
});
it("lists company-scoped environments", async () => {
@@ -1392,4 +1401,149 @@ describe("environment routes", () => {
);
expect(JSON.stringify(mockLogActivity.mock.calls[0][1].details)).not.toContain("unsaved-test-key");
});
+
+ it("resolves selected secret refs before probing unsaved provider config", async () => {
+ mockValidatePluginSandboxProviderConfig.mockResolvedValue({
+ normalizedConfig: {
+ template: "base",
+ apiKey: "11111111-1111-1111-1111-111111111111",
+ timeoutMs: 300000,
+ reuseLease: true,
+ },
+ pluginId: "plugin-secure",
+ pluginKey: "acme.secure-sandbox-provider",
+ driver: {
+ driverKey: "secure-plugin",
+ kind: "sandbox_provider",
+ displayName: "Secure Sandbox",
+ configSchema: {
+ type: "object",
+ properties: {
+ template: { type: "string" },
+ apiKey: { type: "string", format: "secret-ref" },
+ timeoutMs: { type: "number" },
+ reuseLease: { type: "boolean" },
+ },
+ },
+ },
+ });
+ mockProbeEnvironment.mockResolvedValue({
+ ok: true,
+ driver: "sandbox",
+ summary: "Secure sandbox provider is ready.",
+ details: { provider: "secure-plugin" },
+ });
+ const pluginWorkerManager = {};
+ const app = createApp({
+ type: "board",
+ userId: "user-1",
+ source: "local_implicit",
+ runId: "run-1",
+ }, { pluginWorkerManager });
+
+ const res = await request(app)
+ .post("/api/companies/company-1/environments/probe-config")
+ .send({
+ name: "Draft Secure Sandbox",
+ driver: "sandbox",
+ config: {
+ provider: "secure-plugin",
+ template: "base",
+ apiKey: "11111111-1111-1111-1111-111111111111",
+ timeoutMs: 300000,
+ reuseLease: true,
+ },
+ });
+
+ expect(res.status).toBe(200);
+ expect(mockEnvironmentService.create).not.toHaveBeenCalled();
+ expect(mockSecretService.create).not.toHaveBeenCalled();
+ expect(mockSecretService.resolveSecretValueForEphemeralAccess).toHaveBeenCalledWith(
+ "company-1",
+ "11111111-1111-1111-1111-111111111111",
+ "latest",
+ {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "user",
+ actorId: "user-1",
+ actorSource: "local_implicit",
+ heartbeatRunId: "run-1",
+ },
+ );
+ expect(mockProbeEnvironment).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({
+ id: "unsaved",
+ driver: "sandbox",
+ config: expect.objectContaining({
+ apiKey: "resolved-provider-key",
+ }),
+ }),
+ expect.objectContaining({
+ pluginWorkerManager,
+ resolvedConfig: expect.objectContaining({
+ driver: "sandbox",
+ config: expect.objectContaining({
+ apiKey: "resolved-provider-key",
+ }),
+ }),
+ }),
+ );
+ expect(JSON.stringify(mockLogActivity.mock.calls[0][1].details)).not.toContain("resolved-provider-key");
+ });
+
+ it("rejects sandbox draft probes when the actor cannot read company secrets", async () => {
+ mockValidatePluginSandboxProviderConfig.mockResolvedValue({
+ normalizedConfig: {
+ template: "base",
+ apiKey: "11111111-1111-1111-1111-111111111111",
+ },
+ pluginId: "plugin-secure",
+ pluginKey: "acme.secure-sandbox-provider",
+ driver: {
+ driverKey: "secure-plugin",
+ kind: "sandbox_provider",
+ displayName: "Secure Sandbox",
+ configSchema: {
+ type: "object",
+ properties: {
+ template: { type: "string" },
+ apiKey: { type: "string", format: "secret-ref" },
+ },
+ },
+ },
+ });
+ mockAccessService.canUser.mockResolvedValue(true);
+ mockAccessService.decide.mockResolvedValue({
+ allowed: false,
+ explanation: "Missing permission: secrets:read",
+ });
+ const pluginWorkerManager = {};
+ const app = createApp({
+ type: "board",
+ userId: "user-2",
+ source: "session",
+ companyIds: ["company-1"],
+ memberships: [{ companyId: "company-1", status: "active", membershipRole: "member" }],
+ }, { pluginWorkerManager });
+
+ const res = await request(app)
+ .post("/api/companies/company-1/environments/probe-config")
+ .send({
+ name: "Draft Secure Sandbox",
+ driver: "sandbox",
+ config: {
+ provider: "secure-plugin",
+ template: "base",
+ apiKey: "11111111-1111-1111-1111-111111111111",
+ },
+ });
+
+ expect(res.status).toBe(403);
+ expect(res.body.error).toContain("secrets:read");
+ expect(mockSecretService.resolveSecretValueForEphemeralAccess).not.toHaveBeenCalled();
+ expect(mockProbeEnvironment).not.toHaveBeenCalled();
+ });
});
diff --git a/server/src/__tests__/secrets-service.test.ts b/server/src/__tests__/secrets-service.test.ts
index ee7b7d95b1..0560765927 100644
--- a/server/src/__tests__/secrets-service.test.ts
+++ b/server/src/__tests__/secrets-service.test.ts
@@ -7,6 +7,7 @@ import { eq } from "drizzle-orm";
import {
agents,
companies,
+ companyMemberships,
companySecretBindings,
companySecretProviderConfigs,
companySecretVersions,
@@ -50,6 +51,7 @@ describeEmbeddedPostgres("secretService", () => {
await db.delete(companySecretVersions);
await db.delete(companySecrets);
await db.delete(companySecretProviderConfigs);
+ await db.delete(companyMemberships);
await db.delete(agents);
await db.delete(companies);
});
@@ -77,6 +79,22 @@ describeEmbeddedPostgres("secretService", () => {
return companyId;
}
+ async function seedCompanyMember(
+ companyId: string,
+ userId: string,
+ membershipRole: "owner" | "member" | "viewer" = "member",
+ ) {
+ await db.insert(companyMemberships).values({
+ companyId,
+ principalType: "user",
+ principalId: userId,
+ status: "active",
+ membershipRole,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ });
+ }
+
it("rejects cross-company secret references during env normalization", async () => {
const companyA = await seedCompany("A");
const companyB = await seedCompany("B");
@@ -1953,4 +1971,112 @@ describeEmbeddedPostgres("secretService", () => {
/not active/i,
);
});
+
+ it("records audited ephemeral secret access without requiring a persisted binding", async () => {
+ const companyId = await seedCompany();
+ const svc = secretService(db);
+ const secret = await svc.create(companyId, {
+ name: `ephemeral-${randomUUID()}`,
+ provider: "local_encrypted",
+ value: "runtime-secret",
+ });
+ await seedCompanyMember(companyId, "user-1");
+
+ const resolved = await svc.resolveSecretValueForEphemeralAccess(companyId, secret.id, "latest", {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "user",
+ actorId: "user-1",
+ });
+
+ expect(resolved).toBe("runtime-secret");
+ const events = await svc.listAccessEvents(companyId, secret.id);
+ expect(events).toHaveLength(1);
+ expect(events[0]).toMatchObject({
+ companyId,
+ secretId: secret.id,
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "user",
+ actorId: "user-1",
+ outcome: "success",
+ });
+ expect(JSON.stringify(events)).not.toContain("runtime-secret");
+ });
+
+ it("preserves local implicit board authorization for ephemeral secret access", async () => {
+ const companyId = await seedCompany();
+ const svc = secretService(db);
+ const secret = await svc.create(companyId, {
+ name: `ephemeral-local-board-${randomUUID()}`,
+ provider: "local_encrypted",
+ value: "runtime-secret",
+ });
+
+ const resolved = await svc.resolveSecretValueForEphemeralAccess(companyId, secret.id, "latest", {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "user",
+ actorId: "local-board",
+ actorSource: "local_implicit",
+ });
+
+ expect(resolved).toBe("runtime-secret");
+ });
+
+ it("preserves agent jwt source for ephemeral secret authorization", async () => {
+ const companyId = await seedCompany();
+ const svc = secretService(db);
+ const secret = await svc.create(companyId, {
+ name: `ephemeral-agent-jwt-${randomUUID()}`,
+ provider: "local_encrypted",
+ value: "runtime-secret",
+ });
+ const agentId = randomUUID();
+ await db.insert(agents).values({
+ id: agentId,
+ companyId,
+ name: "JWT Agent",
+ role: "engineer",
+ adapterType: "codex_local",
+ adapterConfig: {},
+ status: "idle",
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ });
+
+ const resolved = await svc.resolveSecretValueForEphemeralAccess(companyId, secret.id, "latest", {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "agent",
+ actorId: agentId,
+ actorSource: "agent_jwt",
+ });
+
+ expect(resolved).toBe("runtime-secret");
+ });
+
+ it("rejects ephemeral secret access for actors without secret-read authorization", async () => {
+ const companyId = await seedCompany();
+ const svc = secretService(db);
+ const secret = await svc.create(companyId, {
+ name: `ephemeral-denied-${randomUUID()}`,
+ provider: "local_encrypted",
+ value: "runtime-secret",
+ });
+
+ await expect(
+ svc.resolveSecretValueForEphemeralAccess(companyId, secret.id, "latest", {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: "apiKey",
+ actorType: "user",
+ actorId: "user-without-membership",
+ }),
+ ).rejects.toThrow(/active member|secrets:read|forbidden/i);
+ });
});
diff --git a/server/src/routes/authz.ts b/server/src/routes/authz.ts
index d51a09934d..0234a9f53f 100644
--- a/server/src/routes/authz.ts
+++ b/server/src/routes/authz.ts
@@ -74,21 +74,46 @@ export function assertCompanyAccess(req: Request, companyId: string) {
}
}
-export function getActorInfo(req: Request) {
+export function getActorInfo(req: Request): (
+ {
+ actorType: "agent";
+ actorId: string;
+ agentId: string | null;
+ runId: string | null;
+ actorSource: "agent_key" | "agent_jwt";
+ }
+ | {
+ actorType: "user";
+ actorId: string;
+ agentId: null;
+ runId: string | null;
+ actorSource: "local_implicit" | "session" | "board_key" | "cloud_tenant";
+ }
+) {
assertAuthenticated(req);
if (req.actor.type === "agent") {
+ const actorSource = req.actor.source === "agent_jwt" ? "agent_jwt" : "agent_key";
return {
actorType: "agent" as const,
actorId: req.actor.agentId ?? "unknown-agent",
agentId: req.actor.agentId ?? null,
runId: req.actor.runId ?? null,
+ actorSource,
};
}
+ const actorSource =
+ req.actor.source === "local_implicit" ||
+ req.actor.source === "board_key" ||
+ req.actor.source === "cloud_tenant"
+ ? req.actor.source
+ : "session";
+
return {
actorType: "user" as const,
actorId: req.actor.userId ?? "board",
agentId: null,
runId: req.actor.runId ?? null,
+ actorSource,
};
}
diff --git a/server/src/routes/environments.ts b/server/src/routes/environments.ts
index d6b09385e2..8899988feb 100644
--- a/server/src/routes/environments.ts
+++ b/server/src/routes/environments.ts
@@ -86,6 +86,17 @@ export function environmentRoutes(
throw forbidden("Missing permission: environments:manage");
}
+ async function assertCanReadSecretsForDraftProbe(req: Request, companyId: string) {
+ const decision = await access.decide({
+ actor: req.actor,
+ action: "secrets:read",
+ resource: { type: "company", companyId },
+ });
+ if (!decision.allowed) {
+ throw forbidden(decision.explanation);
+ }
+ }
+
async function actorCanReadEnvironmentConfigurations(req: Request, companyId: string) {
assertCompanyAccess(req, companyId);
@@ -431,11 +442,23 @@ export function environmentRoutes(
async (req, res) => {
const companyId = req.params.companyId as string;
await assertCanMutateEnvironments(req, companyId);
+ if (req.body.driver === "sandbox") {
+ // Draft sandbox probes can resolve unbound secret refs, so require
+ // the same company-scoped secret-read capability before normalization.
+ await assertCanReadSecretsForDraftProbe(req, companyId);
+ }
const actor = getActorInfo(req);
const normalizedConfig = await normalizeEnvironmentConfigForProbe({
db,
+ companyId,
driver: req.body.driver,
config: req.body.config,
+ accessContext: {
+ actorType: actor.actorType,
+ actorId: actor.actorId,
+ actorSource: actor.actorSource,
+ heartbeatRunId: actor.runId,
+ },
pluginWorkerManager: options.pluginWorkerManager,
});
const environment = {
diff --git a/server/src/services/environment-config.ts b/server/src/services/environment-config.ts
index e95fe37f7f..3d1286d03e 100644
--- a/server/src/services/environment-config.ts
+++ b/server/src/services/environment-config.ts
@@ -264,6 +264,45 @@ async function resolveConfigSecretRefsForRuntime(input: {
return nextConfig;
}
+async function resolveConfigSecretRefsForProbe(input: {
+ db: Db;
+ companyId: string;
+ config: Record<string, unknown>;
+ schema: Record<string, unknown> | null;
+ accessContext?: {
+ actorType: "agent" | "user";
+ actorId: string;
+ actorSource?: "local_implicit" | "session" | "board_key" | "agent_key" | "agent_jwt" | "cloud_tenant";
+ heartbeatRunId?: string | null;
+ };
+}): Promise<Record<string, unknown>> {
+ const secrets = secretService(input.db);
+ let nextConfig = { ...input.config };
+ for (const path of collectSecretRefPaths(input.schema)) {
+ const current = readConfigValueAtPath(nextConfig, path);
+ if (typeof current !== "string") continue;
+ const trimmed = current.trim();
+ if (!isUuidSecretRef(trimmed)) continue;
+ // Unsaved draft probes do not have an environment record yet, so they
+ // cannot rely on environment-bound secret resolution. Resolve directly for
+ // this ephemeral board-only probe and never persist the plaintext value.
+ nextConfig = writeConfigValueAtPath(
+ nextConfig,
+ path,
+ await secrets.resolveSecretValueForEphemeralAccess(input.companyId, trimmed, "latest", {
+ consumerType: "system",
+ consumerId: "environment-probe-config",
+ configPath: path,
+ actorType: input.accessContext?.actorType ?? "system",
+ actorId: input.accessContext?.actorId ?? null,
+ actorSource: input.accessContext?.actorSource,
+ heartbeatRunId: input.accessContext?.heartbeatRunId ?? null,
+ }),
+ );
+ }
+ return nextConfig;
+}
+
export async function collectEnvironmentSecretRefs(input: {
db: Db;
environment: Pick<Environment, "id" | "driver" | "config">;
@@ -338,8 +377,15 @@ export function normalizeEnvironmentConfig(input: {
export function normalizeEnvironmentConfigForProbe(input: {
db: Db;
+ companyId: string;
driver: EnvironmentDriver;
config: Record<string, unknown> | null | undefined;
+ accessContext?: {
+ actorType: "agent" | "user";
+ actorId: string;
+ actorSource?: "local_implicit" | "session" | "board_key" | "agent_key" | "agent_jwt" | "cloud_tenant";
+ heartbeatRunId?: string | null;
+ };
pluginWorkerManager?: PluginWorkerManager;
}): Promise<Record<string, unknown>> | Record<string, unknown> {
if (input.driver === "ssh") {
@@ -370,9 +416,20 @@ export function normalizeEnvironmentConfigForProbe(input: {
workerManager: input.pluginWorkerManager,
provider: parsed.data.provider,
config: stripSandboxProviderEnvelope(parsed.data),
- }).then((validated) => ({
+ }).then(async (validated) => ({
provider: parsed.data.provider,
- ...validated.normalizedConfig,
+ ...(await resolveConfigSecretRefsForProbe({
+ db: input.db,
+ companyId: input.companyId,
+ config: validated.normalizedConfig,
+ accessContext: input.accessContext,
+ schema:
+ validated.driver.configSchema &&
+ typeof validated.driver.configSchema === "object" &&
+ !Array.isArray(validated.driver.configSchema)
+ ? validated.driver.configSchema as Record<string, unknown>
+ : null,
+ })),
}));
}
diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.ts
index 0f9f7b182d..01f0fa94aa 100644
--- a/server/src/services/heartbeat.ts
+++ b/server/src/services/heartbeat.ts
@@ -4647,6 +4647,47 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
return updated;
}
+ async function setRunStatusIfRunning(
+ runId: string,
+ status: string,
+ patch?: Partial<typeof heartbeatRuns.$inferInsert>,
+ ) {
+ const updated = await db
+ .update(heartbeatRuns)
+ .set({ status, ...patch, updatedAt: new Date() })
+ .where(and(eq(heartbeatRuns.id, runId), eq(heartbeatRuns.status, "running")))
+ .returning()
+ .then((rows) => rows[0] ?? null);
+
+ if (updated) {
+ publishLiveEvent({
+ companyId: updated.companyId,
+ type: "heartbeat.run.status",
+ payload: {
+ runId: updated.id,
+ agentId: updated.agentId,
+ status: updated.status,
+ invocationSource: updated.invocationSource,
+ triggerDetail: updated.triggerDetail,
+ error: updated.error ?? null,
+ errorCode: updated.errorCode ?? null,
+ startedAt: updated.startedAt ? new Date(updated.startedAt).toISOString() : null,
+ finishedAt: updated.finishedAt ? new Date(updated.finishedAt).toISOString() : null,
+ },
+ });
+ publishRunLifecyclePluginEvent(updated);
+ return { run: updated, updated: true as const };
+ }
+
+ const current = await db
+ .select()
+ .from(heartbeatRuns)
+ .where(eq(heartbeatRuns.id, runId))
+ .then((rows) => rows[0] ?? null);
+
+ return { run: current, updated: false as const };
+ }
+
function publishRunLifecyclePluginEvent(run: typeof heartbeatRuns.$inferSelect) {
const eventType =
run.status === "running"
@@ -9204,7 +9245,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
adapterResult.summary ?? null,
);
- let persistedRun = await setRunStatus(run.id, status, {
+ const persistedRunWrite = await setRunStatusIfRunning(run.id, status, {
finishedAt: new Date(),
error: runErrorMessage,
errorCode: runErrorCode,
@@ -9219,6 +9260,19 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
logSha256: logSummary?.sha256,
logCompressed: logSummary?.compressed ?? false,
});
+ if (!persistedRunWrite.updated) {
+ logger.info(
+ {
+ runId: run.id,
+ attemptedStatus: status,
+ currentStatus: persistedRunWrite.run?.status ?? null,
+ },
+ "skipping late run finalization because the run already left running state",
+ );
+ return;
+ }
+
+ let persistedRun = persistedRunWrite.run;
if (persistedRun) {
persistedRun = await classifyAndPersistRunLiveness(persistedRun, persistedResultJson) ?? persistedRun;
}
@@ -9395,7 +9449,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
logger.warn({ err: flushErr, runId }, "failed to flush run output progress after error");
});
- const failedRun = await setRunStatus(run.id, "failed", {
+ const failedRunWrite = await setRunStatusIfRunning(run.id, "failed", {
error: message,
errorCode: failureErrorCode,
finishedAt: new Date(),
@@ -9410,6 +9464,19 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
logSha256: logSummary?.sha256,
logCompressed: logSummary?.compressed ?? false,
});
+ if (!failedRunWrite.updated) {
+ logger.info(
+ {
+ runId: run.id,
+ attemptedStatus: "failed",
+ currentStatus: failedRunWrite.run?.status ?? null,
+ },
+ "skipping late adapter failure finalization because the run already left running state",
+ );
+ return;
+ }
+
+ const failedRun = failedRunWrite.run;
await setWakeupStatus(run.wakeupRequestId, "failed", {
finishedAt: new Date(),
error: message,
@@ -9460,7 +9527,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
const message = outerErr instanceof Error ? outerErr.message : "Unknown setup failure";
logger.error({ err: outerErr, runId }, "heartbeat execution setup failed");
const setupFailureAgent = await getAgent(run.agentId).catch(() => null);
- await setRunStatus(runId, "failed", {
+ const setupFailureWrite = await setRunStatusIfRunning(runId, "failed", {
error: message,
errorCode: "setup_failed",
finishedAt: new Date(),
@@ -9470,13 +9537,24 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
errorMessage: message,
}),
} : {}),
- }).catch(() => undefined);
- await setWakeupStatus(run.wakeupRequestId, "failed", {
- finishedAt: new Date(),
- error: message,
- }).catch(() => undefined);
+ }).catch(() => ({ run: null, updated: false as const }));
+ if (!setupFailureWrite.updated) {
+ logger.info(
+ {
+ runId,
+ attemptedStatus: "failed",
+ currentStatus: setupFailureWrite.run?.status ?? null,
+ },
+ "skipping late setup failure finalization because the run already left running state",
+ );
+ } else {
+ await setWakeupStatus(run.wakeupRequestId, "failed", {
+ finishedAt: new Date(),
+ error: message,
+ }).catch(() => undefined);
+ }
const failedRun = await getRun(runId).catch(() => null);
- if (failedRun) {
+ if (setupFailureWrite.updated && failedRun) {
// Emit a run-log event so the failure is visible in the run timeline,
// consistent with what the inner catch block does for adapter failures.
await appendRunEvent(failedRun, 1, {
@@ -9495,9 +9573,12 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
}
await releaseIssueExecutionAndPromote(livenessRun).catch(() => undefined);
}
- // Ensure the agent is not left stuck in "running" if the inner catch handler's
- // DB calls threw (e.g. a transient DB error in finalizeAgentStatus).
- await finalizeAgentStatus(run.agentId, "failed").catch(() => undefined);
+ // Ensure the agent is not left stuck in "running" if the setup-failure
+ // path owned the terminal transition. If another path already finalized
+ // the run, keep that terminal outcome authoritative.
+ if (setupFailureWrite.updated) {
+ await finalizeAgentStatus(run.agentId, "failed").catch(() => undefined);
+ }
} finally {
const latestRun = await getRun(run.id).catch(() => null);
await releaseEnvironmentLeasesForRun({
diff --git a/server/src/services/recovery/successful-run-handoff.test.ts b/server/src/services/recovery/successful-run-handoff.test.ts
index 77e950f7fb..e632d97411 100644
--- a/server/src/services/recovery/successful-run-handoff.test.ts
+++ b/server/src/services/recovery/successful-run-handoff.test.ts
@@ -184,6 +184,23 @@ describe("successful run handoff decision", () => {
});
});
+ it("does not queue for successful comment-driven wakes", () => {
+ expect(decide({
+ run: {
+ ...run,
+ contextSnapshot: {
+ issueId: "issue-1",
+ wakeReason: "issue_commented",
+ commentId: "comment-1",
+ wakeCommentIds: ["comment-1"],
+ },
+ } as any,
+ })).toEqual({
+ kind: "skip",
+ reason: "comment-driven wake already owns the next action",
+ });
+ });
+
it("uses a stable one-attempt idempotency key", () => {
expect(buildFinishSuccessfulRunHandoffIdempotencyKey({
issueId: "issue-1",
diff --git a/server/src/services/recovery/successful-run-handoff.ts b/server/src/services/recovery/successful-run-handoff.ts
index 3332501876..4e322c5676 100644
--- a/server/src/services/recovery/successful-run-handoff.ts
+++ b/server/src/services/recovery/successful-run-handoff.ts
@@ -295,6 +295,14 @@ function isIssueMonitorMaintenanceRun(run: HeartbeatRunRow) {
return Boolean(wakeReason?.startsWith("issue_monitor") || source?.startsWith("issue.monitor"));
}
+function isCommentDrivenWake(run: HeartbeatRunRow) {
+ const context = readRecord(run.contextSnapshot);
+ const wakeReason = readString(context.wakeReason);
+ return wakeReason === "issue_commented" ||
+ wakeReason === "issue_comment_mentioned" ||
+ wakeReason === "issue_reopened_via_comment";
+}
+
function isProductiveSuccessfulRun(input: {
livenessState: RunLivenessState | null;
detectedProgressSummary: string | null;
@@ -350,6 +358,7 @@ export function decideSuccessfulRunHandoff(input: {
if (run.status !== "succeeded") return { kind: "skip", reason: "source run did not succeed" };
if (isCorrectiveHandoffRun(run)) return { kind: "skip", reason: "source run is already a corrective handoff run" };
if (isIssueMonitorMaintenanceRun(run)) return { kind: "skip", reason: "issue monitor run owns its own recovery path" };
+ if (isCommentDrivenWake(run)) return { kind: "skip", reason: "comment-driven wake already owns the next action" };
if (run.issueCommentStatus === "retry_queued" || run.issueCommentStatus === "retry_exhausted") {
return { kind: "skip", reason: "missing issue comment retry owns the next action" };
}
diff --git a/server/src/services/secrets.ts b/server/src/services/secrets.ts
index 77eafd0839..a7f7292856 100644
--- a/server/src/services/secrets.ts
+++ b/server/src/services/secrets.ts
@@ -38,7 +38,7 @@ import {
secretProviderConfigDiscoveryPreviewSchema,
updateSecretProviderConfigSchema,
} from "@paperclipai/shared";
-import { conflict, HttpError, notFound, unprocessable } from "../errors.js";
+import { conflict, forbidden, HttpError, notFound, unprocessable } from "../errors.js";
import { logger } from "../middleware/logger.js";
import {
checkSecretProviders,
@@ -54,6 +54,7 @@ import type {
SecretProviderWriteContext,
} from "../secrets/types.js";
import { isSecretProviderClientError } from "../secrets/types.js";
+import { authorizationService } from "./authorization.js";
const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
const SENSITIVE_ENV_KEY_RE =
@@ -178,12 +179,18 @@ type SecretConsumerContext = {
configPath?: string | null;
actorType?: "agent" | "user" | "system" | "plugin";
actorId?: string | null;
+ actorSource?: "local_implicit" | "session" | "board_key" | "agent_key" | "agent_jwt" | "cloud_tenant";
issueId?: string | null;
heartbeatRunId?: string | null;
pluginId?: string | null;
allowedBindingIds?: string[] | null;
};
+type SecretResolutionOptions = {
+ bindingContext?: SecretConsumerContext;
+ accessContext?: SecretConsumerContext;
+};
+
export type RuntimeSecretManifestEntry = {
configPath: string;
envKey: string | null;
@@ -295,6 +302,8 @@ function assertSelectableProviderConfig(config: {
}
export function secretService(db: Db) {
+ const authorization = authorizationService(db);
+
type NormalizeEnvOptions = {
strictMode?: boolean;
fieldPath?: string;
@@ -562,14 +571,16 @@ export function secretService(db: Db) {
companyId: string,
secretId: string,
version: number | "latest",
- context?: SecretConsumerContext,
+ options?: SecretResolutionOptions,
): Promise<RuntimeSecretResolution> {
+ const bindingContext = options?.bindingContext;
+ const accessContext = options?.accessContext ?? bindingContext;
const secret = await getById(secretId);
if (!secret) throw notFound("Secret not found");
if (secret.companyId !== companyId) throw unprocessable("Secret must belong to same company");
const resolvedVersion = version === "latest" ? secret.latestVersion : version;
const providerId = secret.provider as SecretProvider;
- const configPath = context?.configPath ?? null;
+ const configPath = accessContext?.configPath ?? null;
try {
if (secret.status === "deleted") {
throw new HttpError(404, "Secret not found", { code: "secret_deleted" });
@@ -577,7 +588,7 @@ export function secretService(db: Db) {
if (secret.status !== "active") {
throw unprocessable("Secret is not active", { code: "secret_inactive" });
}
- const binding = await assertBindingContext(companyId, secret.id, context);
+ const binding = await assertBindingContext(companyId, secret.id, bindingContext);
const versionRow = await getSecretVersion(secret.id, resolvedVersion);
if (!versionRow) throw new HttpError(404, "Secret version not found", { code: "version_missing" });
if (versionRow.status === "disabled" || versionRow.status === "destroyed" || versionRow.revokedAt) {
@@ -612,7 +623,7 @@ export function secretService(db: Db) {
secretId: secret.id,
version: resolvedVersion,
provider: providerId,
- context,
+ context: accessContext,
outcome: "success",
}).catch(() => undefined),
]);
@@ -636,7 +647,7 @@ export function secretService(db: Db) {
secretId: secret.id,
version: resolvedVersion,
provider: providerId,
- context,
+ context: accessContext,
outcome: "failure",
errorCode,
}).catch(() => undefined);
@@ -650,7 +661,57 @@ export function secretService(db: Db) {
version: number | "latest",
context?: SecretConsumerContext,
): Promise<string> {
- return (await resolveSecretValueInternal(companyId, secretId, version, context)).value;
+ return (await resolveSecretValueInternal(companyId, secretId, version, {
+ bindingContext: context,
+ accessContext: context,
+ })).value;
+ }
+
+ async function resolveSecretValueForEphemeralAccess(
+ companyId: string,
+ secretId: string,
+ version: number | "latest",
+ context: SecretConsumerContext,
+ ): Promise<string> {
+ if (context.consumerType !== "system" || context.consumerId !== "environment-probe-config") {
+ throw forbidden("Ephemeral secret resolution is limited to draft environment probes");
+ }
+ if (
+ (context.actorType !== "agent" && context.actorType !== "user") ||
+ !context.actorId?.trim()
+ ) {
+ throw forbidden("Ephemeral secret resolution requires an authenticated actor");
+ }
+ const actor =
+ context.actorType === "agent"
+ ? {
+ type: "agent" as const,
+ agentId: context.actorId,
+ companyId,
+ source: context.actorSource === "agent_jwt" ? "agent_jwt" as const : "agent_key" as const,
+ }
+ : {
+ type: "board" as const,
+ userId: context.actorId,
+ source: context.actorSource === "local_implicit"
+ ? "local_implicit" as const
+ : context.actorSource === "board_key"
+ ? "board_key" as const
+ : context.actorSource === "cloud_tenant"
+ ? "cloud_tenant" as const
+ : "session" as const,
+ };
+ const decision = await authorization.decide({
+ actor,
+ action: "secrets:read",
+ resource: { type: "company", companyId },
+ });
+ if (!decision.allowed) {
+ throw forbidden(decision.explanation);
+ }
+ return (await resolveSecretValueInternal(companyId, secretId, version, {
+ accessContext: context,
+ })).value;
}
async function normalizeEnvConfig(
@@ -1579,6 +1640,7 @@ export function secretService(db: Db) {
getById,
getByName,
resolveSecretValue,
+ resolveSecretValueForEphemeralAccess,
create: async (
companyId: string,
@@ -2275,7 +2337,12 @@ export function secretService(db: Db) {
companyId,
binding.secretId,
binding.version,
- context ? { ...context, configPath: `env.${key}` } : undefined,
+ context
+ ? {
+ bindingContext: { ...context, configPath: `env.${key}` },
+ accessContext: { ...context, configPath: `env.${key}` },
+ }
+ : undefined,
);
resolved[key] = secretResolution.value;
manifest.push(secretResolution.manifestEntry);
@@ -2318,7 +2385,12 @@ export function secretService(db: Db) {
companyId,
binding.secretId,
binding.version,
- context ? { ...context, configPath: `env.${key}` } : undefined,
+ context
+ ? {
+ bindingContext: { ...context, configPath: `env.${key}` },
+ accessContext: { ...context, configPath: `env.${key}` },
+ }
+ : undefined,
);
env[key] = secretResolution.value;
manifest.push(secretResolution.manifestEntry);