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
Add secrets provider vaults and remote import (#5429)
Dotta778e775c3583
diff --git a/cli/src/__tests__/secrets.test.ts b/cli/src/__tests__/secrets.test.tsnew file mode 100644index 0000000000..a1089ae0a0--- /dev/null+++ b/cli/src/__tests__/secrets.test.ts@@ -0,0 +1,257 @@+import { afterEach, beforeEach, describe, expect, it } from "vitest";+import type { Agent, CompanySecret } from "@paperclipai/shared";+import type { PaperclipConfig } from "../config/schema.js";+import { secretsCheck } from "../checks/secrets-check.js";+import {+ buildInlineMigrationSecretName,+ buildMigratedAgentEnv,+ collectInlineSecretMigrationCandidates,+ parseSecretsInclude,+ toPlainEnvValue,+} from "../commands/client/secrets.js";++function agent(partial: Partial<Agent>): Agent {+ return {+ id: "agent-12345678",+ companyId: "company-1",+ name: "Coder",+ urlKey: "coder",+ role: "engineer",+ title: null,+ icon: null,+ status: "idle",+ reportsTo: null,+ capabilities: null,+ adapterType: "codex_local",+ adapterConfig: {},+ runtimeConfig: {},+ budgetMonthlyCents: 0,+ spentMonthlyCents: 0,+ pauseReason: null,+ pausedAt: null,+ permissions: {+ canCreateAgents: false,+ },+ lastHeartbeatAt: null,+ metadata: null,+ createdAt: new Date("2026-04-26T00:00:00.000Z"),+ updatedAt: new Date("2026-04-26T00:00:00.000Z"),+ ...partial,+ };+}++function secret(partial: Partial<CompanySecret>): CompanySecret {+ return {+ id: "secret-1",+ companyId: "company-1",+ key: "agent_agent-12_anthropic_api_key",+ name: "agent_agent-12_anthropic_api_key",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 1,+ description: null,+ lastResolvedAt: null,+ lastRotatedAt: null,+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: null,+ createdAt: new Date("2026-04-26T00:00:00.000Z"),+ updatedAt: new Date("2026-04-26T00:00:00.000Z"),+ ...partial,+ };+}++function configWithSecretsProvider(provider: PaperclipConfig["secrets"]["provider"]): PaperclipConfig {+ return {+ $meta: {+ version: 1,+ updatedAt: "2026-05-02T00:00:00.000Z",+ source: "configure",+ },+ database: {+ mode: "embedded-postgres",+ embeddedPostgresDataDir: "/tmp/paperclip/db",+ embeddedPostgresPort: 55432,+ backup: {+ enabled: true,+ intervalMinutes: 60,+ retentionDays: 30,+ dir: "/tmp/paperclip/backups",+ },+ },+ logging: {+ mode: "file",+ logDir: "/tmp/paperclip/logs",+ },+ server: {+ deploymentMode: "local_trusted",+ exposure: "private",+ host: "127.0.0.1",+ port: 3100,+ allowedHostnames: [],+ serveUi: true,+ },+ auth: {+ baseUrlMode: "auto",+ disableSignUp: false,+ },+ telemetry: {+ enabled: true,+ },+ storage: {+ provider: "local_disk",+ localDisk: {+ baseDir: "/tmp/paperclip/storage",+ },+ s3: {+ bucket: "paperclip",+ region: "us-east-1",+ prefix: "",+ forcePathStyle: false,+ },+ },+ secrets: {+ provider,+ strictMode: true,+ localEncrypted: {+ keyFilePath: "/tmp/paperclip/secrets/master.key",+ },+ },+ };+}++describe("secrets CLI helpers", () => {+ const originalEnv = { ...process.env };++ beforeEach(() => {+ process.env = { ...originalEnv };+ delete process.env.PAPERCLIP_SECRETS_AWS_REGION;+ delete process.env.AWS_REGION;+ delete process.env.AWS_DEFAULT_REGION;+ delete process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID;+ delete process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID;+ });++ afterEach(() => {+ process.env = { ...originalEnv };+ });++ it("parses declaration include filters", () => {+ expect(parseSecretsInclude("agents,projects,tasks")).toEqual({+ company: false,+ agents: true,+ projects: true,+ issues: true,+ skills: false,+ });+ });++ it("detects inline sensitive env values that need migration", () => {+ const rows = collectInlineSecretMigrationCandidates(+ [+ agent({+ id: "agent-12345678",+ adapterConfig: {+ env: {+ ANTHROPIC_API_KEY: "sk-ant-test",+ GH_TOKEN: {+ type: "plain",+ value: "ghp-test",+ },+ PATH: {+ type: "plain",+ value: "/usr/bin",+ },+ OPENAI_API_KEY: {+ type: "secret_ref",+ secretId: "secret-existing",+ },+ },+ },+ }),+ ],+ [+ secret({+ id: "secret-gh-token",+ name: buildInlineMigrationSecretName("agent-12345678", "GH_TOKEN"),+ }),+ ],+ );++ expect(rows).toEqual([+ {+ agentId: "agent-12345678",+ agentName: "Coder",+ envKey: "ANTHROPIC_API_KEY",+ secretName: "agent_agent-12_anthropic_api_key",+ existingSecretId: null,+ },+ {+ agentId: "agent-12345678",+ agentName: "Coder",+ envKey: "GH_TOKEN",+ secretName: "agent_agent-12_gh_token",+ existingSecretId: "secret-gh-token",+ },+ ]);+ });++ it("builds migrated env bindings without preserving secret values", () => {+ const next = buildMigratedAgentEnv(+ {+ ANTHROPIC_API_KEY: "sk-ant-test",+ NODE_ENV: {+ type: "plain",+ value: "development",+ },+ },+ new Map([["ANTHROPIC_API_KEY", "secret-1"]]),+ );++ expect(next).toEqual({+ ANTHROPIC_API_KEY: {+ type: "secret_ref",+ secretId: "secret-1",+ version: "latest",+ },+ NODE_ENV: {+ type: "plain",+ value: "development",+ },+ });+ expect(JSON.stringify(next)).not.toContain("sk-ant-test");+ });++ it("reads only explicit plain env values", () => {+ expect(toPlainEnvValue("plain-value")).toBe("plain-value");+ expect(toPlainEnvValue({ type: "plain", value: "wrapped" })).toBe("wrapped");+ expect(toPlainEnvValue({ type: "secret_ref", secretId: "secret-1" })).toBeNull();+ });++ it("reports the AWS bootstrap config required by doctor", () => {+ const result = secretsCheck(configWithSecretsProvider("aws_secrets_manager"));++ expect(result.status).toBe("fail");+ expect(result.message).toContain("PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID");+ expect(result.repairHint).toContain("AWS SDK default credential chain");+ expect(result.repairHint).toContain("Do not store AWS root credentials");+ });++ it("passes AWS doctor checks when non-secret provider config is present", () => {+ process.env.PAPERCLIP_SECRETS_AWS_REGION = "us-east-1";+ process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID = "prod-us-1";+ process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID =+ "arn:aws:kms:us-east-1:123456789012:key/test";+ process.env.AWS_PROFILE = "paperclip-prod";++ const result = secretsCheck(configWithSecretsProvider("aws_secrets_manager"));++ expect(result.status).toBe("pass");+ expect(result.message).toContain("prod-us-1");+ expect(result.message).toContain("AWS_PROFILE/shared config");+ });+});diff --git a/cli/src/checks/secrets-check.ts b/cli/src/checks/secrets-check.tsindex 49c6a90b28..73f9c0402c 100644--- a/cli/src/checks/secrets-check.ts+++ b/cli/src/checks/secrets-check.ts@@ -5,6 +5,9 @@ import type { PaperclipConfig } from "../config/schema.js";import type { CheckResult } from "./index.js";import { resolveRuntimeLikePath } from "./path-resolver.js";+const AWS_CREDENTIAL_SOURCE_HINT =+ "Provide AWS runtime credentials through the AWS SDK default credential chain: IAM role/workload identity, AWS_PROFILE/SSO/shared credentials, web identity, container/instance metadata, or short-lived shell credentials";+function decodeMasterKey(raw: string): Buffer | null {const trimmed = raw.trim();if (!trimmed) return null;@@ -47,13 +50,16 @@ function withStrictModeNote(export function secretsCheck(config: PaperclipConfig, configPath?: string): CheckResult {const provider = config.secrets.provider;+ if (provider === "aws_secrets_manager") {+ return withStrictModeNote(awsSecretsManagerCheck(), config);+ }if (provider !== "local_encrypted") {return {name: "Secrets adapter",status: "fail",- message: `${provider} is configured, but this build only supports local_encrypted`,+ message: `${provider} is configured, but this build only supports local_encrypted and aws_secrets_manager`,canRepair: false,- repairHint: "Run `paperclipai configure --section secrets` and set provider to local_encrypted",+ repairHint: "Run `paperclipai configure --section secrets` and choose local_encrypted or aws_secrets_manager",};}@@ -135,12 +141,100 @@ export function secretsCheck(config: PaperclipConfig, configPath?: string): Chec};}+ const keyMode = fs.statSync(keyFilePath).mode & 0o777;+ const permissionWarning =+ (keyMode & 0o077) !== 0+ ? `; key file permissions are ${keyMode.toString(8)} (run chmod 600 ${keyFilePath})`+ : "";+return withStrictModeNote({name: "Secrets adapter",- status: "pass",- message: `Local encrypted provider configured with key file ${keyFilePath}`,+ status: permissionWarning ? "warn" : "pass",+ message: `Local encrypted provider configured with key file ${keyFilePath}${permissionWarning}`,+ repairHint: permissionWarning+ ? "Restrict the local encrypted secrets key file to owner read/write permissions"+ : undefined,},config,);}++function awsSecretsManagerCheck(): CheckResult {+ const missingConfig = missingAwsSecretsManagerConfig();+ if (missingConfig.length > 0) {+ return {+ name: "Secrets adapter",+ status: "fail",+ message: `AWS Secrets Manager provider is missing non-secret config: ${missingConfig.join(", ")}`,+ canRepair: false,+ repairHint:+ `Set ${missingConfig.join(", ")} in the Paperclip server runtime. ${AWS_CREDENTIAL_SOURCE_HINT}. Do not store AWS root credentials or long-lived IAM user keys in Paperclip secrets.`,+ };+ }++ const staticEnvCredentials =+ process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim();+ const credentialSource = detectedAwsCredentialSources().join(", ");+ const message =+ `AWS Secrets Manager provider configured for deployment ${process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID}; ` ++ `runtime credentials source: ${credentialSource || "AWS SDK default credential chain"}`;++ if (staticEnvCredentials) {+ return {+ name: "Secrets adapter",+ status: "warn",+ message,+ canRepair: false,+ repairHint:+ "AWS static environment credentials are visible. Use only short-lived shell credentials locally; prefer IAM role/workload identity for hosted deployments and never store AWS access keys in Paperclip company secrets.",+ };+ }++ return {+ name: "Secrets adapter",+ status: "pass",+ message,+ };+}++function missingAwsSecretsManagerConfig(): string[] {+ const missing: string[] = [];+ if (+ !(+ process.env.PAPERCLIP_SECRETS_AWS_REGION?.trim() ||+ process.env.AWS_REGION?.trim() ||+ process.env.AWS_DEFAULT_REGION?.trim()+ )+ ) {+ missing.push("PAPERCLIP_SECRETS_AWS_REGION or AWS_REGION/AWS_DEFAULT_REGION");+ }+ if (!process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID?.trim()) {+ missing.push("PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID");+ }+ if (!process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID?.trim()) {+ missing.push("PAPERCLIP_SECRETS_AWS_KMS_KEY_ID");+ }+ return missing;+}++function detectedAwsCredentialSources(): string[] {+ const sources: string[] = [];+ if (process.env.AWS_PROFILE?.trim()) sources.push("AWS_PROFILE/shared config");+ if (process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim()) {+ sources.push("temporary AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY environment credentials");+ }+ if (process.env.AWS_WEB_IDENTITY_TOKEN_FILE?.trim() && process.env.AWS_ROLE_ARN?.trim()) {+ sources.push("AWS web identity token");+ }+ if (+ process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI?.trim() ||+ process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI?.trim()+ ) {+ sources.push("AWS container credentials endpoint");+ }+ if (process.env.AWS_SHARED_CREDENTIALS_FILE?.trim() || process.env.AWS_CONFIG_FILE?.trim()) {+ sources.push("custom AWS shared credentials/config file");+ }+ return sources;+}diff --git a/cli/src/commands/client/secrets.ts b/cli/src/commands/client/secrets.tsnew file mode 100644index 0000000000..98fb025d41--- /dev/null+++ b/cli/src/commands/client/secrets.ts@@ -0,0 +1,501 @@+import { Command } from "commander";+import pc from "picocolors";+import type {+ Agent,+ AgentEnvConfig,+ CompanyPortabilityEnvInput,+ CompanyPortabilityExportPreviewResult,+ CompanyPortabilityInclude,+ CompanySecret,+ EnvBinding,+ SecretProvider,+ SecretProviderDescriptor,+} from "@paperclipai/shared";+import {+ addCommonClientOptions,+ formatInlineRecord,+ handleCommandError,+ printOutput,+ resolveCommandContext,+ type BaseClientOptions,+} from "./common.js";++interface SecretListOptions extends BaseClientOptions {+ companyId?: string;+}++interface SecretDeclarationsOptions extends BaseClientOptions {+ companyId?: string;+ include?: string;+ kind?: "all" | "secret" | "plain";+}++interface SecretCreateOptions extends BaseClientOptions {+ companyId?: string;+ name?: string;+ key?: string;+ provider?: SecretProvider;+ value?: string;+ valueEnv?: string;+ description?: string;+}++interface SecretLinkOptions extends BaseClientOptions {+ companyId?: string;+ name?: string;+ key?: string;+ provider?: SecretProvider;+ externalRef?: string;+ providerVersionRef?: string;+ description?: string;+}++interface SecretDoctorOptions extends BaseClientOptions {+ companyId?: string;+}++interface SecretMigrateInlineEnvOptions extends BaseClientOptions {+ companyId?: string;+ apply?: boolean;+}++interface SecretProviderHealth {+ provider: SecretProvider;+ status: "ok" | "warn" | "error";+ message: string;+ warnings?: string[];+ backupGuidance?: string[];+ details?: Record<string, unknown>;+}++interface SecretProviderHealthResponse {+ providers: SecretProviderHealth[];+}++export interface InlineSecretMigrationCandidate {+ agentId: string;+ agentName: string;+ envKey: string;+ secretName: string;+ existingSecretId: string | null;+}++const SENSITIVE_ENV_KEY_RE =+ /(^token$|[-_]?token$|api[-_]?key|access[-_]?token|auth(?:_?token)?|authorization|bearer|secret|passwd|password|credential|jwt|private[-_]?key|cookie|connectionstring)/i;++const DEFAULT_DECLARATION_INCLUDE: CompanyPortabilityInclude = {+ company: true,+ agents: true,+ projects: true,+ issues: false,+ skills: false,+};++export function parseSecretsInclude(input: string | undefined): CompanyPortabilityInclude {+ if (!input?.trim()) return { ...DEFAULT_DECLARATION_INCLUDE };+ const values = input.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);+ const include = {+ company: values.includes("company"),+ agents: values.includes("agents"),+ projects: values.includes("projects"),+ issues: values.includes("issues") || values.includes("tasks"),+ skills: values.includes("skills"),+ };+ if (!Object.values(include).some(Boolean)) {+ throw new Error("Invalid --include value. Use one or more of: company,agents,projects,issues,tasks,skills");+ }+ return include;+}++export function isSensitiveEnvKey(key: string): boolean {+ return SENSITIVE_ENV_KEY_RE.test(key);+}++export function toPlainEnvValue(binding: unknown): string | null {+ if (typeof binding === "string") return binding;+ if (typeof binding !== "object" || binding === null || Array.isArray(binding)) return null;+ const record = binding as Record<string, unknown>;+ if (record.type === "plain" && typeof record.value === "string") return record.value;+ return null;+}++export function buildInlineMigrationSecretName(agentId: string, key: string): string {+ return `agent_${agentId.slice(0, 8)}_${key.toLowerCase()}`;+}++export function collectInlineSecretMigrationCandidates(+ agents: Agent[],+ existingSecrets: CompanySecret[],+): InlineSecretMigrationCandidate[] {+ const secretByName = new Map(existingSecrets.map((secret) => [secret.name, secret]));+ const candidates: InlineSecretMigrationCandidate[] = [];++ for (const agent of agents) {+ const env = asRecord(agent.adapterConfig.env);+ if (!env) continue;+ for (const [envKey, binding] of Object.entries(env)) {+ if (!isSensitiveEnvKey(envKey)) continue;+ const plain = toPlainEnvValue(binding);+ if (plain === null || plain.trim().length === 0) continue;+ const secretName = buildInlineMigrationSecretName(agent.id, envKey);+ candidates.push({+ agentId: agent.id,+ agentName: agent.name,+ envKey,+ secretName,+ existingSecretId: secretByName.get(secretName)?.id ?? null,+ });+ }+ }++ return candidates;+}++export function buildMigratedAgentEnv(+ env: Record<string, unknown>,+ secretIdByEnvKey: Map<string, string>,+): AgentEnvConfig {+ const next: AgentEnvConfig = { ...(env as Record<string, EnvBinding>) };+ for (const [envKey, secretId] of secretIdByEnvKey) {+ next[envKey] = {+ type: "secret_ref",+ secretId,+ version: "latest",+ };+ }+ return next;+}++function asRecord(value: unknown): Record<string, unknown> | null {+ if (typeof value !== "object" || value === null || Array.isArray(value)) return null;+ return value as Record<string, unknown>;+}++function readValueFromOptions(opts: SecretCreateOptions): string {+ if (opts.value !== undefined && opts.valueEnv !== undefined) {+ throw new Error("Use only one of --value or --value-env.");+ }+ if (opts.valueEnv !== undefined) {+ const value = process.env[opts.valueEnv];+ if (!value) throw new Error(`Environment variable ${opts.valueEnv} is empty or unset.`);+ return value;+ }+ if (opts.value !== undefined) return opts.value;+ throw new Error("Secret value is required. Pass --value or --value-env.");+}++function renderDeclaration(input: CompanyPortabilityEnvInput): Record<string, unknown> {+ const scope = input.agentSlug+ ? `agent:${input.agentSlug}`+ : input.projectSlug+ ? `project:${input.projectSlug}`+ : "company";+ return {+ key: input.key,+ scope,+ kind: input.kind,+ requirement: input.requirement,+ portability: input.portability,+ hasDefault: input.defaultValue !== null && input.defaultValue.length > 0,+ description: input.description,+ };+}++function renderSecret(secret: CompanySecret): Record<string, unknown> {+ return {+ id: secret.id,+ name: secret.name,+ key: secret.key,+ provider: secret.provider,+ status: secret.status,+ managedMode: secret.managedMode,+ latestVersion: secret.latestVersion,+ externalRef: secret.externalRef ? "yes" : "no",+ };+}++function printProviderHealth(rows: SecretProviderHealth[], json: boolean): void {+ if (json) {+ printOutput(rows, { json: true });+ return;+ }+ if (rows.length === 0) {+ printOutput([], { json: false });+ return;+ }+ for (const row of rows) {+ console.log(+ formatInlineRecord({+ id: row.provider,+ status: row.status,+ message: row.message,+ }),+ );+ for (const warning of row.warnings ?? []) {+ console.log(pc.yellow(`warning=${warning}`));+ }+ const missingConfig = asStringArray(row.details?.missingConfig);+ if (missingConfig.length > 0) {+ console.log(pc.dim(`missingConfig=${missingConfig.join(",")}`));+ }+ const credentialSource = typeof row.details?.credentialSource === "string"+ ? row.details.credentialSource+ : null;+ if (credentialSource) {+ console.log(pc.dim(`credentialSource=${credentialSource}`));+ }+ const detectedCredentialSources = asStringArray(row.details?.detectedCredentialSources);+ if (detectedCredentialSources.length > 0) {+ console.log(pc.dim(`detectedCredentialSources=${detectedCredentialSources.join(",")}`));+ }+ for (const guidance of row.backupGuidance ?? []) {+ console.log(pc.dim(`backup=${guidance}`));+ }+ }+}++function asStringArray(value: unknown): string[] {+ return Array.isArray(value)+ ? value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0)+ : [];+}++async function migrateInlineEnv(opts: SecretMigrateInlineEnvOptions): Promise<void> {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const companyId = ctx.companyId!;+ const agents = (await ctx.api.get<Agent[]>(`/api/companies/${companyId}/agents`)) ?? [];+ const secrets = (await ctx.api.get<CompanySecret[]>(`/api/companies/${companyId}/secrets`)) ?? [];+ const candidates = collectInlineSecretMigrationCandidates(agents, secrets);++ if (!opts.apply) {+ printOutput(+ {+ apply: false,+ agentsToUpdate: new Set(candidates.map((candidate) => candidate.agentId)).size,+ secretsToCreate: candidates.filter((candidate) => !candidate.existingSecretId).length,+ secretsToRotate: candidates.filter((candidate) => candidate.existingSecretId).length,+ candidates,+ },+ { json: ctx.json },+ );+ if (!ctx.json) {+ console.log(pc.dim("Re-run with --apply to create/rotate secrets and update agent env bindings."));+ }+ return;+ }++ const createdOrRotated = new Map<string, string>();+ let createdSecrets = 0;+ let rotatedSecrets = 0;++ for (const candidate of candidates) {+ const agent = agents.find((row) => row.id === candidate.agentId);+ const env = asRecord(agent?.adapterConfig.env);+ const value = env ? toPlainEnvValue(env[candidate.envKey]) : null;+ if (!value) continue;++ if (candidate.existingSecretId) {+ await ctx.api.post(`/api/secrets/${candidate.existingSecretId}/rotate`, { value });+ createdOrRotated.set(`${candidate.agentId}:${candidate.envKey}`, candidate.existingSecretId);+ rotatedSecrets += 1;+ continue;+ }++ const created = await ctx.api.post<CompanySecret>(`/api/companies/${companyId}/secrets`, {+ name: candidate.secretName,+ provider: "local_encrypted",+ value,+ description: `Migrated from agent ${candidate.agentId} env ${candidate.envKey}`,+ });+ if (!created) throw new Error(`Secret create returned no data for ${candidate.secretName}`);+ createdOrRotated.set(`${candidate.agentId}:${candidate.envKey}`, created.id);+ createdSecrets += 1;+ }++ let updatedAgents = 0;+ for (const agent of agents) {+ const env = asRecord(agent.adapterConfig.env);+ if (!env) continue;+ const secretIdByEnvKey = new Map<string, string>();+ for (const [key] of Object.entries(env)) {+ const secretId = createdOrRotated.get(`${agent.id}:${key}`);+ if (secretId) secretIdByEnvKey.set(key, secretId);+ }+ if (secretIdByEnvKey.size === 0) continue;+ const adapterConfig = {+ ...agent.adapterConfig,+ env: buildMigratedAgentEnv(env, secretIdByEnvKey),+ };+ await ctx.api.patch(`/api/agents/${agent.id}`, {+ adapterConfig,+ replaceAdapterConfig: true,+ });+ updatedAgents += 1;+ }++ printOutput(+ {+ apply: true,+ updatedAgents,+ createdSecrets,+ rotatedSecrets,+ },+ { json: ctx.json },+ );+}++export function registerSecretCommands(program: Command): void {+ const secrets = program.command("secrets").description("Secret declaration and provider operations");++ addCommonClientOptions(+ secrets+ .command("list")+ .description("List secret metadata for a company")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .action(async (opts: SecretListOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const rows = (await ctx.api.get<CompanySecret[]>(`/api/companies/${ctx.companyId}/secrets`)) ?? [];+ printOutput(ctx.json ? rows : rows.map(renderSecret), { json: ctx.json });+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("declarations")+ .description("List portable env declarations emitted by company export")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .option("--include <values>", "Comma-separated include set: company,agents,projects,issues,tasks,skills", "company,agents,projects")+ .option("--kind <kind>", "Filter declarations: all | secret | plain", "all")+ .action(async (opts: SecretDeclarationsOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const kind = opts.kind ?? "all";+ if (!["all", "secret", "plain"].includes(kind)) {+ throw new Error("Invalid --kind value. Use: all, secret, plain");+ }+ const preview = await ctx.api.post<CompanyPortabilityExportPreviewResult>(+ `/api/companies/${ctx.companyId}/exports/preview`,+ { include: parseSecretsInclude(opts.include) },+ );+ const declarations = (preview?.manifest.envInputs ?? [])+ .filter((entry) => kind === "all" || entry.kind === kind);+ printOutput(ctx.json ? declarations : declarations.map(renderDeclaration), { json: ctx.json });+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("create")+ .description("Create a Paperclip-managed secret")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .requiredOption("--name <name>", "Secret display name")+ .option("--key <key>", "Portable secret key")+ .option("--provider <provider>", "Secret provider id")+ .option("--value <value>", "Secret value")+ .option("--value-env <name>", "Read secret value from an environment variable")+ .option("--description <text>", "Description")+ .action(async (opts: SecretCreateOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const created = await ctx.api.post<CompanySecret>(`/api/companies/${ctx.companyId}/secrets`, {+ name: opts.name,+ key: opts.key,+ provider: opts.provider,+ value: readValueFromOptions(opts),+ description: opts.description,+ });+ printOutput(ctx.json ? created : renderSecret(created!), { json: ctx.json });+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("link")+ .description("Link an external provider-owned secret without storing its value in Paperclip")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .requiredOption("--name <name>", "Secret display name")+ .requiredOption("--provider <provider>", "Secret provider id")+ .requiredOption("--external-ref <ref>", "Provider secret ARN/name/path/reference")+ .option("--key <key>", "Portable secret key")+ .option("--provider-version-ref <ref>", "Provider version id or label")+ .option("--description <text>", "Description")+ .action(async (opts: SecretLinkOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const created = await ctx.api.post<CompanySecret>(`/api/companies/${ctx.companyId}/secrets`, {+ name: opts.name,+ key: opts.key,+ provider: opts.provider,+ managedMode: "external_reference",+ externalRef: opts.externalRef,+ providerVersionRef: opts.providerVersionRef,+ description: opts.description,+ });+ printOutput(ctx.json ? created : renderSecret(created!), { json: ctx.json });+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("doctor")+ .description("Run secret provider health checks through the Paperclip API")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .action(async (opts: SecretDoctorOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const health = await ctx.api.get<SecretProviderHealthResponse>(+ `/api/companies/${ctx.companyId}/secret-providers/health`,+ );+ printProviderHealth(health?.providers ?? [], ctx.json);+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("providers")+ .description("List configured secret provider descriptors")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .action(async (opts: SecretDoctorOptions) => {+ try {+ const ctx = resolveCommandContext(opts, { requireCompany: true });+ const rows = (await ctx.api.get<SecretProviderDescriptor[]>(+ `/api/companies/${ctx.companyId}/secret-providers`,+ )) ?? [];+ printOutput(rows, { json: ctx.json });+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );++ addCommonClientOptions(+ secrets+ .command("migrate-inline-env")+ .description("Migrate inline sensitive agent env values into secret references")+ .requiredOption("-C, --company-id <id>", "Company ID")+ .option("--apply", "Persist changes; default is a dry run", false)+ .action(async (opts: SecretMigrateInlineEnvOptions) => {+ try {+ await migrateInlineEnv(opts);+ } catch (err) {+ handleCommandError(err);+ }+ }),+ );+}diff --git a/cli/src/index.ts b/cli/src/index.tsindex bbec356f34..f1a2084a72 100644--- a/cli/src/index.ts+++ b/cli/src/index.ts@@ -18,6 +18,7 @@ import { registerActivityCommands } from "./commands/client/activity.js";import { registerDashboardCommands } from "./commands/client/dashboard.js";import { registerRoutineCommands } from "./commands/routines.js";import { registerFeedbackCommands } from "./commands/client/feedback.js";+import { registerSecretCommands } from "./commands/client/secrets.js";import { applyDataDirOverride, type DataDirOptionLike } from "./config/data-dir.js";import { loadPaperclipEnvFile } from "./config/env.js";import { initTelemetryFromConfigFile, flushTelemetry } from "./telemetry.js";@@ -147,6 +148,7 @@ registerActivityCommands(program);registerDashboardCommands(program);registerRoutineCommands(program);registerFeedbackCommands(program);+registerSecretCommands(program);registerWorktreeCommands(program);registerEnvLabCommands(program);registerPluginCommands(program);diff --git a/cli/src/prompts/secrets.ts b/cli/src/prompts/secrets.tsindex c65ef0bc61..f1804bceb7 100644--- a/cli/src/prompts/secrets.ts+++ b/cli/src/prompts/secrets.ts@@ -32,7 +32,7 @@ export async function promptSecrets(current?: SecretsConfig): Promise<SecretsCon{value: "aws_secrets_manager" as const,label: "AWS Secrets Manager",- hint: "requires external adapter integration",+ hint: "requires runtime AWS credentials and provider env config",},{value: "gcp_secret_manager" as const,@@ -84,7 +84,9 @@ export async function promptSecrets(current?: SecretsConfig): Promise<SecretsConif (provider !== "local_encrypted") {p.note(- `${provider} is not fully wired in this build yet. Keep local_encrypted unless you are actively implementing that adapter.`,+ provider === "aws_secrets_manager"+ ? "AWS credentials must come from the Paperclip server runtime (IAM role/workload identity, AWS_PROFILE/SSO/shared credentials, or short-lived shell env), not from Paperclip company secrets."+ : `${provider} is not fully wired in this build yet. Keep local_encrypted unless you are actively implementing that adapter.`,"Heads up",);}diff --git a/doc/CLI.md b/doc/CLI.mdindex 9f2aba8645..29c494e3be 100644--- a/doc/CLI.md+++ b/doc/CLI.md@@ -143,6 +143,32 @@ pnpm paperclipai agent local-cli codexcoder --company-id <company-id>pnpm paperclipai agent local-cli claudecoder --company-id <company-id>```+## Secrets Commands++```sh+pnpm paperclipai secrets list --company-id <company-id>+pnpm paperclipai secrets declarations --company-id <company-id> [--include agents,projects] [--kind secret]+pnpm paperclipai secrets create --company-id <company-id> --name anthropic-api-key --value-env ANTHROPIC_API_KEY+pnpm paperclipai secrets link --company-id <company-id> --name prod-stripe-key --provider aws_secrets_manager --external-ref <provider-ref>+pnpm paperclipai secrets doctor --company-id <company-id>+pnpm paperclipai secrets migrate-inline-env --company-id <company-id> [--apply]+```++Secret listing and declarations never print secret values. `create` accepts+`--value-env` so shell history does not capture the value. `link` records+provider-owned references without copying the secret value into Paperclip.+For AWS-backed secrets, `secrets doctor` reports missing non-secret provider+env and the expected AWS SDK runtime credential source; do not store AWS+bootstrap credentials in Paperclip secrets.++Per-company provider vaults (multiple vault instances per provider, default+vault selection, coming-soon GCP/Vault) are configured from the board UI under+`Company Settings → Secrets → Provider vaults` or through+`/api/companies/{companyId}/secret-provider-configs`. There is no CLI surface+for vault management today. See the+[secrets deploy guide](../docs/deploy/secrets.md#provider-vaults) and+[API reference](../docs/api/secrets.md#provider-vaults) for the contract.+## Approval Commands```shdiff --git a/doc/DATABASE.md b/doc/DATABASE.mdindex 23abd32d41..2e0ad66135 100644--- a/doc/DATABASE.md+++ b/doc/DATABASE.md@@ -171,6 +171,8 @@ For local/default installs, the active provider is `local_encrypted`:- Secret material is encrypted at rest with a local master key.- Default key file: `~/.paperclip/instances/default/secrets/master.key` (auto-created if missing).- CLI config location: `~/.paperclip/instances/default/config.json` under `secrets.localEncrypted.keyFilePath`.+- Backup/restore requires both the database metadata and the local master key file; either artifact alone is insufficient.+- The server best-effort enforces `0600` key file permissions and provider health reports permission warnings.Optional overrides:@@ -192,5 +194,10 @@ pnpm paperclipai configure --section secretsInline secret migration command:```sh+pnpm paperclipai secrets migrate-inline-env --company-id <company-id> --apply++# direct database maintenance fallbackpnpm secrets:migrate-inline-env --apply```++Hosted AWS provider notes live in [SECRETS-AWS-PROVIDER.md](./SECRETS-AWS-PROVIDER.md).diff --git a/doc/DEVELOPING.md b/doc/DEVELOPING.mdindex d95bb04dd7..c9a2a19414 100644--- a/doc/DEVELOPING.md+++ b/doc/DEVELOPING.md@@ -462,6 +462,7 @@ Agent env vars now support secret references. By default, secret values are stor- Default local key path: `~/.paperclip/instances/default/secrets/master.key`- Override key material directly: `PAPERCLIP_SECRETS_MASTER_KEY`- Override key file path: `PAPERCLIP_SECRETS_MASTER_KEY_FILE`+- Back up the key file and database together; either one alone is not enough to restore local encrypted secrets.Strict mode (recommended outside local trusted machines):@@ -470,12 +471,20 @@ PAPERCLIP_SECRETS_STRICT_MODE=true```When strict mode is enabled, sensitive env keys (for example `*_API_KEY`, `*_TOKEN`, `*_SECRET`) must use secret references instead of inline plain values.+Authenticated deployments default strict mode on unless explicitly overridden.CLI configuration support:- `pnpm paperclipai onboard` writes a default `secrets` config section (`local_encrypted`, strict mode off, key file path set) and creates a local key file when needed.- `pnpm paperclipai configure --section secrets` lets you update provider/strict mode/key path and creates the local key file when needed.-- `pnpm paperclipai doctor` validates secrets adapter configuration and can create a missing local key file with `--repair`.+- `pnpm paperclipai doctor` validates secrets adapter configuration, can create a missing local key file with `--repair`, and reports missing AWS Secrets Manager bootstrap env when that provider is selected.+- Provider health is available at `GET /api/companies/:companyId/secret-providers/health` and reports local key permission warnings plus backup guidance.++Per-company provider vaults are configured in the board UI under+`Company Settings → Secrets → Provider vaults`, backed by+`/api/companies/{companyId}/secret-provider-configs`. The CLI does not own+vault lifecycle today. See `docs/deploy/secrets.md` (`Provider Vaults` section)+for the operator model.Migration helper for existing inline env secrets:diff --git a/doc/SECRETS-AWS-PROVIDER.md b/doc/SECRETS-AWS-PROVIDER.mdnew file mode 100644index 0000000000..c7cce82e57--- /dev/null+++ b/doc/SECRETS-AWS-PROVIDER.md@@ -0,0 +1,368 @@+# AWS Secrets Manager Provider++Operational contract for the hosted `aws_secrets_manager` secret provider used by Paperclip Cloud.++## Scope++- Hosted provider for Paperclip-managed secrets when Paperclip Cloud runs on AWS.+- Source of truth for secret values is AWS Secrets Manager, not Postgres.+- Paperclip stores only metadata needed for ownership, bindings, version selection, audit, and runtime resolution.+- AWS provider bootstrap credentials are deployment/runtime credentials, not Paperclip-managed company secrets.+- Remote import for existing AWS secrets is metadata-only. Preview/import uses+ AWS inventory metadata and creates Paperclip external references; it does not+ copy plaintext into Paperclip.+- Per-company AWS provider vaults (named instances of `aws_secrets_manager`+ with their own region, namespace, prefix, KMS key id, and tags) are managed+ in the board UI under `Company Settings → Secrets → Provider vaults`. See+ [Provider Vaults](../docs/deploy/secrets.md#provider-vaults) for the operator+ model and [Provider Vaults API](../docs/api/secrets.md#provider-vaults) for+ the routes. The bootstrap trust model in this document still applies — vault+ config carries non-sensitive routing metadata only, never AWS credentials.++## Bootstrap Trust Model++The AWS provider has a chicken-and-egg boundary: Paperclip cannot use+`company_secrets` to unlock the AWS provider that stores those secrets. The+initial AWS trust must exist before the Paperclip server starts.++Allowed bootstrap locations:++- Infrastructure IAM or workload identity attached to the Paperclip server+ runtime.+- Process environment or orchestrator secret store used to start the Paperclip+ server.+- Local AWS SDK sources such as `AWS_PROFILE`, AWS SSO/shared config, web+ identity, container metadata, or instance metadata.+- Short-lived shell credentials for local development only.++Do not ask operators to paste AWS root credentials or long-lived IAM user access+keys into the Paperclip board UI. Do not store those bootstrap keys in+`company_secrets`.++## Paperclip Cloud Bootstrap++Paperclip Cloud must provision the AWS backing resources before any board user+can create AWS-backed company secrets:++1. Create or select the deployment KMS key.+2. Create the Paperclip server runtime role for the deployment.+3. Attach a minimum IAM policy scoped to the deployment Secrets Manager prefix+ and the configured KMS key.+4. Configure the server runtime with the non-secret provider environment+ variables below.+5. Run `paperclipai doctor` or the provider health endpoint from the deployed+ runtime and confirm that the provider reports the expected region, prefix,+ deployment id, KMS setting, and AWS SDK credential source.++Once this is in place, the board UI can create Paperclip-managed AWS secrets and+Paperclip will write them under the deployment/company namespace.++## Self-Hosted And Local Bootstrap++Self-hosted AWS deployments should use the AWS SDK default credential provider+chain. Preferred sources are role-based:++- EC2 instance profile.+- ECS task role.+- EKS IRSA or another OIDC web identity role.+- AWS SSO/shared config via `AWS_PROFILE`.++Local development can use:++```sh+aws sso login --profile paperclip-dev+AWS_PROFILE=paperclip-dev \+PAPERCLIP_SECRETS_PROVIDER=aws_secrets_manager \+PAPERCLIP_SECRETS_AWS_REGION=us-east-1 \+PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID=dev-local \+PAPERCLIP_SECRETS_AWS_KMS_KEY_ID=arn:aws:kms:us-east-1:123456789012:key/abcd-... \+pnpm dev+```++Temporary `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY` environment credentials+are acceptable only as a local break-glass or short-lived test source. They+should not be written to Paperclip config, committed to `.env` files, stored in+`company_secrets`, or used as the default Paperclip Cloud bootstrap path.++## Deployment Config++Required environment variables:++```sh+PAPERCLIP_SECRETS_PROVIDER=aws_secrets_manager+PAPERCLIP_SECRETS_AWS_REGION=us-east-1+PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID=prod-us-1+PAPERCLIP_SECRETS_AWS_KMS_KEY_ID=arn:aws:kms:us-east-1:123456789012:key/abcd-...+```++Optional environment variables:++```sh+PAPERCLIP_SECRETS_AWS_PREFIX=paperclip+PAPERCLIP_SECRETS_AWS_ENVIRONMENT=production+PAPERCLIP_SECRETS_AWS_PROVIDER_OWNER=paperclip+PAPERCLIP_SECRETS_AWS_ENDPOINT=+PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS=30+```++Naming convention for Paperclip-managed secrets:++```text+paperclip/{deploymentId}/{companyId}/{secretKey}+```++Tag set for Paperclip-managed secrets:++- `paperclip:managed-by=paperclip`+- `paperclip:provider-owner=<owner tag>`+- `paperclip:deployment-id=<deployment id>`+- `paperclip:company-id=<company id>`+- `paperclip:secret-key=<secret key>`+- `paperclip:environment=<environment tag>`++## IAM And KMS Assumptions++Launch posture:++- One Paperclip app role per deployment.+- One deployment-scoped KMS key per deployment at launch.+- Future per-company KMS keys remain compatible because Paperclip stores provider refs and version metadata separately from values.++Minimum IAM boundary:++- Allow `secretsmanager:CreateSecret`, `PutSecretValue`, `GetSecretValue`, and `DeleteSecret`.+- Scope resources to the deployment prefix:++```text+arn:aws:secretsmanager:<region>:<account-id>:secret:paperclip/<deployment-id>/*+```++- Allow `kms:Encrypt`, `kms:Decrypt`, `kms:GenerateDataKey`, and `kms:DescribeKey` for the configured deployment CMK.+- Deny wildcard access outside the deployment prefix.+- Prefer workload identity / role-based auth. Do not store AWS credentials inline in Paperclip config.++Example minimum policy shape:++```json+{+ "Version": "2012-10-17",+ "Statement": [+ {+ "Sid": "PaperclipDeploymentSecrets",+ "Effect": "Allow",+ "Action": [+ "secretsmanager:CreateSecret",+ "secretsmanager:PutSecretValue",+ "secretsmanager:GetSecretValue",+ "secretsmanager:DeleteSecret"+ ],+ "Resource": "arn:aws:secretsmanager:<region>:<account-id>:secret:paperclip/<deployment-id>/*"+ },+ {+ "Sid": "PaperclipDeploymentKms",+ "Effect": "Allow",+ "Action": [+ "kms:Encrypt",+ "kms:Decrypt",+ "kms:GenerateDataKey",+ "kms:DescribeKey"+ ],+ "Resource": "arn:aws:kms:<region>:<account-id>:key/<key-id>"+ }+ ]+}+```++Operational expectation:++- Paperclip-managed secrets may be deleted only by Paperclip or an operator with equivalent break-glass access.+- External references may resolve through Paperclip runtime, but Paperclip should not delete the external secret resource.++## Remote Import Inventory IAM++Remote import preview needs one additional AWS permission:++```json+{+ "Sid": "PaperclipRemoteSecretInventory",+ "Effect": "Allow",+ "Action": "secretsmanager:ListSecrets",+ "Resource": "*"+}+```++This is intentionally separate from the managed create/rotate/delete policy.+AWS treats `ListSecrets` as an account/Region inventory action; do not document+secret ARNs, names, tags, or AWS request filters as an IAM boundary for it. Use+`Resource: "*"` and decide whether inventory exposure is acceptable for the AWS+account and Region behind each provider vault.++Remote import preview/import must not call:++- `secretsmanager:GetSecretValue`+- `secretsmanager:BatchGetSecretValue`+- `kms:Decrypt`++Those permissions are only needed later when a bound runtime resolves an+imported external reference. For imported refs, scope read permissions to the+operator-approved external prefixes that Paperclip is allowed to consume:++```json+{+ "Sid": "PaperclipResolveImportedExternalReferences",+ "Effect": "Allow",+ "Action": "secretsmanager:GetSecretValue",+ "Resource": [+ "arn:aws:secretsmanager:<region>:<account-id>:secret:<approved-external-prefix>/*"+ ]+}+```++If selected external secrets use customer-managed KMS keys, also grant+`kms:Decrypt` and `kms:DescribeKey` on those keys. Keep managed write/delete+permissions scoped to `paperclip/<deployment-id>/*`; do not broaden them for+remote import.++Safe scoping guidance:++- Prefer one Paperclip runtime role per environment/account.+- Point provider vaults at the intended AWS account and Region instead of a+ broad central admin role.+- Enable `ListSecrets` only in accounts where inventory exposure is acceptable.+- Keep preview/import board-only; agent API keys must not call these routes.+- Treat AWS tag/name filters as search UX only, not permission enforcement.++Paperclip also blocks importing refs under its own managed namespace as+external references. Use the Paperclip-managed flow for+`paperclip/{deploymentId}/{companyId}/{secretKey}` resources.++## Existing AWS Secrets++V1 keeps existing AWS Secrets Manager entries as **linked external references**, not adopted+Paperclip-managed resources.++Use the Paperclip-managed flow when Paperclip should create and rotate the value. The AWS+secret name is derived from deployment and company scope:++```text+paperclip/{deploymentId}/{companyId}/{secretKey}+```++Use the external-reference flow when the secret already exists at an operator-owned path such+as:++```text+/paperclip-bench/anthropic_api_key+```++In that mode Paperclip stores only the path or ARN, resolves it at runtime, and records+redacted access events. Operators rotate the actual value in AWS. Update the Paperclip+reference only when the AWS path, ARN, or pinned provider version changes.++Paperclip does not currently offer an "adopt existing AWS secret" flow that takes over future+`PutSecretValue` writes for an arbitrary existing secret. Adding that later requires explicit+confirmation UX, scope validation, expected Paperclip tags, and security/cloud-ops review.++## Data Custody++- Paperclip stores `externalRef`, `providerVersionRef`, provider id, fingerprint hash, status, and binding metadata.+- Paperclip does not store AWS secret plaintext in `company_secret_versions.material`.+- Runtime resolution fetches the value from AWS only when a bound consumer needs it.++## Rotation Runbook++Manual Paperclip-managed rotation:++1. Write the new value through the Paperclip secret rotate flow.+2. Paperclip creates a new AWS secret version with `PutSecretValue`.+3. Paperclip records the new `providerVersionRef` in `company_secret_versions`.+4. Re-run or restart affected workloads that consume `latest`, or pin consumers to a specific Paperclip version before rollout when you need staged release safety.++Guidance:++- Prefer pinned Paperclip secret versions for risky rollouts.+- Treat provider-native automatic rotation as a later enhancement; current V1 flow is explicit create-new-version plus controlled rollout.++## Backup And Restore Runbook++What must survive:++- Paperclip database metadata for secret ownership, bindings, status, and provider version refs.+- AWS Secrets Manager namespace under the configured deployment prefix.+- The configured KMS key and its decrypt permissions.++Restore checklist:++1. Restore Paperclip database metadata.+2. Confirm the same AWS Secrets Manager namespace still exists.+3. Confirm the Paperclip runtime role can call `GetSecretValue` on the restored prefix.+4. Confirm the role still has decrypt access to the CMK referenced by `PAPERCLIP_SECRETS_AWS_KMS_KEY_ID`.+5. Run the live smoke below or a targeted runtime secret resolution test.++## Provider Outage Runbook++Symptoms:++- Secret create/rotate/resolve operations fail with AWS provider errors.+- Agent runs fail before adapter invocation on required secret resolution.+- Remote import preview fails to list AWS inventory.++Immediate actions:++1. Confirm AWS regional health and Secrets Manager availability.+2. Confirm the runtime role still has `GetSecretValue` and KMS decrypt permissions.+3. Check for accidental prefix, region, deployment id, or KMS key config drift.+4. Retry a single resolution after AWS service health is green.+5. If outage persists, pause high-risk runs that require secret access rather than churning retries.++Remote import-specific actions:++- Missing list permission: add `secretsmanager:ListSecrets` with+ `Resource: "*"` only when inventory import is approved for that vault's+ AWS account and Region.+- Throttling: narrow the search, wait briefly, and retry with backoff. Avoid+ full-account enumeration.+- Invalid or stale cursor: refresh the preview and discard the old+ `NextToken`.+- Large account: load pages intentionally, keep one in-flight preview request+ per vault/search, and do not run background full-account crawls.+- Runtime read failure after import: verify `GetSecretValue` and KMS decrypt+ on the selected external secret. Visibility in `ListSecrets` does not prove+ read permission.++## Incident Response Runbook++Potential incidents:++- Cross-company access caused by IAM scoping drift.+- KMS policy drift causing decrypt failures or over-broad access.+- Suspected secret exposure in logs, transcripts, or downstream agent output.++Response steps:++1. Stop or pause affected Paperclip runs.+2. Audit recent Paperclip secret access events for impacted secret ids and consumers.+3. Audit AWS CloudTrail for `ListSecrets`, `GetSecretValue`,+ `PutSecretValue`, and `DeleteSecret` calls on the relevant vault account,+ Region, deployment prefix, and approved external prefixes.+4. Rotate impacted secrets in AWS through Paperclip-managed versioning.+5. Re-scope IAM and KMS policies before resuming normal traffic.+6. If a value may have reached an agent transcript or external system, treat it as exposed and rotate immediately.++## Optional Live Smoke++This is safe to skip locally. Run it only against a dedicated AWS test namespace.++Prerequisites:++- AWS credentials or workload identity with the deployment-scoped IAM permissions above.+- `PAPERCLIP_SECRETS_PROVIDER=aws_secrets_manager`+- The required `PAPERCLIP_SECRETS_AWS_*` environment variables set.++Suggested smoke:++1. Create a test secret through the Paperclip board or API under a throwaway company.+2. Confirm the resulting AWS secret name matches `paperclip/{deploymentId}/{companyId}/{secretKey}`.+3. Rotate the secret once and confirm a new `providerVersionRef` appears in Paperclip metadata.+4. Resolve the secret through a bound runtime path, not by adding a general-purpose reveal endpoint.+5. Delete the throwaway secret and confirm AWS schedules deletion with the configured recovery window.diff --git a/doc/plans/2026-04-26-plugin-secret-ref-company-scope.md b/doc/plans/2026-04-26-plugin-secret-ref-company-scope.mdnew file mode 100644index 0000000000..ca689e1958--- /dev/null+++ b/doc/plans/2026-04-26-plugin-secret-ref-company-scope.md@@ -0,0 +1,86 @@+# Plugin Secret Refs: Company Scope Reintroduction Plan++Date: 2026-04-26+Status: follow-up after fail-closed mitigation+Related issue: PAP-2394++## Current state++`PAP-2394` now fails closed:++- `POST /api/plugins/:pluginId/config` rejects any config containing plugin secret refs.+- `ctx.secrets.resolve()` is disabled for plugin workers.++This removes the release-blocking cross-company exposure path, but it also disables plugin secret-ref support until the runtime carries company scope end to end.++## Vulnerability summary++The original design mixed an instance-global config store with company-scoped secret bindings:++- [server/src/routes/plugins.ts](/Users/dotta/paperclip/.paperclip/worktrees/PAP-2339-secrets-make-a-plan/server/src/routes/plugins.ts:1898) saved one global plugin config row, then wrote bindings into `company_secret_bindings` grouped by each referenced secret's owning company.+- [packages/db/src/schema/plugin_config.ts](/Users/dotta/paperclip/.paperclip/worktrees/PAP-2339-secrets-make-a-plan/packages/db/src/schema/plugin_config.ts:15) stored one config row per plugin, with no company dimension.+- [packages/db/src/schema/company_secret_bindings.ts](/Users/dotta/paperclip/.paperclip/worktrees/PAP-2339-secrets-make-a-plan/packages/db/src/schema/company_secret_bindings.ts:5) already modeled bindings as company-scoped.+- [server/src/services/plugin-secrets-handler.ts](/Users/dotta/paperclip/.paperclip/worktrees/PAP-2339-secrets-make-a-plan/server/src/services/plugin-secrets-handler.ts:212) resolved by `pluginId` + secret UUID, with no active company context from the bridge call.+- [packages/plugins/sdk/src/worker-rpc-host.ts](/Users/dotta/paperclip/.paperclip/worktrees/PAP-2339-secrets-make-a-plan/packages/plugins/sdk/src/worker-rpc-host.ts:384) exposed `ctx.config.get()` and `ctx.secrets.resolve()` without a company parameter.++This violated Least Privilege, Complete Mediation, and Secure Defaults.++## Recommended end state++Re-enable plugin secret refs only after both of these are true:++1. Plugin config reads/writes are company-scoped.+2. Runtime secret resolution carries explicit company context and enforces it at resolution time.++## Implementation plan++### 1. Make plugin config company-scoped++- Add `company_id` to `plugin_config`, with a unique index on `(plugin_id, company_id)`.+- Update registry helpers to require `companyId` for `getConfig`, `upsertConfig`, `patchConfig`, and `deleteConfig`.+- Update plugin config routes to require `companyId` and call `assertCompanyAccess(req, companyId)`.+- Keep instance-global plugin lifecycle state separate from company-scoped plugin config.++### 2. Propagate company context through the worker runtime++- Extend the SDK so `ctx.config.get()` and `ctx.secrets.resolve()` can receive or derive `companyId`.+- Introduce worker request context storage for handlers that already run with company scope:+ - `getData`+ - `performAction`+ - scoped API routes+ - tool executions+ - environment driver calls+- Fail closed when plugin code tries to read company-scoped config or secrets outside an active company context.++### 3. Rebind secrets by `(companyId, pluginId, configPath)`++- On config save, validate every referenced secret belongs to the authorized company.+- Store bindings only for that company.+- Resolve secrets only by the current company-scoped binding, never by bare plugin ID plus UUID.+- Treat stale bindings as invalid and remove them on config replacement.++### 4. Prevent cross-company config disclosure++- When returning config to the UI, only materialize the selected company's secret refs.+- Never expose another company's secret UUIDs through the global plugin config surface.++## Required regression coverage++- Company A board user cannot save plugin config that references a Company B secret.+- Company A plugin execution cannot resolve a Company B secret even if the same plugin is configured for Company B.+- Company-scoped config reads only return the selected company's secret bindings.+- Config replacement removes stale bindings for the same `(companyId, pluginId)` target.+- Runtime calls without company context fail closed.++## Migration notes++- Existing `plugin_config` rows need a migration strategy before re-enable.+- Safest default: do not auto-assume a company for historical secret refs.+- Prefer one of:+ - explicit admin migration per company, or+ - import existing rows as non-secret config only and require re-entry of secret refs.++## Release posture++- Keep plugin secret refs disabled until all steps above land.+- Do not restore the feature behind a soft warning; the insecure path must remain unavailable by default.diff --git a/doc/pr/5429/env-editor-with-secrets.png b/doc/pr/5429/env-editor-with-secrets.pngnew file mode 100644index 0000000000..ad426135b9Binary files /dev/null and b/doc/pr/5429/env-editor-with-secrets.png differdiff --git a/doc/pr/5429/secret-binding-picker.png b/doc/pr/5429/secret-binding-picker.pngnew file mode 100644index 0000000000..d5b0cc8ab2Binary files /dev/null and b/doc/pr/5429/secret-binding-picker.png differdiff --git a/doc/pr/5429/secrets-inventory.png b/doc/pr/5429/secrets-inventory.pngnew file mode 100644index 0000000000..13fb20f2f8Binary files /dev/null and b/doc/pr/5429/secrets-inventory.png differdiff --git a/docs/api/secrets-remote-import.md b/docs/api/secrets-remote-import.mdnew file mode 100644index 0000000000..8b3c9099f5--- /dev/null+++ b/docs/api/secrets-remote-import.md@@ -0,0 +1,133 @@+---+title: Secrets Remote Import+summary: AWS Secrets Manager metadata-only remote import API+---++Remote import lets the board link existing AWS Secrets Manager entries as+Paperclip `external_reference` secrets without copying plaintext into+Paperclip.++Both routes are board-only and company-scoped. The selected provider vault must+belong to the company, use `aws_secrets_manager`, and have a selectable status+(`ready` or `warning`). Disabled, coming-soon, or cross-company vaults are+rejected.++Remote import is an inventory and metadata workflow. Preview calls AWS+`ListSecrets` only and import stores a Paperclip external reference plus+fingerprint/version metadata. Neither route calls `GetSecretValue` or+`BatchGetSecretValue`, requests `SecretString`, requires KMS decrypt, logs raw+remote metadata, or copies secret plaintext into Paperclip.++## Preview Remote AWS Secrets++```+POST /api/companies/{companyId}/secrets/remote-import/preview+{+ "providerConfigId": "<aws-vault-uuid>",+ "query": "stripe",+ "nextToken": "optional-provider-page-token",+ "pageSize": 50+}+```++`query` is optional and is sent to AWS as an inventory filter. Treat it as+non-secret metadata because AWS may record list request parameters in+CloudTrail. `nextToken` is an opaque AWS cursor; pass it back unchanged.+`pageSize` is capped at 100.++Response:++```json+{+ "providerConfigId": "<aws-vault-uuid>",+ "provider": "aws_secrets_manager",+ "nextToken": null,+ "candidates": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "remoteName": "prod/stripe",+ "name": "prod/stripe",+ "key": "prod-stripe",+ "providerVersionRef": null,+ "providerMetadata": {+ "lastChangedDate": "2026-05-06T00:00:00.000Z",+ "hasDescription": true+ },+ "status": "ready",+ "importable": true,+ "conflicts": []+ }+ ]+}+```++Candidate `status` values:++- `ready`: no existing exact external reference and no name/key collision.+- `duplicate`: an existing secret already has the exact provider `externalRef`.+- `conflict`: the suggested Paperclip `name` or `key` is already in use.++Conflict `type` values are `exact_reference`, `name`, `key`, and+`provider_guardrail`. AWS refs under Paperclip's own managed namespace are+blocked as external references so one company cannot import another company's+Paperclip-managed AWS secret through a broad runtime role.++## Import Remote AWS Secret References++```+POST /api/companies/{companyId}/secrets/remote-import+{+ "providerConfigId": "<aws-vault-uuid>",+ "secrets": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "name": "Stripe production key",+ "key": "stripe-production-key",+ "description": "Stripe key used by production checkout",+ "providerVersionRef": null,+ "providerMetadata": {+ "lastChangedDate": "2026-05-06T00:00:00.000Z",+ "hasDescription": true+ }+ }+ ]+}+```++The import response is row-level. Ready rows become active+`external_reference` secrets with version metadata only. Exact-reference+duplicates and name/key conflicts are skipped without failing the whole request.+The `secrets` array accepts 1-100 rows, and the backend re-checks duplicates and+conflicts at submit time.+Each row may include an optional Paperclip `description` entered during review;+blank descriptions are stored as `null`. AWS provider descriptions are not+copied into this field.++```json+{+ "providerConfigId": "<aws-vault-uuid>",+ "provider": "aws_secrets_manager",+ "importedCount": 1,+ "skippedCount": 1,+ "errorCount": 0,+ "results": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "name": "Stripe production key",+ "key": "stripe-production-key",+ "status": "imported",+ "reason": null,+ "secretId": "<paperclip-secret-id>",+ "conflicts": []+ }+ ]+}+```++Activity logs record aggregate counts and provider/vault ids only, not remote+secret names, ARNs, tags, or values.++Imported references may still fail during a future bound runtime resolution if+the Paperclip runtime role can list the AWS secret but lacks+`secretsmanager:GetSecretValue` or required KMS decrypt permission for that+specific secret.diff --git a/docs/api/secrets.md b/docs/api/secrets.mdindex 49a36e0e43..93a56b6080 100644--- a/docs/api/secrets.md+++ b/docs/api/secrets.md@@ -25,16 +25,357 @@ POST /api/companies/{companyId}/secretsThe value is encrypted at rest. Only the secret ID and metadata are returned.-## Update Secret+To link a provider-owned secret without copying the value into Paperclip, create+an external-reference secret:+```json+{+ "name": "prod-stripe-key",+ "provider": "aws_secrets_manager",+ "managedMode": "external_reference",+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/stripe",+ "providerVersionRef": "version-id-or-label"+}+```++Paperclip stores the provider reference and a non-sensitive fingerprint only.+The value is resolved, when the provider is configured, through the server+runtime path that enforces binding context and records access events.++## Provider Health++```+GET /api/companies/{companyId}/secret-providers/health```-PATCH /api/secrets/{secretId}++Returns provider setup diagnostics, warnings, and local backup guidance. Health+responses must not include secret values or provider credentials.++For `aws_secrets_manager`, an unready health response names the missing+non-secret provider environment variables, the AWS SDK default credential source+expected by the server runtime, and the custody rule that AWS bootstrap+credentials must not be stored in Paperclip `company_secrets`.++The equivalent CLI check is:++```sh+pnpm paperclipai secrets doctor --company-id {companyId}+```++## Provider Vaults++Provider vaults are named, company-scoped configurations that route secret+material to one of the supported provider backends. See the+[secrets deploy guide](/deploy/secrets#provider-vaults) for the operator model+and custody rules.++All routes below require board auth and company access. Mutating routes emit+`secret_provider_config.*` activity-log entries. No route in this surface+returns provider credential values; submitting credential-shaped fields in+`config` is rejected at validation time.++### List Vaults++```+GET /api/companies/{companyId}/secret-provider-configs+```++Returns every vault for the company (including disabled rows for audit), each+with id, provider, displayName, status, isDefault, non-sensitive `config`,+latest health snapshot (`healthStatus`, `healthCheckedAt`, `healthMessage`,+`healthDetails`), `disabledAt`, and audit columns.++### Create Vault++```+POST /api/companies/{companyId}/secret-provider-configs+{+ "provider": "aws_secrets_manager",+ "displayName": "Prod US-East",+ "isDefault": true,+ "config": {+ "region": "us-east-1",+ "namespace": "paperclip",+ "secretNamePrefix": "paperclip",+ "kmsKeyId": "arn:aws:kms:us-east-1:123456789012:key/abcd-...",+ "environmentTag": "production"+ }+}+```++Per-provider `config` shapes:++- `local_encrypted`: optional `backupReminderAcknowledged: boolean`.+- `aws_secrets_manager`: required `region`; optional `namespace`,+ `secretNamePrefix`, `kmsKeyId`, `ownerTag`, `environmentTag`.+- `gcp_secret_manager` (coming soon): optional `projectId`, `location`,+ `namespace`, `secretNamePrefix`.+- `vault` (coming soon): optional origin-only HTTPS `address`, `namespace`,+ `mountPath`, `secretPathPrefix`. `address` values with embedded credentials,+ paths, query strings, or fragments are rejected.++`status` defaults to `ready` for `local_encrypted` and `aws_secrets_manager`,+and to `coming_soon` for `gcp_secret_manager` and `vault`. Coming-soon and+disabled vaults cannot be marked `isDefault`. Setting `isDefault: true` clears+the previous default for the same provider in the same transaction.++### Get Vault++```+GET /api/secret-provider-configs/{id}+```++### Update Vault++```+PATCH /api/secret-provider-configs/{id}+{+ "displayName": "Prod US-East-2",+ "config": {+ "region": "us-east-2",+ "kmsKeyId": "arn:aws:kms:us-east-2:123456789012:key/abcd-..."+ }+}+```++`config` is replaced wholesale on update — pass the full provider config+payload, not a partial diff. Status transitions for `gcp_secret_manager` and+`vault` are constrained to `coming_soon` and `disabled` until their runtime+modules ship.++### Disable Vault++```+DELETE /api/secret-provider-configs/{id}+```++Soft-deletes the vault: status flips to `disabled`, `isDefault` clears, and+`disabledAt` is stamped. Disabled vaults remain in `GET` results for audit+purposes but are no longer offered in the secret create/rotate flow.++### Set Default++```+POST /api/secret-provider-configs/{id}/default+```++Marks the target vault as the default for its provider family and clears the+previous default. Returns 422 when the target is `coming_soon` or `disabled`.++### Run Health Check++```+POST /api/secret-provider-configs/{id}/health+```++Runs a provider-specific health probe and persists the result on the vault.+Response shape:++```json+{+ "configId": "<uuid>",+ "provider": "aws_secrets_manager",+ "status": "ready" | "warning" | "error" | "coming_soon" | "disabled",+ "message": "Provider vault is ready to handle managed writes",+ "details": {+ "code": "provider_ready",+ "message": "...",+ "guidance": ["..."]+ },+ "checkedAt": "2026-05-06T14:00:00.000Z"+}+```++Health responses never include provider credentials or secret values. For AWS+vaults, `details.guidance` may include missing non-secret env names and the+expected AWS SDK credential source; coming-soon vaults always return+`status: "coming_soon"` with `code: "runtime_locked"` and never call into+provider modules.++### Selecting A Vault When Creating Or Rotating Secrets++`POST /api/companies/{companyId}/secrets` and+`POST /api/secrets/{secretId}/rotate` both accept an optional+`providerConfigId` field that pins the secret to a specific vault. When+omitted (or null), the operation runs through the deployment-level provider+configuration — the same path existing installs already use. The board UI+preselects the company's default vault for the chosen provider before+submitting, so callers should usually send an explicit `providerConfigId`.+Coming-soon and disabled vaults are rejected with a 422; a vault that does not+match the secret's provider is rejected the same way.++```json+POST /api/companies/{companyId}/secrets+{+ "name": "prod-stripe-key",+ "provider": "aws_secrets_manager",+ "providerConfigId": "<vault-uuid>",+ "managedMode": "external_reference",+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/stripe"+}+```++### Response Redaction Rules++Every route in this surface enforces the same redaction contract:++- Secret values are never returned. The board UI never has a "reveal value"+ affordance; resolution happens server-side at runtime under a binding.+- Provider credential values are never accepted, stored, returned, logged, or+ echoed in error messages. Submitting credential-shaped fields fails+ validation with a non-leaking error.+- Activity log entries record vault id, provider, displayName, status, and+ isDefault transitions — never `config` payloads or health detail bodies.++## Remote Import From AWS Secrets Manager++Remote import links existing AWS Secrets Manager entries into Paperclip as+`external_reference` secrets. Import stores provider reference metadata only; it+does not copy the remote secret plaintext into Paperclip.++The routes are board-only and company-scoped. `providerConfigId` must point to+a same-company AWS provider vault with status `ready` or `warning`. Disabled,+coming-soon, non-AWS, and cross-company vaults are rejected. Imported secrets+resolve later through the selected vault, so runtime reads still need+`secretsmanager:GetSecretValue` and any required KMS decrypt permission on the+selected external secret.++### Preview Remote Import Candidates++```+POST /api/companies/{companyId}/secrets/remote-import/preview+{+ "providerConfigId": "<aws-vault-uuid>",+ "query": "stripe",+ "nextToken": "opaque-provider-token",+ "pageSize": 50+}+```++`query` is optional and is passed to AWS Secrets Manager inventory filtering.+Treat it as non-secret metadata because AWS may record list request parameters+in CloudTrail. `nextToken` is an opaque AWS cursor; callers must pass it back+unchanged and must not synthesize offsets. `pageSize` is optional, defaults to+50 in the UI, and is capped at 100.++Preview uses AWS `ListSecrets` only. It must not call `GetSecretValue` or+`BatchGetSecretValue`, must not request `SecretString`, and must not require KMS+decrypt. The response contains sanitized metadata for display and conflict+decisions:++```json+{+ "providerConfigId": "<aws-vault-uuid>",+ "provider": "aws_secrets_manager",+ "nextToken": null,+ "candidates": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "remoteName": "prod/stripe",+ "name": "prod/stripe",+ "key": "prod-stripe",+ "providerVersionRef": null,+ "providerMetadata": {+ "createdDate": "2026-05-06T00:00:00.000Z",+ "lastChangedDate": "2026-05-06T00:00:00.000Z",+ "hasDescription": true,+ "hasKmsKey": true,+ "tagCount": 3+ },+ "status": "ready",+ "importable": true,+ "conflicts": []+ }+ ]+}+```++Candidate statuses:++- `ready`: the row can be selected for import.+- `duplicate`: a Paperclip secret already links the same canonical provider+ reference for the same provider vault.+- `conflict`: the row has a name/key collision or provider guardrail failure.++Conflict types are `exact_reference`, `name`, `key`, and+`provider_guardrail`. AWS refs under Paperclip's own managed namespace are+blocked as external references; use the Paperclip-managed secret flow for those+resources instead.++### Import Selected Remote References++```+POST /api/companies/{companyId}/secrets/remote-import+{+ "providerConfigId": "<aws-vault-uuid>",+ "secrets": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "name": "Stripe production key",+ "key": "stripe-production-key",+ "description": "Stripe key used by production checkout",+ "providerVersionRef": null,+ "providerMetadata": {+ "createdDate": "2026-05-06T00:00:00.000Z"+ }+ }+ ]+}+```++The `secrets` array accepts 1-100 rows. Each row may override the suggested+Paperclip `name`, `key`, optional Paperclip `description`,+`providerVersionRef`, and sanitized `providerMetadata`. Blank descriptions are+stored as `null`; AWS provider descriptions are not copied into Paperclip+descriptions. The backend re-checks duplicate refs and name/key conflicts at+submit time; a stale preview does not bypass those checks.++The import response is row-level:++```json+{+ "providerConfigId": "<aws-vault-uuid>",+ "provider": "aws_secrets_manager",+ "importedCount": 1,+ "skippedCount": 1,+ "errorCount": 0,+ "results": [+ {+ "externalRef": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/stripe",+ "name": "Stripe production key",+ "key": "stripe-production-key",+ "status": "imported",+ "reason": null,+ "secretId": "<paperclip-secret-id>",+ "conflicts": []+ }+ ]+}+```++Row statuses:++- `imported`: Paperclip created an active `external_reference` secret and one+ metadata-only version row.+- `skipped`: the row had an exact-reference duplicate or name/key conflict.+- `error`: the provider rejected the reference or the row failed validation.++Activity logs for preview/import store aggregate counts, provider id, and vault+id only. They must not store remote secret names, ARNs, descriptions, tags,+plaintext values, provider credentials, or raw AWS error blobs.++## Rotate Secret++```+POST /api/secrets/{secretId}/rotate{"value": "sk-ant-new-value..."}```-Creates a new version of the secret. Agents referencing `"version": "latest"` automatically get the new value on next heartbeat.+Creates a new version of the secret. Agents referencing `"version": "latest"`+automatically get the new value on next heartbeat. Pin to a specific version+when a bad `latest` rollout would affect many agents at once.## Using Secrets in Agent Config@@ -52,4 +393,20 @@ Reference secrets in agent adapter config instead of inline values:}```-The server resolves and decrypts secret references at runtime, injecting the real value into the agent process environment.+The server resolves and decrypts secret references at runtime, injecting the+real value into the agent process environment. Paperclip's custody guarantees+end at injection: the agent process can read, log, or forward the value, so+treat any secret bound to an agent as exposed to that agent. See the custody+boundaries note in the [secrets deploy guide](/deploy/secrets#custody-boundaries).++## Portability++Company export/import APIs represent agent and project environment requirements+as declarations in the package manifest. Exports omit secret values, secret IDs,+provider references, and encrypted provider material. Use:++```sh+pnpm paperclipai secrets declarations --company-id {companyId}+```++to inspect the declarations that an export would emit before moving a package.diff --git a/docs/cli/overview.md b/docs/cli/overview.mdindex 8bcf78aa95..f160832b8f 100644--- a/docs/cli/overview.md+++ b/docs/cli/overview.md@@ -57,6 +57,16 @@ pnpm paperclipai context set --api-key-env-var-name PAPERCLIP_API_KEYexport PAPERCLIP_API_KEY=...```+Secret operations are available under `paperclipai secrets`:++```sh+pnpm paperclipai secrets declarations --company-id <company-id> --kind secret+pnpm paperclipai secrets create --company-id <company-id> --name anthropic-api-key --value-env ANTHROPIC_API_KEY+pnpm paperclipai secrets link --company-id <company-id> --name prod-stripe-key --provider aws_secrets_manager --external-ref <provider-ref>+pnpm paperclipai secrets doctor --company-id <company-id>+pnpm paperclipai secrets migrate-inline-env --company-id <company-id> --apply+```+Context is stored at `~/.paperclip/context.json`.## Command Categoriesdiff --git a/docs/cli/setup-commands.md b/docs/cli/setup-commands.mdindex bb3cf17f11..f6284aba01 100644--- a/docs/cli/setup-commands.md+++ b/docs/cli/setup-commands.md@@ -67,7 +67,8 @@ Validates:- Server configuration- Database connectivity-- Secrets adapter configuration+- Secrets adapter configuration, including AWS Secrets Manager non-secret env+ config when selected- Storage configuration- Missing key files@@ -81,6 +82,13 @@ pnpm paperclipai configure --section secretspnpm paperclipai configure --section storage```+`--section secrets` updates the deployment-level provider used as the fallback+for secrets that do not target a specific company vault. Per-company provider+vaults (named instances, default vault selection, multiple vaults per provider,+coming-soon GCP/Vault) live in the board UI under+`Company Settings → Secrets → Provider vaults` and the+`/api/companies/{companyId}/secret-provider-configs` API.+## `paperclipai env`Show resolved environment configuration:diff --git a/docs/deploy/secrets.md b/docs/deploy/secrets.mdindex 3ef1c689f8..41fa9df375 100644--- a/docs/deploy/secrets.md+++ b/docs/deploy/secrets.md@@ -5,6 +5,52 @@ summary: Master key, encryption, and strict modePaperclip encrypts secrets at rest using a local master key. Agent environment variables that contain sensitive values (API keys, tokens) are stored as encrypted secret references.+## Custody Boundaries++Paperclip protects secret values up to the moment they are handed to an agent+or workload:++- Storage: values are encrypted at rest by the active provider. The local+ provider keeps them encrypted with a key that never leaves the host.+- Transport: values are decrypted server-side and injected into the agent+ process environment, SSH command env, sandbox driver, or HTTP request+ immediately before the call. Paperclip does not return decrypted values to+ the board UI.+- Audit: each resolution records a non-sensitive event (secret id, version,+ provider id, consumer, outcome) without the value or provider credentials.++Once a value reaches the consuming process, Paperclip can no longer guarantee+secrecy. The agent (or sandbox, or remote host) can read the value, write it to+its own logs or transcript, or pass it to downstream tools. Treat any secret+you bind to an agent as exposed to that agent. Limit blast radius with bindings+(only bind what each agent needs), short-lived provider credentials where the+provider supports them, and rotation when an agent transcript or downstream+system might have captured a value.++## Using Secrets In Runs++Creating a company secret does not automatically create an environment variable.+You use a secret by binding it into an agent, project, environment, or plugin+configuration field that supports secret references.++For agent and project environment variables:++1. Create or link the secret in `Company Settings > Secrets`.+2. Open the agent's `Environment variables` field, or the project's `Env`+ field.+3. Add the environment variable key the process expects, such as `GH_TOKEN` or+ `OPENAI_API_KEY`.+4. Set the row source to `Secret`, select the stored secret, and choose either+ `latest` or a pinned version.++At runtime, Paperclip resolves the selected secret server-side and injects the+resolved value under the env key from the binding row. The stored secret name+can be human-readable; the binding key is what the agent process receives.++Project env applies to every issue run in that project. When a project env key+matches an agent env key, the project value wins before Paperclip injects its+own `PAPERCLIP_*` runtime variables.+## Default Provider: `local_encrypted`Secrets are encrypted with a local master key stored at:@@ -14,6 +60,13 @@ Secrets are encrypted with a local master key stored at:```This key is auto-created during onboarding. The key never leaves your machine.+Paperclip best-effort enforces `0600` permissions when it creates or loads the+key file. `paperclipai doctor` and the provider health API warn when the file is+readable by group or other users.++Back up the key file together with database backups. A database backup without+the key cannot decrypt local secrets, and a key backup without the database+metadata is not enough to restore named secret versions.## Configuration@@ -35,6 +88,7 @@ Validate secrets config:```shpnpm paperclipai doctor+pnpm paperclipai secrets doctor --company-id <company-id>```### Environment Overrides@@ -55,15 +109,279 @@ PAPERCLIP_SECRETS_STRICT_MODE=trueRecommended for any deployment beyond local trusted.+Authenticated deployments default strict mode on unless explicitly overridden by+configuration or `PAPERCLIP_SECRETS_STRICT_MODE=false`.++## External References++Provider-owned secrets can be linked without copying values into Paperclip by+using `managedMode: "external_reference"` plus a provider `externalRef`.+Paperclip stores metadata and a non-sensitive fingerprint, never the value.+Runtime resolution remains server-side and binding-enforced.++The built-in AWS, GCP, and Vault provider IDs currently accept external+reference metadata, but runtime resolution requires provider configuration in the+deployment. Their provider health check reports this as a warning until+configured.++For hosted Paperclip Cloud on AWS, see the AWS Secrets Manager operational+contract — required env vars, IAM/KMS scoping, naming and tag conventions, and+backup/rotation/incident runbooks — in `doc/SECRETS-AWS-PROVIDER.md`.++## Provider Vaults++A *provider vault* is a named, company-scoped configuration that points secret+material at one of the supported provider backends. Each company can configure+multiple vaults, including more than one vault per provider family, and pick a+default vault per family for new secret operations. Existing secrets created+before any vault was configured continue to resolve through the deployment-level+default provider — no migration is required.++### Where to configure++Open `Company Settings → Secrets` in the board UI and switch to the+`Provider vaults` tab. From there you can:++- Create a vault for any supported provider family.+- Edit the non-secret config of an existing vault.+- Set one ready vault per provider family as the company default.+- Disable a vault (a soft delete that keeps audit history).+- Run a health check against a vault and read the latest result inline.++The same operations are exposed under+`/api/companies/{companyId}/secret-provider-configs` for automation. See the+[secrets API reference](/api/secrets#provider-vaults) for the full route table.++### Custody Of Provider Credentials++Provider vaults intentionally store only **non-sensitive** configuration:+region, project id, namespace, prefix, KMS key id, mount path, address, and+similar routing metadata. The API, UI, and activity log never accept, return,+or display provider credential values. Submitting fields with names like+`accessKeyId`, `secretAccessKey`, `token`, `password`, `serviceAccountJson`,+`privateKey`, `keyFile`, `unsealKey`, or any common credential alias is rejected+at validation time.++That keeps the bootstrap rule from the AWS provider applicable to every+provider family: **provider credentials live in deployment infrastructure+identity, not in Paperclip company secrets**. Allowed credential sources are+workload identity attached to the Paperclip server (instance profile, IRSA, ECS+task role), `AWS_PROFILE` / SSO / shared config for local runs, an orchestrator+secret store that boots the server, or short-lived shell credentials for local+development. Do not paste long-lived API keys into the vault config.++### Vault Status++Each vault carries a status that drives what the runtime can do with it:++| Status | Meaning |+|---------------|-----------------------------------------------------------------------------------------------|+| `ready` | Selectable for create/rotate/resolve. Eligible to be the default. |+| `warning` | Saved config exists but health needs attention (for example missing AWS env). Still selectable. |+| `coming_soon` | Visible and editable as draft metadata, but locked out of all runtime operations. |+| `disabled` | Soft-deleted. Hidden from the secret create/rotate flow. |++`gcp_secret_manager` and `vault` are pinned to `coming_soon` until their+runtime modules ship. The settings UI lets you save draft configuration for+those providers (and surfaces them on the vault list), but secret create,+rotate, and resolve calls that target a coming-soon vault fail with a clear+runtime-locked error.++### Default Vault Behavior++A company can mark **one** ready (or warning) vault per provider family as the+default. The secret create and rotate dialogs preselect the default vault for+the chosen provider so operators don't have to remember which vault to pick.+Coming-soon and disabled vaults cannot be marked default; attempting to do so+returns a validation error. Setting a new default automatically clears the+previous default for that provider.++If a secret is created without any `providerConfigId` (no vaults exist yet, or+the operator clears the selector), runtime resolution falls back to the+deployment-level provider configuration — the same path existing installs use.+This keeps secrets created before any provider vault was configured working+without migration. Picking the default in the UI is an explicit selection, not+a runtime fallback: the create call still sends an explicit `providerConfigId`.++### Multiple Vaults Per Provider++Multiple vaults from the same provider family are first-class. Common patterns:++- Two AWS vaults pointing at different regions or KMS keys for environment+ separation.+- A staging Vault address alongside a production address.+- A dedicated GCP project for a single product line while the rest of the+ company uses another.++Each vault has its own display name, status, default flag, and health record.+Operators choose the vault explicitly when creating or rotating a secret; the+default vault is preselected to avoid accidental routing to the wrong account.++### Per-Vault Health Checks++`POST /api/secret-provider-configs/{id}/health` runs a provider-specific health+probe and stores the result on the vault row. The settings UI exposes the same+action and renders the result inline. Health responses include a status,+operator-facing message, and structured guidance (such as missing env var+names, expected credential sources, and backup reminders). They never include+provider credentials or secret values. Coming-soon vaults always return a+`runtime_locked` health code and never call into provider modules.++### Provider-Specific Notes++**Local encrypted vaults** wrap the existing `local_encrypted` provider. The+master key path and rotation guidance described above still applies. A local+vault config is mostly bookkeeping plus an explicit acknowledgement that the+key file is backed up alongside the database.++**AWS Secrets Manager vaults** read the per-vault `region`, `namespace`,+`secretNamePrefix`, `kmsKeyId`, `ownerTag`, and `environmentTag` to route+managed writes and external-reference reads. The vault config supplements (and+can override) the deployment-level `PAPERCLIP_SECRETS_AWS_*` env. Bootstrap+credentials still come from the AWS SDK default credential chain — see+`doc/SECRETS-AWS-PROVIDER.md` for the full IAM and KMS contract.++**GCP Secret Manager** and **HashiCorp Vault** vaults are coming soon. You can+save draft `projectId`, `location`, `namespace`, `address`, and `mountPath`+metadata so the company is ready to flip them on when the provider modules+ship. Vault `address` values must be origin-only `http(s)://host[:port]` URLs;+addresses with embedded credentials, paths, query strings, or fragments are+rejected.++### Remote Import From AWS Vaults++AWS provider vaults can import existing AWS Secrets Manager entries as+Paperclip `external_reference` secrets. This is a metadata-only link: Paperclip+stores the AWS ARN/path, a fingerprint/version reference, and binding metadata.+It does not read, copy, store, log, or display the remote plaintext secret+value during preview or import.++Operator flow in the board UI:++1. Open `Company Settings -> Secrets`.+2. Confirm at least one AWS provider vault is `ready` or `warning`.+3. In the `Secrets` tab, choose `Import from vault`.+4. Select an AWS vault, search the remote inventory, and load more pages as+ needed.+5. Check the rows to import, review/edit the Paperclip name and key, then+ submit.+6. Review the result summary for created, skipped, and failed rows.++The preview list is intentionally paged and search-first. AWS accounts can have+large per-Region inventories, and `ListSecrets` returns opaque `NextToken`+cursors. Do not expect Paperclip to crawl a whole account in the background;+load pages deliberately and retry throttled requests with backoff.++Remote import exposes AWS secret metadata visible to the Paperclip runtime+role, including names/ARNs and safe derived fields such as dates, whether a+description or KMS key exists, and tag count. Treat names, ARNs, tags, and+search text as operational metadata that may be sensitive. The API and activity+log must not store raw descriptions, tags, plaintext values, provider+credentials, or raw AWS error blobs.++Required AWS posture:++- Preview needs optional `secretsmanager:ListSecrets` permission on+ `Resource: "*"`. AWS does not support constraining `ListSecrets` to+ individual secret ARNs or tags as an IAM boundary.+- Preview/import must not call `secretsmanager:GetSecretValue`,+ `secretsmanager:BatchGetSecretValue`, or KMS decrypt.+- Runtime resolution of an imported reference still needs+ `secretsmanager:GetSecretValue` on the selected external ARN/path and KMS+ decrypt when that secret uses a customer-managed key.+- Keep managed create/rotate/delete permissions scoped to the Paperclip+ deployment prefix. Do not broaden managed write/delete permissions just+ because import inventory is enabled.++Safe scoping comes from deployment posture rather than AWS list filtering:+dedicated Paperclip runtime roles per environment/account, AWS vaults pointed at+the intended account and Region, import-enabled roles only where inventory+exposure is acceptable, and board-only access to the import routes. Tags and+name filters are search aids, not a permission model.++If import preview fails:++- `AccessDenied` or `not authorized`: the runtime role is missing+ `secretsmanager:ListSecrets`; add the optional inventory statement only if+ remote import should be enabled for that vault.+- Throttling: retry after a short delay and narrow the search before loading+ more pages.+- Invalid cursor: refresh the preview; AWS `NextToken` values are opaque and+ can expire or become stale.+- Runtime resolution failure after import: verify `GetSecretValue` and KMS+ decrypt scope for the selected external secret. Being visible in inventory is+ not proof that the runtime role can read the value.++### Backup And Restore++Each provider family has a different backup story:++- `local_encrypted`: back up the local master key file and the Paperclip+ database together. Either alone is not enough to restore the encrypted+ values, and the vault row only records the path and acknowledgement, not the+ key bytes.+- `aws_secrets_manager`: back up Paperclip's database for vault metadata+ (vault id, region, prefix, KMS key id, default flag, bindings, version+ pointers). The actual secret values live in AWS Secrets Manager under the+ configured prefix; restore by pointing the same Paperclip company at the+ same AWS namespace and confirming the runtime role still has+ `GetSecretValue` plus KMS decrypt. The full restore checklist lives in+ `doc/SECRETS-AWS-PROVIDER.md`.+- `gcp_secret_manager` and `vault`: while these are coming soon, only the+ draft vault config exists in Paperclip. Database backups capture it. There+ is nothing to restore on the provider side until runtime support lands.++### AWS Provider Bootstrap Boundary++The AWS Secrets Manager provider cannot bootstrap itself from Paperclip+`company_secrets`. Its initial AWS access must be present before the server can+create or resolve AWS-backed company secrets, regardless of whether you use the+deployment-level default or a per-company vault.++For Paperclip Cloud, provision the server runtime IAM role/workload identity,+KMS key, deployment prefix, and non-secret `PAPERCLIP_SECRETS_AWS_*` environment+configuration before enabling AWS-backed secrets in the board UI. For+self-hosted and local runs, use the AWS SDK default credential chain: instance+profile, ECS task role, EKS IRSA/OIDC web identity, AWS SSO/shared config via+`AWS_PROFILE`, or short-lived shell credentials for local development.++Do not store AWS root credentials or long-lived IAM user access keys in+Paperclip secrets. Bootstrap material belongs in infrastructure IAM/workload+identity, the process environment, an AWS profile, or the orchestrator secret+store.+## Migrating Inline SecretsIf you have existing agents with inline API keys in their config, migrate them to encrypted secret refs:```sh+pnpm paperclipai secrets migrate-inline-env --company-id <company-id>+pnpm paperclipai secrets migrate-inline-env --company-id <company-id> --apply++# low-level script for direct database maintenancepnpm secrets:migrate-inline-env # dry runpnpm secrets:migrate-inline-env --apply # apply migration```+Use the CLI command for normal operations because it goes through the Paperclip+API, creates or rotates secret records, and updates agent env bindings with+audit logging.++## Portable Declarations++Company exports include only environment declarations. They do not include+secret IDs, provider references, encrypted material, or plaintext values.++```sh+pnpm paperclipai secrets declarations --company-id <company-id> --kind secret+```++Before importing a package into another instance, use those declarations to+create local values or link hosted provider references in the target deployment.+For hosted providers such as AWS Secrets Manager, the hosted provider remains+the value custodian; Paperclip stores metadata and provider version references,+not provider credentials or plaintext secret values.+## Secret References in Agent ConfigAgent environment variables use secret references:diff --git a/packages/adapter-utils/src/command-managed-runtime.test.ts b/packages/adapter-utils/src/command-managed-runtime.test.tsindex 74c5d6a948..f765d2cee5 100644--- a/packages/adapter-utils/src/command-managed-runtime.test.ts+++ b/packages/adapter-utils/src/command-managed-runtime.test.ts@@ -61,7 +61,7 @@ describe("command managed runtime", () => {if (input.stdin != null &&(input.command === "sh" || input.command === "bash") &&- args[0] === "-lc" &&+ (args[0] === "-c" || args[0] === "-lc") &&typeof args[1] === "string") {env.PAPERCLIP_TEST_STDIN = input.stdin;diff --git a/packages/adapter-utils/src/command-managed-runtime.ts b/packages/adapter-utils/src/command-managed-runtime.tsindex 6f53cbb2b9..9c7221667e 100644--- a/packages/adapter-utils/src/command-managed-runtime.ts+++ b/packages/adapter-utils/src/command-managed-runtime.ts@@ -6,7 +6,7 @@ import {type SandboxManagedRuntimeClient,type SandboxRemoteExecutionSpec,} from "./sandbox-managed-runtime.js";-import { preferredShellForSandbox } from "./sandbox-shell.js";+import { preferredShellForSandbox, shellCommandArgs } from "./sandbox-shell.js";import type { RunProcessResult } from "./server-utils.js";export interface CommandManagedRuntimeRunner {@@ -65,7 +65,7 @@ export function createCommandManagedRuntimeClient(input: {const runShell = async (script: string, opts: { stdin?: string; timeoutMs?: number } = {}) => {const result = await input.runner.execute({command: shellCommand,- args: ["-lc", script],+ args: shellCommandArgs(script),cwd: input.commandCwd,stdin: opts.stdin,timeoutMs: opts.timeoutMs ?? input.timeoutMs,@@ -116,7 +116,7 @@ export function createCommandManagedRuntimeClient(input: {remove: async (remotePath) => {const result = await input.runner.execute({command: shellCommand,- args: ["-lc", `rm -rf ${shellQuote(remotePath)}`],+ args: shellCommandArgs(`rm -rf ${shellQuote(remotePath)}`),cwd: input.commandCwd,timeoutMs: input.timeoutMs,});@@ -125,7 +125,7 @@ export function createCommandManagedRuntimeClient(input: {run: async (command, options) => {const result = await input.runner.execute({command: shellCommand,- args: ["-lc", command],+ args: shellCommandArgs(command),cwd: input.commandCwd,timeoutMs: options.timeoutMs,});@@ -176,7 +176,7 @@ export async function prepareCommandManagedRuntime(input: {if (detectCommand) {const probe = await input.runner.execute({command: shellCommand,- args: ["-lc", `command -v ${shellQuote(detectCommand)} >/dev/null 2>&1`],+ args: shellCommandArgs(`command -v ${shellQuote(detectCommand)} >/dev/null 2>&1`),cwd: commandCwd,timeoutMs,});@@ -195,7 +195,7 @@ export async function prepareCommandManagedRuntime(input: {}const result = await input.runner.execute({command: shellCommand,- args: ["-lc", installCommand],+ args: shellCommandArgs(installCommand),cwd: commandCwd,timeoutMs,});diff --git a/packages/adapter-utils/src/execution-target-sandbox.test.ts b/packages/adapter-utils/src/execution-target-sandbox.test.tsindex 91bfd57d0d..ef56e1ff99 100644--- a/packages/adapter-utils/src/execution-target-sandbox.test.ts+++ b/packages/adapter-utils/src/execution-target-sandbox.test.ts@@ -136,7 +136,7 @@ describe("sandbox adapter execution targets", () => {expect(runner.execute).toHaveBeenCalledWith(expect.objectContaining({command: "sh",- args: ["-lc", 'printf %s "$HOME"'],+ args: ["-c", 'printf %s "$HOME"'],cwd: "/workspace",timeoutMs: 7000,}));@@ -284,7 +284,7 @@ describe("sandbox adapter execution targets", () => {expect(runner.execute).toHaveBeenCalledWith(expect.objectContaining({command: "bash",- args: ["-lc", 'printf %s "$HOME"'],+ args: ["-c", 'printf %s "$HOME"'],cwd: "/workspace",timeoutMs: 7000,}));diff --git a/packages/adapter-utils/src/execution-target.test.ts b/packages/adapter-utils/src/execution-target.test.tsindex 22b04ab8cb..d608e76c52 100644--- a/packages/adapter-utils/src/execution-target.test.ts+++ b/packages/adapter-utils/src/execution-target.test.ts@@ -45,7 +45,7 @@ describe("runAdapterExecutionTargetShellCommand", () => {},);- // runSshCommand owns profile sourcing and the outer `sh -lc` wrapper —+ // runSshCommand owns profile sourcing and the outer shell wrapper —// the caller passes the raw command string. Wrapping it here would// double-nest the login shell and re-source profiles after the explicit// env override, silently undoing identity-var preservation.@@ -317,7 +317,7 @@ describe("ensureAdapterExecutionTargetRuntimeCommandInstalled", () => {expect(runner.execute).toHaveBeenCalledWith(expect.objectContaining({command: "sh",- args: ["-lc", "npm install -g @google/gemini-cli"],+ args: ["-c", "npm install -g @google/gemini-cli"],cwd: "/remote/workspace",env: { PATH: "/usr/bin" },timeoutMs: 30_000,diff --git a/packages/adapter-utils/src/execution-target.ts b/packages/adapter-utils/src/execution-target.tsindex 091b988e57..e014dcddb7 100644--- a/packages/adapter-utils/src/execution-target.ts+++ b/packages/adapter-utils/src/execution-target.ts@@ -27,7 +27,7 @@ import {type TerminalResultCleanupOptions,} from "./server-utils.js";import { sanitizeRemoteExecutionEnv } from "./remote-execution-env.js";-import { preferredShellForSandbox } from "./sandbox-shell.js";+import { preferredShellForSandbox, shellCommandArgs } from "./sandbox-shell.js";export interface AdapterLocalExecutionTarget {kind: "local";@@ -319,7 +319,7 @@ async function ensureSandboxCommandResolvable(try {const installResult = await runner.execute({command: "sh",- args: ["-lc", installCommand],+ args: shellCommandArgs(installCommand),cwd: target.remoteCwd,timeoutMs: target.timeoutMs ?? 300_000,});@@ -417,8 +417,8 @@ export async function runAdapterExecutionTargetShellCommand(if (target.transport === "ssh") {try {// Pass the raw command — `runSshCommand` owns profile sourcing and- // the outer `sh -lc` wrapper. Wrapping again here would nest a second- // `sh -lc` after the explicit `env KEY=VAL` overrides, re-sourcing+ // the outer shell wrapper. Wrapping again here would nest a second+ // shell after the explicit `env KEY=VAL` overrides, re-sourcing// login profiles AFTER the override and silently undoing any// identity var (NVM_DIR / PATH / etc.) that a profile re-exports.const result = await runSshCommand(target.spec, command, {@@ -477,7 +477,7 @@ export async function runAdapterExecutionTargetShellCommand(const shellCommand = preferredSandboxShell(target);return await requireSandboxRunner(target).execute({command: shellCommand,- args: ["-lc", command],+ args: shellCommandArgs(command),cwd: target.remoteCwd,env,timeoutMs: (options.timeoutSec ?? 15) * 1000,diff --git a/packages/adapter-utils/src/sandbox-callback-bridge.test.ts b/packages/adapter-utils/src/sandbox-callback-bridge.test.tsindex a644fc46be..ebcd88874e 100644--- a/packages/adapter-utils/src/sandbox-callback-bridge.test.ts+++ b/packages/adapter-utils/src/sandbox-callback-bridge.test.ts@@ -46,7 +46,7 @@ describe("sandbox callback bridge", () => {if (input.stdin != null &&(input.command === "sh" || input.command === "bash") &&- args[0] === "-lc" &&+ (args[0] === "-c" || args[0] === "-lc") &&typeof args[1] === "string") {env.PAPERCLIP_TEST_STDIN = input.stdin;@@ -508,7 +508,7 @@ describe("sandbox callback bridge", () => {authorizeRequest: async () => null,handleRequest: async (request) => {seenRequestIds.push(request.id);- await new Promise((resolve) => setTimeout(resolve, 100));+ await new Promise((resolve) => setTimeout(resolve, 250));return {status: 200,headers: { "content-type": "application/json" },@@ -551,7 +551,7 @@ describe("sandbox callback bridge", () => {error: "Bridge worker stopped before request could be handled.",});- await new Promise((resolve) => setTimeout(resolve, 150));+ await new Promise((resolve) => setTimeout(resolve, 300));await expect(readdir(directories.responsesDir)).resolves.toEqual([]);await expect(diff --git a/packages/adapter-utils/src/sandbox-callback-bridge.ts b/packages/adapter-utils/src/sandbox-callback-bridge.tsindex 71fdb45c43..bab9f6147c 100644--- a/packages/adapter-utils/src/sandbox-callback-bridge.ts+++ b/packages/adapter-utils/src/sandbox-callback-bridge.ts@@ -4,7 +4,7 @@ import os from "node:os";import path from "node:path";import type { CommandManagedRuntimeRunner } from "./command-managed-runtime.js";-import { preferredShellForSandbox } from "./sandbox-shell.js";+import { preferredShellForSandbox, shellCommandArgs } from "./sandbox-shell.js";import type { RunProcessResult } from "./server-utils.js";const DEFAULT_BRIDGE_TOKEN_BYTES = 24;@@ -207,7 +207,7 @@ async function runShell(): Promise<RunProcessResult> {return await runner.execute({command: shellCommand,- args: ["-lc", script],+ args: shellCommandArgs(script),cwd,timeoutMs,stdin,@@ -569,10 +569,11 @@ async function writeBridgeResponse(requestPath: string,responsePath: string,response: SandboxCallbackBridgeResponse,+ options: { requireRequestPath?: boolean } = {},) {const body = `${JSON.stringify(response)}\n`;if (client.writeResponseFile) {- await client.writeResponseFile(responsePath, body, { requestPath });+ await client.writeResponseFile(responsePath, body, options.requireRequestPath === false ? {} : { requestPath });return;}const tempPath = `${responsePath}.tmp`;@@ -686,12 +687,15 @@ export async function startSandboxCallbackBridgeWorker(input: {try {const raw = await input.client.readTextFile(requestPath);const parsed = JSON.parse(raw) as Partial<SandboxCallbackBridgeRequest>;+ await input.client.remove(requestPath).catch(() => undefined);await writeBridgeResponse(input.client, requestPath, responsePath, {id: typeof parsed.id === "string" && parsed.id.length > 0 ? parsed.id : requestId,status: 503,headers: { "content-type": "application/json" },body: JSON.stringify({ error: message }),completedAt: new Date().toISOString(),+ }, {+ requireRequestPath: false,});} catch (error) {console.warn(@@ -901,8 +905,7 @@ export async function startSandboxCallbackBridgeServer(input: {const nodeCommand = input.nodeCommand?.trim() || "node";const startResult = await input.runner.execute({command: shellCommand,- args: [- "-lc",+ args: shellCommandArgs([`mkdir -p ${shellQuote(directories.requestsDir)} ${shellQuote(directories.responsesDir)} ${shellQuote(directories.logsDir)}`,`rm -f ${shellQuote(directories.readyFile)} ${shellQuote(directories.pidFile)}`,@@ -913,7 +916,7 @@ export async function startSandboxCallbackBridgeServer(input: {`printf '%s\\n' \"$pid\" > ${shellQuote(directories.pidFile)}`,"printf '{\"pid\":%s}\\n' \"$pid\"",].join("\n"),- ],+ ),cwd: input.remoteCwd,timeoutMs,});@@ -975,8 +978,7 @@ export async function startSandboxCallbackBridgeServer(input: {stop: async () => {const stopResult = await input.runner.execute({command: shellCommand,- args: [- "-lc",+ args: shellCommandArgs([`if [ -s ${shellQuote(directories.pidFile)} ]; then`,` pid="$(cat ${shellQuote(directories.pidFile)})"`,@@ -989,7 +991,7 @@ export async function startSandboxCallbackBridgeServer(input: {"fi",`rm -f ${shellQuote(directories.pidFile)} ${shellQuote(directories.readyFile)}`,].join("\n"),- ],+ ),cwd: input.remoteCwd,timeoutMs,});diff --git a/packages/adapter-utils/src/sandbox-managed-runtime.test.ts b/packages/adapter-utils/src/sandbox-managed-runtime.test.tsindex bbaa34260c..5f51faaab1 100644--- a/packages/adapter-utils/src/sandbox-managed-runtime.test.ts+++ b/packages/adapter-utils/src/sandbox-managed-runtime.test.ts@@ -84,7 +84,7 @@ describe("sandbox managed runtime", () => {await rm(remotePath, { recursive: true, force: true });},run: async (command) => {- await execFile("sh", ["-lc", command], {+ await execFile("sh", ["-c", command], {maxBuffer: 32 * 1024 * 1024,});},diff --git a/packages/adapter-utils/src/sandbox-managed-runtime.ts b/packages/adapter-utils/src/sandbox-managed-runtime.tsindex a5d3d5db52..62375d7da2 100644--- a/packages/adapter-utils/src/sandbox-managed-runtime.ts+++ b/packages/adapter-utils/src/sandbox-managed-runtime.ts@@ -267,7 +267,7 @@ export async function prepareSandboxManagedRuntime(input: {const preservedNames = new Set([".paperclip-runtime", ...(input.preserveAbsentOnRestore ?? [])]);const findPreserveArgs = [...preservedNames].map((entry) => `! -name ${shellQuote(entry)}`).join(" ");await input.client.run(- `sh -lc ${shellQuote(+ `sh -c ${shellQuote(`mkdir -p ${shellQuote(workspaceRemoteDir)} && ` +`find ${shellQuote(workspaceRemoteDir)} -mindepth 1 -maxdepth 1 ${findPreserveArgs} -exec rm -rf -- {} + && ` +`tar -xf ${shellQuote(remoteWorkspaceTar)} -C ${shellQuote(workspaceRemoteDir)} && ` +@@ -289,7 +289,7 @@ export async function prepareSandboxManagedRuntime(input: {const remoteAssetTar = path.posix.join(runtimeRootDir, `${asset.key}-upload.tar`);await input.client.writeFile(remoteAssetTar, toArrayBuffer(assetTarBytes));await input.client.run(- `sh -lc ${shellQuote(+ `sh -c ${shellQuote(`rm -rf ${shellQuote(remoteAssetDir)} && ` +`mkdir -p ${shellQuote(remoteAssetDir)} && ` +`tar -xf ${shellQuote(remoteAssetTar)} -C ${shellQuote(remoteAssetDir)} && ` +@@ -314,7 +314,7 @@ export async function prepareSandboxManagedRuntime(input: {await withTempDir("paperclip-sandbox-restore-", async (tempDir) => {const remoteWorkspaceTar = path.posix.join(runtimeRootDir, "workspace-download.tar");await input.client.run(- `sh -lc ${shellQuote(+ `sh -c ${shellQuote(`mkdir -p ${shellQuote(runtimeRootDir)} && ` +`tar -cf ${shellQuote(remoteWorkspaceTar)} -C ${shellQuote(workspaceRemoteDir)} ` +`${tarExcludeFlags(input.workspaceExclude)} .`,diff --git a/packages/adapter-utils/src/sandbox-shell.ts b/packages/adapter-utils/src/sandbox-shell.tsindex c83c0a1a2f..965f0299a7 100644--- a/packages/adapter-utils/src/sandbox-shell.ts+++ b/packages/adapter-utils/src/sandbox-shell.ts@@ -1,3 +1,7 @@export function preferredShellForSandbox(shellCommand: string | null | undefined): "bash" | "sh" {return shellCommand === "bash" ? "bash" : "sh";}++export function shellCommandArgs(script: string): string[] {+ return ["-c", script];+}diff --git a/packages/adapter-utils/src/ssh-fixture.test.ts b/packages/adapter-utils/src/ssh-fixture.test.tsindex 9c33ba41b6..09f4bbb4de 100644--- a/packages/adapter-utils/src/ssh-fixture.test.ts+++ b/packages/adapter-utils/src/ssh-fixture.test.ts@@ -17,6 +17,9 @@ import {} from "./ssh.js";import { prepareRemoteManagedRuntime } from "./remote-managed-runtime.js";+const SSH_FIXTURE_TEST_TIMEOUT_MS = 30_000;+let sshEnvLabUnsupportedReason: string | null = null;+async function git(cwd: string, args: string[]): Promise<string> {return await new Promise((resolve, reject) => {execFile("git", ["-C", cwd, ...args], (error, stdout, stderr) => {@@ -29,6 +32,28 @@ async function git(cwd: string, args: string[]): Promise<string> {});}+async function startSshEnvLabFixtureOrSkip(statePath: string, label: string) {+ if (sshEnvLabUnsupportedReason) {+ console.warn(`Skipping ${label}: ${sshEnvLabUnsupportedReason}`);+ return null;+ }++ const support = await getSshEnvLabSupport();+ if (!support.supported) {+ sshEnvLabUnsupportedReason = support.reason ?? "unsupported environment";+ console.warn(`Skipping ${label}: ${sshEnvLabUnsupportedReason}`);+ return null;+ }++ try {+ return await startSshEnvLabFixture({ statePath });+ } catch (error) {+ sshEnvLabUnsupportedReason = error instanceof Error ? error.message : String(error);+ console.warn(`Skipping ${label}: ${sshEnvLabUnsupportedReason}`);+ return null;+ }+}+describe("ssh env-lab fixture", () => {const cleanupDirs: string[] = [];@@ -41,24 +66,17 @@ describe("ssh env-lab fixture", () => {});it("starts an isolated sshd fixture and executes commands through it", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH env-lab fixture test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH env-lab fixture test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const quotedWorkspace = JSON.stringify(started.workspaceDir);const result = await runSshCommand(config,- `sh -lc 'cd ${quotedWorkspace} && pwd'`,+ `cd ${quotedWorkspace} && pwd`,);expect(result.stdout.trim()).toBe(started.workspaceDir);@@ -69,28 +87,21 @@ describe("ssh env-lab fixture", () => {const stopped = await readSshEnvLabFixtureStatus(statePath);expect(stopped.running).toBe(false);- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("forwards stdin to remote SSH commands", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH stdin forwarding test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH stdin forwarding test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const remotePath = path.posix.join(started.workspaceDir, "stdin-forwarded.txt");await runSshCommand(config,- `sh -lc 'cat > ${JSON.stringify(remotePath)}'`,+ `cat > ${JSON.stringify(remotePath)}`,{stdin: "hello over ssh stdin\n",timeoutMs: 30_000,@@ -100,27 +111,20 @@ describe("ssh env-lab fixture", () => {const result = await runSshCommand(config,- `sh -lc 'cat ${JSON.stringify(remotePath)}'`,+ `cat ${JSON.stringify(remotePath)}`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);expect(result.stdout).toBe("hello over ssh stdin\n");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("does not treat an unrelated reused pid as the running fixture", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH env-lab fixture test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH env-lab fixture test");+ if (!started) return;await stopSshEnvLabFixture(statePath);await mkdir(path.dirname(statePath), { recursive: true });@@ -133,11 +137,12 @@ describe("ssh env-lab fixture", () => {const staleStatus = await readSshEnvLabFixtureStatus(statePath);expect(staleStatus.running).toBe(false);- const restarted = await startSshEnvLabFixture({ statePath });+ const restarted = await startSshEnvLabFixtureOrSkip(statePath, "SSH env-lab fixture restart test");+ if (!restarted) return;expect(restarted.pid).not.toBe(process.pid);await stopSshEnvLabFixture(statePath);- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("rejects invalid environment variable keys when constructing SSH spawn targets", async () => {await expect(@@ -162,14 +167,6 @@ describe("ssh env-lab fixture", () => {});it("syncs a local directory into the remote fixture workspace", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH env-lab fixture test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");@@ -179,7 +176,8 @@ describe("ssh env-lab fixture", () => {await writeFile(path.join(localDir, "message.txt"), "hello from paperclip\n", "utf8");await writeFile(path.join(localDir, "._message.txt"), "should never sync\n", "utf8");- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH env-lab fixture test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const remoteDir = path.posix.join(started.workspaceDir, "overlay");@@ -194,22 +192,14 @@ describe("ssh env-lab fixture", () => {const result = await runSshCommand(config,- `sh -lc 'cat ${JSON.stringify(path.posix.join(remoteDir, "message.txt"))} && if [ -e ${JSON.stringify(path.posix.join(remoteDir, "._message.txt"))} ]; then echo appledouble-present; fi'`,+ `cat ${JSON.stringify(path.posix.join(remoteDir, "message.txt"))} && if [ -e ${JSON.stringify(path.posix.join(remoteDir, "._message.txt"))} ]; then echo appledouble-present; fi`,);expect(result.stdout).toContain("hello from paperclip");expect(result.stdout).not.toContain("appledouble-present");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("can dereference local symlinks while syncing to the remote fixture", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH symlink sync test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");@@ -221,7 +211,8 @@ describe("ssh env-lab fixture", () => {await writeFile(path.join(sourceDir, "auth.json"), "{\"token\":\"secret\"}\n", "utf8");await symlink(path.join(sourceDir, "auth.json"), path.join(localDir, "auth.json"));- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH symlink sync test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const remoteDir = path.posix.join(started.workspaceDir, "overlay-follow-links");@@ -237,29 +228,22 @@ describe("ssh env-lab fixture", () => {const result = await runSshCommand(config,- `sh -lc 'if [ -L ${JSON.stringify(path.posix.join(remoteDir, "auth.json"))} ]; then echo symlink; else echo regular; fi && cat ${JSON.stringify(path.posix.join(remoteDir, "auth.json"))}'`,+ `if [ -L ${JSON.stringify(path.posix.join(remoteDir, "auth.json"))} ]; then echo symlink; else echo regular; fi && cat ${JSON.stringify(path.posix.join(remoteDir, "auth.json"))}`,);expect(result.stdout).toContain("regular");expect(result.stdout).toContain("{\"token\":\"secret\"}");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("round-trips a git workspace through the SSH fixture", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping SSH workspace round-trip test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");const localRepo = path.join(rootDir, "local-workspace");await mkdir(localRepo, { recursive: true });- await git(localRepo, ["init", "-b", "main"]);+ await git(localRepo, ["init"]);+ await git(localRepo, ["checkout", "-b", "main"]);await git(localRepo, ["config", "user.name", "Paperclip Test"]);await git(localRepo, ["config", "user.email", "[email protected]"]);await writeFile(path.join(localRepo, "tracked.txt"), "base\n", "utf8");@@ -270,7 +254,8 @@ describe("ssh env-lab fixture", () => {await writeFile(path.join(localRepo, "tracked.txt"), "dirty local\n", "utf8");await writeFile(path.join(localRepo, "untracked.txt"), "from local\n", "utf8");- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "SSH workspace round-trip test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const spec = {...config,@@ -285,7 +270,7 @@ describe("ssh env-lab fixture", () => {const remoteStatus = await runSshCommand(config,- `sh -lc 'cd ${JSON.stringify(started.workspaceDir)} && git status --short'`,+ `cd ${JSON.stringify(started.workspaceDir)} && git status --short`,);expect(remoteStatus.stdout).toContain("M tracked.txt");expect(remoteStatus.stdout).toContain("?? untracked.txt");@@ -293,7 +278,7 @@ describe("ssh env-lab fixture", () => {await runSshCommand(config,- `sh -lc 'cd ${JSON.stringify(started.workspaceDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && git add tracked.txt untracked.txt && git commit -m "remote update" >/dev/null && printf "remote dirty\\n" > tracked.txt && printf "remote extra\\n" > remote-only.txt'`,+ `cd ${JSON.stringify(started.workspaceDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && git add tracked.txt untracked.txt && git commit -m "remote update" >/dev/null && printf "remote dirty\\n" > tracked.txt && printf "remote extra\\n" > remote-only.txt`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);@@ -308,31 +293,25 @@ describe("ssh env-lab fixture", () => {expect(await git(localRepo, ["log", "-1", "--pretty=%s"])).toBe("remote update");expect(await git(localRepo, ["status", "--short"])).toContain("M tracked.txt");expect(await git(localRepo, ["status", "--short"])).not.toContain("._tracked.txt");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("preserves both concurrent SSH restores in a shared git workspace", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping concurrent SSH restore test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");const localRepo = path.join(rootDir, "local-workspace");await mkdir(localRepo, { recursive: true });- await git(localRepo, ["init", "-b", "main"]);+ await git(localRepo, ["init"]);+ await git(localRepo, ["checkout", "-b", "main"]);await git(localRepo, ["config", "user.name", "Paperclip Test"]);await git(localRepo, ["config", "user.email", "[email protected]"]);await writeFile(path.join(localRepo, "tracked.txt"), "base\n", "utf8");await git(localRepo, ["add", "tracked.txt"]);await git(localRepo, ["commit", "-m", "initial"]);- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "concurrent SSH restore test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const spec = {...config,@@ -356,12 +335,12 @@ describe("ssh env-lab fixture", () => {await runSshCommand(config,- `sh -lc 'printf "from run a\\n" > ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "run-a.txt"))}'`,+ `printf "from run a\\n" > ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "run-a.txt"))}`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);await runSshCommand(config,- `sh -lc 'printf "from run b\\n" > ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "run-b.txt"))}'`,+ `printf "from run b\\n" > ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "run-b.txt"))}`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);@@ -372,31 +351,25 @@ describe("ssh env-lab fixture", () => {await expect(readFile(path.join(localRepo, "run-a.txt"), "utf8")).resolves.toBe("from run a\n");await expect(readFile(path.join(localRepo, "run-b.txt"), "utf8")).resolves.toBe("from run b\n");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("preserves nested per-run files across sequential SSH restores with stale baselines", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping sequential nested SSH restore test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");const localRepo = path.join(rootDir, "local-workspace");await mkdir(localRepo, { recursive: true });- await git(localRepo, ["init", "-b", "main"]);+ await git(localRepo, ["init"]);+ await git(localRepo, ["checkout", "-b", "main"]);await git(localRepo, ["config", "user.name", "Paperclip Test"]);await git(localRepo, ["config", "user.email", "[email protected]"]);await writeFile(path.join(localRepo, "tracked.txt"), "base\n", "utf8");await git(localRepo, ["add", "tracked.txt"]);await git(localRepo, ["commit", "-m", "initial"]);- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "sequential nested SSH restore test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const spec = {...config,@@ -418,12 +391,12 @@ describe("ssh env-lab fixture", () => {await runSshCommand(config,- `sh -lc 'mkdir -p ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "manual-qa/environment-matrix/ssh"))} && printf "from run a\\n" > ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "manual-qa/environment-matrix/ssh/claude_local.md"))}'`,+ `mkdir -p ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "manual-qa/environment-matrix/ssh"))} && printf "from run a\\n" > ${JSON.stringify(path.posix.join(preparedA.workspaceRemoteDir, "manual-qa/environment-matrix/ssh/claude_local.md"))}`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);await runSshCommand(config,- `sh -lc 'mkdir -p ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "manual-qa/environment-matrix/ssh"))} && printf "from run b\\n" > ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "manual-qa/environment-matrix/ssh/codex_local.md"))}'`,+ `mkdir -p ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "manual-qa/environment-matrix/ssh"))} && printf "from run b\\n" > ${JSON.stringify(path.posix.join(preparedB.workspaceRemoteDir, "manual-qa/environment-matrix/ssh/codex_local.md"))}`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);@@ -434,31 +407,25 @@ describe("ssh env-lab fixture", () => {.toBe("from run a\n");await expect(readFile(path.join(localRepo, "manual-qa/environment-matrix/ssh/codex_local.md"), "utf8")).resolves.toBe("from run b\n");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("round-trips remote git commits through the managed runtime restore path", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping managed-runtime SSH git round-trip test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");const localRepo = path.join(rootDir, "local-workspace");await mkdir(localRepo, { recursive: true });- await git(localRepo, ["init", "-b", "main"]);+ await git(localRepo, ["init"]);+ await git(localRepo, ["checkout", "-b", "main"]);await git(localRepo, ["config", "user.name", "Paperclip Test"]);await git(localRepo, ["config", "user.email", "[email protected]"]);await writeFile(path.join(localRepo, "tracked.txt"), "base\n", "utf8");await git(localRepo, ["add", "tracked.txt"]);await git(localRepo, ["commit", "-m", "initial"]);- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "managed-runtime SSH git round-trip test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const spec = {...config,@@ -474,7 +441,7 @@ describe("ssh env-lab fixture", () => {await runSshCommand(config,- `sh -lc 'cd ${JSON.stringify(prepared.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "committed\\n" > tracked.txt && git add tracked.txt && git commit -m "remote update" >/dev/null && printf "dirty remote\\n" > tracked.txt'`,+ `cd ${JSON.stringify(prepared.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "committed\\n" > tracked.txt && git add tracked.txt && git commit -m "remote update" >/dev/null && printf "dirty remote\\n" > tracked.txt`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);@@ -482,31 +449,25 @@ describe("ssh env-lab fixture", () => {expect(await git(localRepo, ["log", "-1", "--pretty=%s"])).toBe("remote update");await expect(readFile(path.join(localRepo, "tracked.txt"), "utf8")).resolves.toBe("dirty remote\n");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);it("merges concurrent remote commits through the managed runtime restore path", async () => {- const support = await getSshEnvLabSupport();- if (!support.supported) {- console.warn(- `Skipping concurrent managed-runtime SSH git merge test: ${support.reason ?? "unsupported environment"}`,- );- return;- }-const rootDir = await mkdtemp(path.join(os.tmpdir(), "paperclip-ssh-fixture-"));cleanupDirs.push(rootDir);const statePath = path.join(rootDir, "state.json");const localRepo = path.join(rootDir, "local-workspace");await mkdir(localRepo, { recursive: true });- await git(localRepo, ["init", "-b", "main"]);+ await git(localRepo, ["init"]);+ await git(localRepo, ["checkout", "-b", "main"]);await git(localRepo, ["config", "user.name", "Paperclip Test"]);await git(localRepo, ["config", "user.email", "[email protected]"]);await writeFile(path.join(localRepo, "tracked.txt"), "base\n", "utf8");await git(localRepo, ["add", "tracked.txt"]);await git(localRepo, ["commit", "-m", "initial"]);- const started = await startSshEnvLabFixture({ statePath });+ const started = await startSshEnvLabFixtureOrSkip(statePath, "concurrent managed-runtime SSH git merge test");+ if (!started) return;const config = await buildSshEnvLabFixtureConfig(started);const spec = {...config,@@ -528,12 +489,12 @@ describe("ssh env-lab fixture", () => {await runSshCommand(config,- `sh -lc 'cd ${JSON.stringify(preparedA.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "from run a\\n" > run-a.txt && git add run-a.txt && git commit -m "remote update a" >/dev/null'`,+ `cd ${JSON.stringify(preparedA.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "from run a\\n" > run-a.txt && git add run-a.txt && git commit -m "remote update a" >/dev/null`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);await runSshCommand(config,- `sh -lc 'cd ${JSON.stringify(preparedB.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "from run b\\n" > run-b.txt && git add run-b.txt && git commit -m "remote update b" >/dev/null'`,+ `cd ${JSON.stringify(preparedB.workspaceRemoteDir)} && git config user.name "Paperclip SSH" && git config user.email "[email protected]" && printf "from run b\\n" > run-b.txt && git add run-b.txt && git commit -m "remote update b" >/dev/null`,{ timeoutMs: 30_000, maxBuffer: 256 * 1024 },);@@ -549,5 +510,5 @@ describe("ssh env-lab fixture", () => {const recentSubjects = await git(localRepo, ["log", "--pretty=%s", "-3"]);expect(recentSubjects).toContain("remote update a");expect(recentSubjects).toContain("remote update b");- });+ }, SSH_FIXTURE_TEST_TIMEOUT_MS);});diff --git a/packages/adapter-utils/src/ssh.ts b/packages/adapter-utils/src/ssh.tsindex 96923a2845..abf1594012 100644--- a/packages/adapter-utils/src/ssh.ts+++ b/packages/adapter-utils/src/ssh.ts@@ -54,13 +54,11 @@ export function createSshCommandManagedRuntimeRunner(input: {? envEntries.map(([key, value]) => `export ${key}=${shellQuote(value)};`).join(" ") + " ": "";const commandScript = command === "sh" || command === "bash"- ? args[0] === "-lc" && typeof args[1] === "string"+ ? (args[0] === "-c" || args[0] === "-lc") && typeof args[1] === "string"? `${exportPrefix}${args[1]}`: `${envPrefix}exec ${[shellQuote(command), ...args.map((arg) => shellQuote(arg))].join(" ")}`: `${envPrefix}exec ${[shellQuote(command), ...args.map((arg) => shellQuote(arg))].join(" ")}`;- const remoteCommand = `${command === "bash" ? "bash" : "sh"} -lc ${- shellQuote(`cd ${shellQuote(cwd)} && ${commandScript}`)- }`;+ const remoteCommand = `cd ${shellQuote(cwd)} && ${commandScript}`;try {const result = await runSshCommand(input.spec, remoteCommand, {@@ -333,7 +331,7 @@ async function commandExists(command: string): Promise<boolean> {async function resolveCommandPath(command: string): Promise<string | null> {try {- const result = await execFileText("sh", ["-lc", `command -v ${shellQuote(command)}`], {+ const result = await execFileText("sh", ["-c", `command -v ${shellQuote(command)}`], {timeout: 5_000,maxBuffer: 8 * 1024,});@@ -421,7 +419,7 @@ async function runSshScript(): Promise<SshCommandResult> {return await runSshCommand(config,- `sh -lc ${shellQuote(script)}`,+ script,options,);}@@ -502,7 +500,7 @@ async function streamLocalFileToSsh(input: {"-p",String(input.spec.port),`${input.spec.username}@${input.spec.host}`,- `sh -lc ${shellQuote(input.remoteScript)}`,+ `sh -c ${shellQuote(input.remoteScript)}`,];await new Promise<void>((resolve, reject) => {@@ -551,7 +549,7 @@ async function streamSshToLocalFile(input: {"-p",String(input.spec.port),`${input.spec.username}@${input.spec.host}`,- `sh -lc ${shellQuote(input.remoteScript)}`,+ `sh -c ${shellQuote(input.remoteScript)}`,];await new Promise<void>((resolve, reject) => {@@ -889,6 +887,13 @@ async function isSshEnvLabFixtureProcess(state: Pick<SshEnvLabFixtureState, "pid}export async function getSshEnvLabSupport(): Promise<SshEnvLabSupport> {+ if (process.platform === "darwin" && process.env.PAPERCLIP_ENABLE_DARWIN_SSH_ENV_LAB !== "1") {+ return {+ supported: false,+ reason: "SSH env-lab fixture is disabled on macOS; set PAPERCLIP_ENABLE_DARWIN_SSH_ENV_LAB=1 to opt in.",+ };+ }+for (const command of ["ssh", "sshd", "ssh-keygen"]) {if (!(await commandExists(command))) {return {@@ -953,7 +958,7 @@ export async function runSshCommand("-p",String(config.port),`${config.username}@${config.host}`,- `sh -lc ${shellQuote(remoteScript)}`,+ `sh -c ${shellQuote(remoteScript)}`,);return options.stdin != null@@ -1008,7 +1013,7 @@ export async function buildSshSpawnTarget(input: {"-p",String(input.spec.port),`${input.spec.username}@${input.spec.host}`,- `sh -lc ${shellQuote(remoteScript)}`,+ `sh -c ${shellQuote(remoteScript)}`,);return {@@ -1031,7 +1036,7 @@ export async function syncDirectoryToSsh(input: {"-p",String(input.spec.port),`${input.spec.username}@${input.spec.host}`,- `sh -lc ${shellQuote(`mkdir -p ${shellQuote(input.remoteDir)} && tar -xf - -C ${shellQuote(input.remoteDir)}`)}`,+ `sh -c ${shellQuote(`mkdir -p ${shellQuote(input.remoteDir)} && tar -xf - -C ${shellQuote(input.remoteDir)}`)}`,];await new Promise<void>((resolve, reject) => {@@ -1127,7 +1132,7 @@ export async function syncDirectoryFromSsh(input: {"-p",String(input.spec.port),`${input.spec.username}@${input.spec.host}`,- `sh -lc ${shellQuote(remoteTarScript)}`,+ `sh -c ${shellQuote(remoteTarScript)}`,];try {@@ -1329,7 +1334,7 @@ export async function ensureSshWorkspaceReady(): Promise<{ remoteCwd: string }> {const result = await runSshCommand(config,- `sh -lc ${shellQuote(`mkdir -p ${shellQuote(config.remoteWorkspacePath)} && cd ${shellQuote(config.remoteWorkspacePath)} && pwd`)}`,+ `mkdir -p ${shellQuote(config.remoteWorkspacePath)} && cd ${shellQuote(config.remoteWorkspacePath)} && pwd`,);return {remoteCwd: result.stdout.trim(),diff --git a/packages/db/src/migrations/0082_dry_vision.sql b/packages/db/src/migrations/0082_dry_vision.sqlnew file mode 100644index 0000000000..e10e470e7a--- /dev/null+++ b/packages/db/src/migrations/0082_dry_vision.sql@@ -0,0 +1,124 @@+CREATE TABLE IF NOT EXISTS "company_secret_bindings" (+ "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,+ "company_id" uuid NOT NULL,+ "secret_id" uuid NOT NULL,+ "target_type" text NOT NULL,+ "target_id" text NOT NULL,+ "config_path" text NOT NULL,+ "version_selector" text DEFAULT 'latest' NOT NULL,+ "required" boolean DEFAULT true NOT NULL,+ "label" text,+ "created_at" timestamp with time zone DEFAULT now() NOT NULL,+ "updated_at" timestamp with time zone DEFAULT now() NOT NULL+);+--> statement-breakpoint+CREATE TABLE IF NOT EXISTS "secret_access_events" (+ "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,+ "company_id" uuid NOT NULL,+ "secret_id" uuid NOT NULL,+ "version" integer,+ "provider" text NOT NULL,+ "actor_type" text NOT NULL,+ "actor_id" text,+ "consumer_type" text NOT NULL,+ "consumer_id" text NOT NULL,+ "config_path" text,+ "issue_id" uuid,+ "heartbeat_run_id" uuid,+ "plugin_id" uuid,+ "outcome" text NOT NULL,+ "error_code" text,+ "created_at" timestamp with time zone DEFAULT now() NOT NULL+);+--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "key" text;--> statement-breakpoint+UPDATE "company_secrets"+SET "key" = left(+ regexp_replace(+ regexp_replace(lower(trim(coalesce("name", "id"::text))), '[^a-z0-9_.-]+', '-', 'g'),+ '^-+|-+$',+ '',+ 'g'+ ),+ 120+)+WHERE "key" IS NULL;--> statement-breakpoint+UPDATE "company_secrets"+SET "key" = "id"::text+WHERE "key" IS NULL OR "key" = '';--> statement-breakpoint+ALTER TABLE "company_secrets" ALTER COLUMN "key" SET NOT NULL;--> statement-breakpoint+WITH ranked AS (+ SELECT+ "id",+ "key",+ row_number() OVER (PARTITION BY "company_id", "key" ORDER BY "created_at", "id") AS rn+ FROM "company_secrets"+)+UPDATE "company_secrets"+SET "key" = left(ranked."key", 100) || '-' || ranked.rn::text+FROM ranked+WHERE "company_secrets"."id" = ranked."id"+ AND ranked.rn > 1;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "status" text DEFAULT 'active' NOT NULL;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "managed_mode" text DEFAULT 'paperclip_managed' NOT NULL;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "provider_config_id" text;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "provider_metadata" jsonb;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "last_resolved_at" timestamp with time zone;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "last_rotated_at" timestamp with time zone;--> statement-breakpoint+UPDATE "company_secrets"+SET "last_rotated_at" = "updated_at"+WHERE "last_rotated_at" IS NULL;--> statement-breakpoint+ALTER TABLE "company_secrets" ADD COLUMN IF NOT EXISTS "deleted_at" timestamp with time zone;--> statement-breakpoint+ALTER TABLE "company_secret_versions" ADD COLUMN IF NOT EXISTS "provider_version_ref" text;--> statement-breakpoint+ALTER TABLE "company_secret_versions" ADD COLUMN IF NOT EXISTS "status" text DEFAULT 'current' NOT NULL;--> statement-breakpoint+ALTER TABLE "company_secret_versions" ADD COLUMN IF NOT EXISTS "fingerprint_sha256" text;--> statement-breakpoint+UPDATE "company_secret_versions"+SET "fingerprint_sha256" = "value_sha256"+WHERE "fingerprint_sha256" IS NULL;--> statement-breakpoint+ALTER TABLE "company_secret_versions" ALTER COLUMN "fingerprint_sha256" SET NOT NULL;--> statement-breakpoint+ALTER TABLE "company_secret_versions" ADD COLUMN IF NOT EXISTS "rotation_job_id" text;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'company_secret_bindings_company_id_companies_id_fk') THEN+ ALTER TABLE "company_secret_bindings" ADD CONSTRAINT "company_secret_bindings_company_id_companies_id_fk" FOREIGN KEY ("company_id") REFERENCES "public"."companies"("id") ON DELETE no action ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'company_secret_bindings_secret_id_company_secrets_id_fk') THEN+ ALTER TABLE "company_secret_bindings" ADD CONSTRAINT "company_secret_bindings_secret_id_company_secrets_id_fk" FOREIGN KEY ("secret_id") REFERENCES "public"."company_secrets"("id") ON DELETE cascade ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'secret_access_events_company_id_companies_id_fk') THEN+ ALTER TABLE "secret_access_events" ADD CONSTRAINT "secret_access_events_company_id_companies_id_fk" FOREIGN KEY ("company_id") REFERENCES "public"."companies"("id") ON DELETE no action ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'secret_access_events_secret_id_company_secrets_id_fk') THEN+ ALTER TABLE "secret_access_events" ADD CONSTRAINT "secret_access_events_secret_id_company_secrets_id_fk" FOREIGN KEY ("secret_id") REFERENCES "public"."company_secrets"("id") ON DELETE cascade ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'secret_access_events_issue_id_issues_id_fk') THEN+ ALTER TABLE "secret_access_events" ADD CONSTRAINT "secret_access_events_issue_id_issues_id_fk" FOREIGN KEY ("issue_id") REFERENCES "public"."issues"("id") ON DELETE set null ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'secret_access_events_heartbeat_run_id_heartbeat_runs_id_fk') THEN+ ALTER TABLE "secret_access_events" ADD CONSTRAINT "secret_access_events_heartbeat_run_id_heartbeat_runs_id_fk" FOREIGN KEY ("heartbeat_run_id") REFERENCES "public"."heartbeat_runs"("id") ON DELETE set null ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'secret_access_events_plugin_id_plugins_id_fk') THEN+ ALTER TABLE "secret_access_events" ADD CONSTRAINT "secret_access_events_plugin_id_plugins_id_fk" FOREIGN KEY ("plugin_id") REFERENCES "public"."plugins"("id") ON DELETE set null ON UPDATE no action;+ END IF;+END $$;--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_bindings_company_idx" ON "company_secret_bindings" USING btree ("company_id");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_bindings_secret_idx" ON "company_secret_bindings" USING btree ("secret_id");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_bindings_target_idx" ON "company_secret_bindings" USING btree ("company_id","target_type","target_id");--> statement-breakpoint+CREATE UNIQUE INDEX IF NOT EXISTS "company_secret_bindings_target_path_uq" ON "company_secret_bindings" USING btree ("company_id","target_type","target_id","config_path");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "secret_access_events_company_created_idx" ON "secret_access_events" USING btree ("company_id","created_at");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "secret_access_events_secret_created_idx" ON "secret_access_events" USING btree ("secret_id","created_at");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "secret_access_events_consumer_idx" ON "secret_access_events" USING btree ("company_id","consumer_type","consumer_id");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "secret_access_events_run_idx" ON "secret_access_events" USING btree ("heartbeat_run_id");--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_versions_fingerprint_idx" ON "company_secret_versions" USING btree ("fingerprint_sha256");--> statement-breakpoint+CREATE UNIQUE INDEX IF NOT EXISTS "company_secrets_company_key_uq" ON "company_secrets" USING btree ("company_id","key");diff --git a/packages/db/src/migrations/0083_company_secret_provider_configs.sql b/packages/db/src/migrations/0083_company_secret_provider_configs.sqlnew file mode 100644index 0000000000..b3426f5296--- /dev/null+++ b/packages/db/src/migrations/0083_company_secret_provider_configs.sql@@ -0,0 +1,51 @@+CREATE TABLE IF NOT EXISTS "company_secret_provider_configs" (+ "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,+ "company_id" uuid NOT NULL,+ "provider" text NOT NULL,+ "display_name" text NOT NULL,+ "status" text DEFAULT 'ready' NOT NULL,+ "is_default" boolean DEFAULT false NOT NULL,+ "config" jsonb DEFAULT '{}'::jsonb NOT NULL,+ "health_status" text,+ "health_checked_at" timestamp with time zone,+ "health_message" text,+ "health_details" jsonb,+ "disabled_at" timestamp with time zone,+ "created_by_agent_id" uuid,+ "created_by_user_id" text,+ "created_at" timestamp with time zone DEFAULT now() NOT NULL,+ "updated_at" timestamp with time zone DEFAULT now() NOT NULL+);+--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'company_secret_provider_configs_company_id_companies_id_fk') THEN+ ALTER TABLE "company_secret_provider_configs" ADD CONSTRAINT "company_secret_provider_configs_company_id_companies_id_fk" FOREIGN KEY ("company_id") REFERENCES "public"."companies"("id") ON DELETE cascade ON UPDATE no action;+ END IF;+END $$;+--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'company_secret_provider_configs_created_by_agent_id_agents_id_fk') THEN+ ALTER TABLE "company_secret_provider_configs" ADD CONSTRAINT "company_secret_provider_configs_created_by_agent_id_agents_id_fk" FOREIGN KEY ("created_by_agent_id") REFERENCES "public"."agents"("id") ON DELETE set null ON UPDATE no action;+ END IF;+END $$;+--> statement-breakpoint+UPDATE "company_secrets"+SET "provider_config_id" = NULL+WHERE "provider_config_id" IS NOT NULL+ AND "provider_config_id" !~* '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$';+--> statement-breakpoint+ALTER TABLE "company_secrets" ALTER COLUMN "provider_config_id" TYPE uuid USING "provider_config_id"::uuid;+--> statement-breakpoint+DO $$ BEGIN+ IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'company_secrets_provider_config_id_company_secret_provider_configs_id_fk') THEN+ ALTER TABLE "company_secrets" ADD CONSTRAINT "company_secrets_provider_config_id_company_secret_provider_configs_id_fk" FOREIGN KEY ("provider_config_id") REFERENCES "public"."company_secret_provider_configs"("id") ON DELETE set null ON UPDATE no action;+ END IF;+END $$;+--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_provider_configs_company_idx" ON "company_secret_provider_configs" USING btree ("company_id");+--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secret_provider_configs_company_provider_idx" ON "company_secret_provider_configs" USING btree ("company_id","provider");+--> statement-breakpoint+CREATE UNIQUE INDEX IF NOT EXISTS "company_secret_provider_configs_default_uq" ON "company_secret_provider_configs" USING btree ("company_id","provider") WHERE "is_default" = true;+--> statement-breakpoint+CREATE INDEX IF NOT EXISTS "company_secrets_provider_config_idx" ON "company_secrets" USING btree ("provider_config_id");diff --git a/packages/db/src/migrations/meta/_journal.json b/packages/db/src/migrations/meta/_journal.jsonindex 418bb6e6bd..74214acd95 100644--- a/packages/db/src/migrations/meta/_journal.json+++ b/packages/db/src/migrations/meta/_journal.json@@ -575,6 +575,20 @@"when": 1778067785040,"tag": "0081_optimal_dormammu","breakpoints": true+ },+ {+ "idx": 82,+ "version": "7",+ "when": 1778067785041,+ "tag": "0082_dry_vision",+ "breakpoints": true+ },+ {+ "idx": 83,+ "version": "7",+ "when": 1778074536410,+ "tag": "0083_company_secret_provider_configs",+ "breakpoints": true}]}diff --git a/packages/db/src/schema/company_secret_bindings.ts b/packages/db/src/schema/company_secret_bindings.tsnew file mode 100644index 0000000000..06f926914a--- /dev/null+++ b/packages/db/src/schema/company_secret_bindings.ts@@ -0,0 +1,31 @@+import { boolean, index, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";+import { companies } from "./companies.js";+import { companySecrets } from "./company_secrets.js";++export const companySecretBindings = pgTable(+ "company_secret_bindings",+ {+ id: uuid("id").primaryKey().defaultRandom(),+ companyId: uuid("company_id").notNull().references(() => companies.id),+ secretId: uuid("secret_id").notNull().references(() => companySecrets.id, { onDelete: "cascade" }),+ targetType: text("target_type").notNull(),+ targetId: text("target_id").notNull(),+ configPath: text("config_path").notNull(),+ versionSelector: text("version_selector").notNull().default("latest"),+ required: boolean("required").notNull().default(true),+ label: text("label"),+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),+ updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),+ },+ (table) => ({+ companyIdx: index("company_secret_bindings_company_idx").on(table.companyId),+ secretIdx: index("company_secret_bindings_secret_idx").on(table.secretId),+ targetIdx: index("company_secret_bindings_target_idx").on(table.companyId, table.targetType, table.targetId),+ targetPathUq: uniqueIndex("company_secret_bindings_target_path_uq").on(+ table.companyId,+ table.targetType,+ table.targetId,+ table.configPath,+ ),+ }),+);diff --git a/packages/db/src/schema/company_secret_provider_configs.ts b/packages/db/src/schema/company_secret_provider_configs.tsnew file mode 100644index 0000000000..4f877b62af--- /dev/null+++ b/packages/db/src/schema/company_secret_provider_configs.ts@@ -0,0 +1,33 @@+import { sql } from "drizzle-orm";+import { pgTable, uuid, text, timestamp, jsonb, index, uniqueIndex, boolean } from "drizzle-orm/pg-core";+import { companies } from "./companies.js";+import { agents } from "./agents.js";++export const companySecretProviderConfigs = pgTable(+ "company_secret_provider_configs",+ {+ id: uuid("id").primaryKey().defaultRandom(),+ companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),+ provider: text("provider").notNull(),+ displayName: text("display_name").notNull(),+ status: text("status").notNull().default("ready"),+ isDefault: boolean("is_default").notNull().default(false),+ config: jsonb("config").$type<Record<string, unknown>>().notNull().default({}),+ healthStatus: text("health_status"),+ healthCheckedAt: timestamp("health_checked_at", { withTimezone: true }),+ healthMessage: text("health_message"),+ healthDetails: jsonb("health_details").$type<Record<string, unknown>>(),+ disabledAt: timestamp("disabled_at", { withTimezone: true }),+ createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),+ createdByUserId: text("created_by_user_id"),+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),+ updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),+ },+ (table) => ({+ companyIdx: index("company_secret_provider_configs_company_idx").on(table.companyId),+ companyProviderIdx: index("company_secret_provider_configs_company_provider_idx").on(table.companyId, table.provider),+ companyDefaultProviderUq: uniqueIndex("company_secret_provider_configs_default_uq")+ .on(table.companyId, table.provider)+ .where(sql`${table.isDefault} = true`),+ }),+);diff --git a/packages/db/src/schema/company_secret_versions.ts b/packages/db/src/schema/company_secret_versions.tsindex c17426e654..899e8fdffd 100644--- a/packages/db/src/schema/company_secret_versions.ts+++ b/packages/db/src/schema/company_secret_versions.ts@@ -10,6 +10,10 @@ export const companySecretVersions = pgTable(version: integer("version").notNull(),material: jsonb("material").$type<Record<string, unknown>>().notNull(),valueSha256: text("value_sha256").notNull(),+ providerVersionRef: text("provider_version_ref"),+ status: text("status").notNull().default("current"),+ fingerprintSha256: text("fingerprint_sha256").notNull(),+ rotationJobId: text("rotation_job_id"),createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),createdByUserId: text("created_by_user_id"),createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),@@ -18,6 +22,7 @@ export const companySecretVersions = pgTable((table) => ({secretIdx: index("company_secret_versions_secret_idx").on(table.secretId, table.createdAt),valueHashIdx: index("company_secret_versions_value_sha256_idx").on(table.valueSha256),+ fingerprintIdx: index("company_secret_versions_fingerprint_idx").on(table.fingerprintSha256),secretVersionUq: uniqueIndex("company_secret_versions_secret_version_uq").on(table.secretId, table.version),}),);diff --git a/packages/db/src/schema/company_secrets.ts b/packages/db/src/schema/company_secrets.tsindex ec8c595d8a..9499d20cc8 100644--- a/packages/db/src/schema/company_secrets.ts+++ b/packages/db/src/schema/company_secrets.ts@@ -1,17 +1,26 @@-import { pgTable, uuid, text, timestamp, integer, index, uniqueIndex } from "drizzle-orm/pg-core";+import { pgTable, uuid, text, timestamp, integer, jsonb, index, uniqueIndex } from "drizzle-orm/pg-core";import { companies } from "./companies.js";import { agents } from "./agents.js";+import { companySecretProviderConfigs } from "./company_secret_provider_configs.js";export const companySecrets = pgTable("company_secrets",{id: uuid("id").primaryKey().defaultRandom(),companyId: uuid("company_id").notNull().references(() => companies.id),+ key: text("key").notNull(),name: text("name").notNull(),provider: text("provider").notNull().default("local_encrypted"),+ status: text("status").notNull().default("active"),+ managedMode: text("managed_mode").notNull().default("paperclip_managed"),externalRef: text("external_ref"),+ providerConfigId: uuid("provider_config_id").references(() => companySecretProviderConfigs.id, { onDelete: "set null" }),+ providerMetadata: jsonb("provider_metadata").$type<Record<string, unknown>>(),latestVersion: integer("latest_version").notNull().default(1),description: text("description"),+ lastResolvedAt: timestamp("last_resolved_at", { withTimezone: true }),+ lastRotatedAt: timestamp("last_rotated_at", { withTimezone: true }),+ deletedAt: timestamp("deleted_at", { withTimezone: true }),createdByAgentId: uuid("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),createdByUserId: text("created_by_user_id"),createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),@@ -20,6 +29,8 @@ export const companySecrets = pgTable((table) => ({companyIdx: index("company_secrets_company_idx").on(table.companyId),companyProviderIdx: index("company_secrets_company_provider_idx").on(table.companyId, table.provider),+ providerConfigIdx: index("company_secrets_provider_config_idx").on(table.providerConfigId),companyNameUq: uniqueIndex("company_secrets_company_name_uq").on(table.companyId, table.name),+ companyKeyUq: uniqueIndex("company_secrets_company_key_uq").on(table.companyId, table.key),}),);diff --git a/packages/db/src/schema/index.ts b/packages/db/src/schema/index.tsindex 67308bd035..9099f9044c 100644--- a/packages/db/src/schema/index.ts+++ b/packages/db/src/schema/index.ts@@ -59,8 +59,11 @@ export { financeEvents } from "./finance_events.js";export { approvals } from "./approvals.js";export { approvalComments } from "./approval_comments.js";export { activityLog } from "./activity_log.js";+export { companySecretProviderConfigs } from "./company_secret_provider_configs.js";export { companySecrets } from "./company_secrets.js";export { companySecretVersions } from "./company_secret_versions.js";+export { companySecretBindings } from "./company_secret_bindings.js";+export { secretAccessEvents } from "./secret_access_events.js";export { companySkills } from "./company_skills.js";export { plugins } from "./plugins.js";export { pluginConfig } from "./plugin_config.js";diff --git a/packages/db/src/schema/secret_access_events.ts b/packages/db/src/schema/secret_access_events.tsnew file mode 100644index 0000000000..b4967f13fd--- /dev/null+++ b/packages/db/src/schema/secret_access_events.ts@@ -0,0 +1,34 @@+import { index, integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";+import { companies } from "./companies.js";+import { companySecrets } from "./company_secrets.js";+import { heartbeatRuns } from "./heartbeat_runs.js";+import { issues } from "./issues.js";+import { plugins } from "./plugins.js";++export const secretAccessEvents = pgTable(+ "secret_access_events",+ {+ id: uuid("id").primaryKey().defaultRandom(),+ companyId: uuid("company_id").notNull().references(() => companies.id),+ secretId: uuid("secret_id").notNull().references(() => companySecrets.id, { onDelete: "cascade" }),+ version: integer("version"),+ provider: text("provider").notNull(),+ actorType: text("actor_type").notNull(),+ actorId: text("actor_id"),+ consumerType: text("consumer_type").notNull(),+ consumerId: text("consumer_id").notNull(),+ configPath: text("config_path"),+ issueId: uuid("issue_id").references(() => issues.id, { onDelete: "set null" }),+ heartbeatRunId: uuid("heartbeat_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),+ pluginId: uuid("plugin_id").references(() => plugins.id, { onDelete: "set null" }),+ outcome: text("outcome").notNull(),+ errorCode: text("error_code"),+ createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),+ },+ (table) => ({+ companyCreatedIdx: index("secret_access_events_company_created_idx").on(table.companyId, table.createdAt),+ secretCreatedIdx: index("secret_access_events_secret_created_idx").on(table.secretId, table.createdAt),+ consumerIdx: index("secret_access_events_consumer_idx").on(table.companyId, table.consumerType, table.consumerId),+ runIdx: index("secret_access_events_run_idx").on(table.heartbeatRunId),+ }),+);diff --git a/packages/shared/src/api.ts b/packages/shared/src/api.tsindex eef841f234..38988c6fc2 100644--- a/packages/shared/src/api.ts+++ b/packages/shared/src/api.ts@@ -11,6 +11,7 @@ export const API = {goals: `${API_PREFIX}/goals`,approvals: `${API_PREFIX}/approvals`,secrets: `${API_PREFIX}/secrets`,+ secretProviderConfigs: `${API_PREFIX}/secret-provider-configs`,costs: `${API_PREFIX}/costs`,activity: `${API_PREFIX}/activity`,dashboard: `${API_PREFIX}/dashboard`,diff --git a/packages/shared/src/constants.ts b/packages/shared/src/constants.tsindex 12cf3b0a53..640f7563c0 100644--- a/packages/shared/src/constants.ts+++ b/packages/shared/src/constants.ts@@ -395,6 +395,54 @@ export const SECRET_PROVIDERS = [] as const;export type SecretProvider = (typeof SECRET_PROVIDERS)[number];+export const SECRET_PROVIDER_CONFIG_STATUSES = [+ "ready",+ "warning",+ "coming_soon",+ "disabled",+] as const;+export type SecretProviderConfigStatus = (typeof SECRET_PROVIDER_CONFIG_STATUSES)[number];++export const SECRET_PROVIDER_CONFIG_HEALTH_STATUSES = [+ "ready",+ "warning",+ "error",+ "coming_soon",+ "disabled",+] as const;+export type SecretProviderConfigHealthStatus =+ (typeof SECRET_PROVIDER_CONFIG_HEALTH_STATUSES)[number];++export const SECRET_STATUSES = ["active", "disabled", "archived", "deleted"] as const;+export type SecretStatus = (typeof SECRET_STATUSES)[number];++export const SECRET_MANAGED_MODES = ["paperclip_managed", "external_reference"] as const;+export type SecretManagedMode = (typeof SECRET_MANAGED_MODES)[number];++export const SECRET_VERSION_STATUSES = [+ "current",+ "previous",+ "disabled",+ "destroyed",+ "failed",+] as const;+export type SecretVersionStatus = (typeof SECRET_VERSION_STATUSES)[number];++export const SECRET_BINDING_TARGET_TYPES = [+ "agent",+ "project",+ "environment",+ "routine",+ "plugin",+ "issue",+ "run",+ "system",+] as const;+export type SecretBindingTargetType = (typeof SECRET_BINDING_TARGET_TYPES)[number];++export const SECRET_ACCESS_OUTCOMES = ["success", "failure"] as const;+export type SecretAccessOutcome = (typeof SECRET_ACCESS_OUTCOMES)[number];+export const STORAGE_PROVIDERS = ["local_disk", "s3"] as const;export type StorageProvider = (typeof STORAGE_PROVIDERS)[number];diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.tsindex 9908db17a3..2239bbf4cb 100644--- a/packages/shared/src/index.ts+++ b/packages/shared/src/index.ts@@ -71,6 +71,8 @@ export {APPROVAL_TYPES,APPROVAL_STATUSES,SECRET_PROVIDERS,+ SECRET_PROVIDER_CONFIG_STATUSES,+ SECRET_PROVIDER_CONFIG_HEALTH_STATUSES,STORAGE_PROVIDERS,BILLING_TYPES,FINANCE_EVENT_KINDS,@@ -182,6 +184,8 @@ export {type ApprovalType,type ApprovalStatus,type SecretProvider,+ type SecretProviderConfigStatus,+ type SecretProviderConfigHealthStatus,type StorageProvider,type BillingType,type FinanceEventKind,@@ -530,7 +534,29 @@ export type {EnvBinding,AgentEnvConfig,CompanySecret,+ CompanySecretProviderConfig,+ SecretProviderConfigPayload,+ SecretProviderConfigHealthDetails,+ SecretProviderConfigHealthResponse,+ CompanySecretBinding,+ CompanySecretBindingTarget,+ CompanySecretUsageBinding,+ CompanySecretVersion,+ SecretAccessEvent,+ RemoteSecretImportCandidate,+ RemoteSecretImportCandidateStatus,+ RemoteSecretImportConflict,+ RemoteSecretImportPreviewResult,+ RemoteSecretImportResult,+ RemoteSecretImportRowResult,+ RemoteSecretImportRowStatus,+ SecretAccessOutcome,+ SecretBindingTargetType,+ SecretManagedMode,SecretProviderDescriptor,+ SecretStatus,+ SecretVersionSelector,+ SecretVersionStatus,Routine,RoutineManagedByPlugin,RoutineVariable,@@ -826,7 +852,19 @@ export {envBindingSchema,envConfigSchema,createSecretSchema,+ createSecretProviderConfigSchema,+ updateSecretProviderConfigSchema,+ remoteSecretImportPreviewSchema,+ remoteSecretImportSchema,+ remoteSecretImportSelectionSchema,+ localEncryptedProviderConfigSchema,+ awsSecretsManagerProviderConfigSchema,+ gcpSecretManagerProviderConfigSchema,+ vaultProviderConfigSchema,+ secretProviderConfigPayloadSchema,+ createSecretBindingSchema,rotateSecretSchema,+ secretBindingTargetSchema,updateSecretSchema,createRoutineSchema,updateRoutineSchema,@@ -840,6 +878,11 @@ export {routineRevisionSnapshotV1Schema,routineRevisionSnapshotSchema,type CreateSecret,+ type CreateSecretProviderConfig,+ type UpdateSecretProviderConfig,+ type RemoteSecretImportPreview,+ type RemoteSecretImport,+ type RemoteSecretImportSelection,type RotateSecret,type UpdateSecret,type CreateRoutine,diff --git a/packages/shared/src/types/index.ts b/packages/shared/src/types/index.tsindex ddc8162d27..39ad1993c9 100644--- a/packages/shared/src/types/index.ts+++ b/packages/shared/src/types/index.ts@@ -244,7 +244,28 @@ export type {EnvBinding,AgentEnvConfig,CompanySecret,+ CompanySecretProviderConfig,+ SecretProviderConfigPayload,+ SecretProviderConfigHealthDetails,+ SecretProviderConfigHealthResponse,+ CompanySecretBinding,+ CompanySecretBindingTarget,+ CompanySecretUsageBinding,+ CompanySecretVersion,+ SecretAccessEvent,+ RemoteSecretImportCandidate,+ RemoteSecretImportCandidateStatus,+ RemoteSecretImportConflict,+ RemoteSecretImportPreviewResult,+ RemoteSecretImportResult,+ RemoteSecretImportRowResult,+ RemoteSecretImportRowStatus,+ SecretAccessOutcome,+ SecretBindingTargetType,+ SecretManagedMode,SecretProviderDescriptor,+ SecretStatus,+ SecretVersionStatus,} from "./secrets.js";export type {Routine,diff --git a/packages/shared/src/types/secrets.ts b/packages/shared/src/types/secrets.tsindex dc020e2b3d..7a4f0ae324 100644--- a/packages/shared/src/types/secrets.ts+++ b/packages/shared/src/types/secrets.ts@@ -1,8 +1,24 @@-export type SecretProvider =- | "local_encrypted"- | "aws_secrets_manager"- | "gcp_secret_manager"- | "vault";+import type {+ SecretAccessOutcome,+ SecretBindingTargetType,+ SecretManagedMode,+ SecretProvider,+ SecretProviderConfigHealthStatus,+ SecretProviderConfigStatus,+ SecretStatus,+ SecretVersionStatus,+} from "../constants.js";++export type {+ SecretAccessOutcome,+ SecretBindingTargetType,+ SecretManagedMode,+ SecretProvider,+ SecretProviderConfigHealthStatus,+ SecretProviderConfigStatus,+ SecretStatus,+ SecretVersionStatus,+};export type SecretVersionSelector = number | "latest";@@ -25,13 +41,22 @@ export type AgentEnvConfig = Record<string, EnvBinding>;export interface CompanySecret {id: string;companyId: string;+ key: string;name: string;provider: SecretProvider;+ status: SecretStatus;+ managedMode: SecretManagedMode;externalRef: string | null;+ providerConfigId: string | null;+ providerMetadata: Record<string, unknown> | null;latestVersion: number;description: string | null;+ lastResolvedAt: Date | null;+ lastRotatedAt: Date | null;+ deletedAt: Date | null;createdByAgentId: string | null;createdByUserId: string | null;+ referenceCount?: number;createdAt: Date;updatedAt: Date;}@@ -40,4 +65,180 @@ export interface SecretProviderDescriptor {id: SecretProvider;label: string;requiresExternalRef: boolean;+ supportsManagedValues?: boolean;+ supportsExternalReferences?: boolean;+ configured?: boolean;+}++export interface LocalEncryptedProviderConfig {+ backupReminderAcknowledged?: boolean;+}++export interface AwsSecretsManagerProviderConfig {+ region: string;+ namespace?: string | null;+ secretNamePrefix?: string | null;+ kmsKeyId?: string | null;+ ownerTag?: string | null;+ environmentTag?: string | null;+}++export interface GcpSecretManagerProviderConfig {+ projectId?: string | null;+ location?: string | null;+ namespace?: string | null;+ secretNamePrefix?: string | null;+}++export interface VaultProviderConfig {+ address?: string | null;+ namespace?: string | null;+ mountPath?: string | null;+ secretPathPrefix?: string | null;+}++export type SecretProviderConfigPayload =+ | LocalEncryptedProviderConfig+ | AwsSecretsManagerProviderConfig+ | GcpSecretManagerProviderConfig+ | VaultProviderConfig;++export interface SecretProviderConfigHealthDetails {+ code: string;+ message: string;+ missingFields?: string[];+ guidance?: string[];+}++export interface CompanySecretProviderConfig {+ id: string;+ companyId: string;+ provider: SecretProvider;+ displayName: string;+ status: SecretProviderConfigStatus;+ isDefault: boolean;+ config: SecretProviderConfigPayload;+ healthStatus: SecretProviderConfigHealthStatus | null;+ healthCheckedAt: Date | null;+ healthMessage: string | null;+ healthDetails: SecretProviderConfigHealthDetails | null;+ disabledAt: Date | null;+ createdByAgentId: string | null;+ createdByUserId: string | null;+ createdAt: Date;+ updatedAt: Date;+}++export interface SecretProviderConfigHealthResponse {+ configId: string;+ provider: SecretProvider;+ status: SecretProviderConfigHealthStatus;+ message: string;+ details: SecretProviderConfigHealthDetails;+ checkedAt: Date;+}++export interface CompanySecretVersion {+ id: string;+ secretId: string;+ version: number;+ providerVersionRef: string | null;+ status: SecretVersionStatus;+ fingerprintSha256: string;+ rotationJobId: string | null;+ createdAt: Date;+ revokedAt: Date | null;+}++export interface CompanySecretBinding {+ id: string;+ companyId: string;+ secretId: string;+ targetType: SecretBindingTargetType;+ targetId: string;+ configPath: string;+ versionSelector: SecretVersionSelector;+ required: boolean;+ label: string | null;+ createdAt: Date;+ updatedAt: Date;+}++export interface CompanySecretBindingTarget {+ type: SecretBindingTargetType;+ id: string;+ label: string;+ href: string | null;+ status: string | null;+}++export interface CompanySecretUsageBinding extends CompanySecretBinding {+ target: CompanySecretBindingTarget;+}++export interface SecretAccessEvent {+ id: string;+ companyId: string;+ secretId: string;+ version: number | null;+ provider: SecretProvider;+ actorType: "agent" | "user" | "system" | "plugin";+ actorId: string | null;+ consumerType: SecretBindingTargetType;+ consumerId: string;+ configPath: string | null;+ issueId: string | null;+ heartbeatRunId: string | null;+ pluginId: string | null;+ outcome: SecretAccessOutcome;+ errorCode: string | null;+ createdAt: Date;+}++export type RemoteSecretImportCandidateStatus = "ready" | "duplicate" | "conflict";++export interface RemoteSecretImportConflict {+ type: "exact_reference" | "name" | "key" | "provider_guardrail";+ message: string;+ existingSecretId?: string;+}++export interface RemoteSecretImportCandidate {+ externalRef: string;+ remoteName: string;+ name: string;+ key: string;+ providerVersionRef: string | null;+ providerMetadata: Record<string, unknown> | null;+ status: RemoteSecretImportCandidateStatus;+ importable: boolean;+ conflicts: RemoteSecretImportConflict[];+}++export interface RemoteSecretImportPreviewResult {+ providerConfigId: string;+ provider: SecretProvider;+ nextToken: string | null;+ candidates: RemoteSecretImportCandidate[];+}++export type RemoteSecretImportRowStatus = "imported" | "skipped" | "error";++export interface RemoteSecretImportRowResult {+ externalRef: string;+ name: string;+ key: string;+ status: RemoteSecretImportRowStatus;+ reason: string | null;+ secretId: string | null;+ conflicts: RemoteSecretImportConflict[];+}++export interface RemoteSecretImportResult {+ providerConfigId: string;+ provider: SecretProvider;+ importedCount: number;+ skippedCount: number;+ errorCount: number;+ results: RemoteSecretImportRowResult[];}diff --git a/packages/shared/src/validators/index.ts b/packages/shared/src/validators/index.tsindex 5b89735d65..14b30989d1 100644--- a/packages/shared/src/validators/index.ts+++ b/packages/shared/src/validators/index.ts@@ -282,9 +282,27 @@ export {envBindingSchema,envConfigSchema,createSecretSchema,+ createSecretProviderConfigSchema,+ updateSecretProviderConfigSchema,+ remoteSecretImportPreviewSchema,+ remoteSecretImportSchema,+ remoteSecretImportSelectionSchema,+ localEncryptedProviderConfigSchema,+ awsSecretsManagerProviderConfigSchema,+ gcpSecretManagerProviderConfigSchema,+ vaultProviderConfigSchema,+ secretProviderConfigPayloadSchema,+ createSecretBindingSchema,rotateSecretSchema,+ secretBindingTargetSchema,updateSecretSchema,+ type CreateSecretBinding,type CreateSecret,+ type CreateSecretProviderConfig,+ type UpdateSecretProviderConfig,+ type RemoteSecretImportPreview,+ type RemoteSecretImport,+ type RemoteSecretImportSelection,type RotateSecret,type UpdateSecret,} from "./secret.js";diff --git a/packages/shared/src/validators/secret.test.ts b/packages/shared/src/validators/secret.test.tsnew file mode 100644index 0000000000..c8a8163d3d--- /dev/null+++ b/packages/shared/src/validators/secret.test.ts@@ -0,0 +1,157 @@+import { describe, expect, it } from "vitest";+import {+ createSecretProviderConfigSchema,+ createSecretSchema,+ remoteSecretImportPreviewSchema,+ remoteSecretImportSchema,+ secretProviderConfigPayloadSchema,+ updateSecretProviderConfigSchema,+} from "./secret.js";++describe("secret validators", () => {+ it("rejects externalRef on managed secrets", () => {+ expect(() =>+ createSecretSchema.parse({+ name: "OpenAI API Key",+ managedMode: "paperclip_managed",+ value: "secret-value",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/other",+ }),+ ).toThrow(/Managed secrets cannot set externalRef/);+ });++ it("allows externalRef on external reference secrets", () => {+ const parsed = createSecretSchema.parse({+ name: "Shared Secret",+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/other",+ });++ expect(parsed.externalRef).toContain(":secret:shared/other");+ });++ it("accepts non-sensitive local and AWS provider vault metadata", () => {+ expect(() =>+ createSecretProviderConfigSchema.parse({+ provider: "local_encrypted",+ displayName: "Local",+ config: { backupReminderAcknowledged: true },+ }),+ ).not.toThrow();++ expect(() =>+ createSecretProviderConfigSchema.parse({+ provider: "aws_secrets_manager",+ displayName: "AWS",+ config: {+ region: "us-east-1",+ namespace: "production",+ secretNamePrefix: "paperclip",+ },+ }),+ ).not.toThrow();+ });++ it("accepts origin-only Vault provider vault addresses", () => {+ expect(() =>+ createSecretProviderConfigSchema.parse({+ provider: "vault",+ displayName: "Vault draft",+ config: { address: " https://vault.example.com/ " },+ }),+ ).not.toThrow();++ const parsed = secretProviderConfigPayloadSchema.parse({+ provider: "vault",+ config: { address: " https://vault.example.com/ " },+ });++ expect(parsed.provider).toBe("vault");+ if (parsed.provider !== "vault") throw new Error("Expected vault provider payload");+ expect(parsed.config.address).toBe("https://vault.example.com");+ });++ it.each([+ "https://user:[email protected]",+ "https://vault.example.com?token=hvs.x",+ "https://vault.example.com#token=hvs.x",+ "https://vault.example.com/v1/secret",+ ])("rejects credential-bearing or non-origin Vault addresses: %s", (address) => {+ expect(() =>+ createSecretProviderConfigSchema.parse({+ provider: "vault",+ displayName: "Vault draft",+ config: { address },+ }),+ ).toThrow(/origin-only HTTP\(S\) URL/i);+ });++ it("rejects unsafe Vault addresses in provider payload validation used by updates", () => {+ expect(() =>+ secretProviderConfigPayloadSchema.parse({+ provider: "vault",+ config: { address: "https://vault.example.com?client_token=hvs.x" },+ }),+ ).toThrow(/origin-only HTTP\(S\) URL/i);+ });++ it("rejects unsafe Vault addresses in provider vault update payloads", () => {+ expect(() =>+ updateSecretProviderConfigSchema.parse({+ config: { address: "https://vault.example.com#token=hvs.x" },+ }),+ ).toThrow(/origin-only HTTP\(S\) URL/i);+ });++ it("validates AWS remote import preview and import payloads", () => {+ expect(+ remoteSecretImportPreviewSchema.parse({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ query: "openai",+ pageSize: 50,+ }),+ ).toEqual({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ query: "openai",+ pageSize: 50,+ });++ expect(+ remoteSecretImportSchema.parse({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "OPENAI_API_KEY",+ description: " Operator-entered Paperclip description ",+ providerMetadata: { name: "prod/openai" },+ },+ ],+ }),+ ).toMatchObject({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ secrets: [+ expect.objectContaining({+ key: "OPENAI_API_KEY",+ description: "Operator-entered Paperclip description",+ }),+ ],+ });+ });++ it("caps AWS remote import paging and row counts", () => {+ expect(() =>+ remoteSecretImportPreviewSchema.parse({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ pageSize: 101,+ }),+ ).toThrow();+ expect(() =>+ remoteSecretImportSchema.parse({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ secrets: [],+ }),+ ).toThrow();+ });+});diff --git a/packages/shared/src/validators/secret.ts b/packages/shared/src/validators/secret.tsindex fc2dba3c23..ae36461746 100644--- a/packages/shared/src/validators/secret.ts+++ b/packages/shared/src/validators/secret.ts@@ -1,5 +1,11 @@import { z } from "zod";-import { SECRET_PROVIDERS } from "../constants.js";+import {+ SECRET_BINDING_TARGET_TYPES,+ SECRET_MANAGED_MODES,+ SECRET_PROVIDER_CONFIG_STATUSES,+ SECRET_PROVIDERS,+ SECRET_STATUSES,+} from "../constants.js";export const envBindingPlainSchema = z.object({type: z.literal("plain"),@@ -23,25 +29,252 @@ export const envConfigSchema = z.record(envBindingSchema);export const createSecretSchema = z.object({name: z.string().min(1),+ key: z.string().min(1).regex(/^[a-zA-Z0-9_.-]+$/).optional(),provider: z.enum(SECRET_PROVIDERS).optional(),- value: z.string().min(1),+ providerConfigId: z.string().uuid().optional().nullable(),+ managedMode: z.enum(SECRET_MANAGED_MODES).optional(),+ value: z.string().min(1).optional().nullable(),description: z.string().optional().nullable(),externalRef: z.string().optional().nullable(),+ providerMetadata: z.record(z.unknown()).optional().nullable(),+ providerVersionRef: z.string().optional().nullable(),+}).superRefine((value, ctx) => {+ if ((value.managedMode ?? "paperclip_managed") === "external_reference") {+ if (!value.externalRef?.trim()) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["externalRef"],+ message: "External reference secrets require externalRef",+ });+ }+ return;+ }+ if (value.externalRef?.trim()) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["externalRef"],+ message: "Managed secrets cannot set externalRef",+ });+ }+ if (!value.value?.trim()) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["value"],+ message: "Managed secrets require value",+ });+ }});export type CreateSecret = z.infer<typeof createSecretSchema>;export const rotateSecretSchema = z.object({- value: z.string().min(1),+ value: z.string().min(1).optional().nullable(),externalRef: z.string().optional().nullable(),+ providerVersionRef: z.string().optional().nullable(),+ providerConfigId: z.string().uuid().optional().nullable(),});export type RotateSecret = z.infer<typeof rotateSecretSchema>;export const updateSecretSchema = z.object({name: z.string().min(1).optional(),+ key: z.string().min(1).regex(/^[a-zA-Z0-9_.-]+$/).optional(),+ status: z.enum(SECRET_STATUSES).optional(),+ providerConfigId: z.string().uuid().optional().nullable(),description: z.string().optional().nullable(),externalRef: z.string().optional().nullable(),+ providerMetadata: z.record(z.unknown()).optional().nullable(),});export type UpdateSecret = z.infer<typeof updateSecretSchema>;++export const secretBindingTargetSchema = z.object({+ targetType: z.enum(SECRET_BINDING_TARGET_TYPES),+ targetId: z.string().min(1),+ configPath: z.string().min(1),+});++export const createSecretBindingSchema = secretBindingTargetSchema.extend({+ secretId: z.string().uuid(),+ versionSelector: z.union([z.literal("latest"), z.number().int().positive()]).default("latest"),+ required: z.boolean().default(true),+ label: z.string().optional().nullable(),+});++export type CreateSecretBinding = z.infer<typeof createSecretBindingSchema>;++const safeShortText = z.string().trim().min(1).max(160);+const optionalSafeShortText = safeShortText.optional().nullable();++const deniedProviderConfigKeyPattern =+ /^(access[-_]?key([-_]?id)?|secret[-_]?access[-_]?key|secret[-_]?key|token|password|passwd|credential|credentials|private[-_]?key|pem|jwt|session[-_]?token|service[-_]?account([-_]?json)?|client[-_]?secret|secret[-_]?id|unseal[-_]?key|recovery[-_]?key|key[-_]?file([-_]?path)?|token[-_]?file([-_]?path)?)$/i;++function rejectSensitiveProviderConfigKeys(value: unknown, ctx: z.RefinementCtx) {+ if (!value || typeof value !== "object" || Array.isArray(value)) return;+ for (const key of Object.keys(value)) {+ if (!deniedProviderConfigKeyPattern.test(key)) continue;+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["config", key],+ message: `Provider vault config cannot persist sensitive field: ${key}`,+ });+ }+}++export const localEncryptedProviderConfigSchema = z.object({+ backupReminderAcknowledged: z.boolean().optional(),+}).strict();++export const awsSecretsManagerProviderConfigSchema = z.object({+ region: z.string().trim().regex(/^[a-z]{2}(?:-gov)?-[a-z]+-\d+$/, "Invalid AWS region"),+ namespace: optionalSafeShortText,+ secretNamePrefix: optionalSafeShortText,+ kmsKeyId: z.string().trim().min(1).max(512).optional().nullable(),+ ownerTag: optionalSafeShortText,+ environmentTag: optionalSafeShortText,+}).strict();++export const gcpSecretManagerProviderConfigSchema = z.object({+ projectId: z.string().trim().min(1).max(128).regex(/^[a-z][a-z0-9-]{4,127}$/).optional().nullable(),+ location: optionalSafeShortText,+ namespace: optionalSafeShortText,+ secretNamePrefix: optionalSafeShortText,+}).strict();++const vaultAddressSchema = z.preprocess(+ (value) => typeof value === "string" ? value.trim() : value,+ z.string().url().superRefine((value, ctx) => {+ let url: URL;+ try {+ url = new URL(value);+ } catch {+ return;+ }+ const hasPath = url.pathname !== "" && url.pathname !== "/";+ if (+ (url.protocol !== "http:" && url.protocol !== "https:") ||+ url.username ||+ url.password ||+ url.search ||+ url.hash ||+ hasPath+ ) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ message: "Vault address must be an origin-only HTTP(S) URL without credentials, path, query, or fragment",+ });+ }+ }).transform((value) => new URL(value).origin),+);++function rejectUnsafeVaultAddress(value: unknown, ctx: z.RefinementCtx) {+ if (value === undefined || value === null) return;+ const parsed = vaultAddressSchema.safeParse(value);+ if (parsed.success) return;+ for (const issue of parsed.error.issues) {+ ctx.addIssue({+ ...issue,+ path: ["config", "address", ...issue.path],+ });+ }+}++export const vaultProviderConfigSchema = z.object({+ address: vaultAddressSchema.optional().nullable(),+ namespace: optionalSafeShortText,+ mountPath: optionalSafeShortText,+ secretPathPrefix: optionalSafeShortText,+}).strict();++export const secretProviderConfigPayloadSchema = z.discriminatedUnion("provider", [+ z.object({ provider: z.literal("local_encrypted"), config: localEncryptedProviderConfigSchema }),+ z.object({ provider: z.literal("aws_secrets_manager"), config: awsSecretsManagerProviderConfigSchema }),+ z.object({ provider: z.literal("gcp_secret_manager"), config: gcpSecretManagerProviderConfigSchema }),+ z.object({ provider: z.literal("vault"), config: vaultProviderConfigSchema }),+]);++export const createSecretProviderConfigSchema = z.object({+ provider: z.enum(SECRET_PROVIDERS),+ displayName: z.string().trim().min(1).max(120),+ status: z.enum(SECRET_PROVIDER_CONFIG_STATUSES).optional(),+ isDefault: z.boolean().optional(),+ config: z.record(z.unknown()).default({}),+}).superRefine((value, ctx) => {+ rejectSensitiveProviderConfigKeys(value.config, ctx);+ const parsed = secretProviderConfigPayloadSchema.safeParse({+ provider: value.provider,+ config: value.config,+ });+ if (!parsed.success) {+ for (const issue of parsed.error.issues) {+ ctx.addIssue({+ ...issue,+ path: issue.path[0] === "config" ? issue.path : ["config", ...issue.path],+ });+ }+ }+ const status = value.status ?? (["gcp_secret_manager", "vault"].includes(value.provider) ? "coming_soon" : "ready");+ if ((value.provider === "gcp_secret_manager" || value.provider === "vault") && status !== "coming_soon" && status !== "disabled") {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["status"],+ message: `${value.provider} provider vaults are locked while coming soon`,+ });+ }+ if ((status === "coming_soon" || status === "disabled") && value.isDefault) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["isDefault"],+ message: "Only ready or warning provider vaults can be default",+ });+ }+});++export type CreateSecretProviderConfig = z.infer<typeof createSecretProviderConfigSchema>;++export const updateSecretProviderConfigSchema = z.object({+ displayName: z.string().trim().min(1).max(120).optional(),+ status: z.enum(SECRET_PROVIDER_CONFIG_STATUSES).optional(),+ isDefault: z.boolean().optional(),+ config: z.record(z.unknown()).optional(),+}).superRefine((value, ctx) => {+ if (value.config !== undefined) {+ rejectSensitiveProviderConfigKeys(value.config, ctx);+ rejectUnsafeVaultAddress(value.config.address, ctx);+ }+ if ((value.status === "coming_soon" || value.status === "disabled") && value.isDefault) {+ ctx.addIssue({+ code: z.ZodIssueCode.custom,+ path: ["isDefault"],+ message: "Only ready or warning provider vaults can be default",+ });+ }+});++export type UpdateSecretProviderConfig = z.infer<typeof updateSecretProviderConfigSchema>;++export const remoteSecretImportPreviewSchema = z.object({+ providerConfigId: z.string().uuid(),+ query: z.string().trim().max(200).optional().nullable(),+ nextToken: z.string().trim().min(1).max(4096).optional().nullable(),+ pageSize: z.number().int().min(1).max(100).optional(),+});++export type RemoteSecretImportPreview = z.infer<typeof remoteSecretImportPreviewSchema>;++export const remoteSecretImportSelectionSchema = z.object({+ externalRef: z.string().trim().min(1).max(2048),+ name: z.string().trim().min(1).max(160).optional().nullable(),+ key: z.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9_.-]+$/).optional().nullable(),+ description: z.string().trim().max(500).optional().nullable(),+ providerVersionRef: z.string().trim().min(1).max(512).optional().nullable(),+ providerMetadata: z.record(z.unknown()).optional().nullable(),+});++export const remoteSecretImportSchema = z.object({+ providerConfigId: z.string().uuid(),+ secrets: z.array(remoteSecretImportSelectionSchema).min(1).max(100),+});++export type RemoteSecretImportSelection = z.infer<typeof remoteSecretImportSelectionSchema>;+export type RemoteSecretImport = z.infer<typeof remoteSecretImportSchema>;diff --git a/scripts/capture-pap-2351-binding-picker.mjs b/scripts/capture-pap-2351-binding-picker.mjsnew file mode 100644index 0000000000..a8dad5edb5--- /dev/null+++ b/scripts/capture-pap-2351-binding-picker.mjs@@ -0,0 +1,115 @@+#!/usr/bin/env node+// Captures the BindingPicker storybook screenshot for PAP-2351 re-review.+// Boots a tiny static server over `ui/storybook-static` and screenshots the+// happy-path picker grid in dark mode at 1440x900 (matches the original+// PAP-2350 capture).++import { createRequire } from "node:module";+const localRequire = createRequire(import.meta.url);+const { chromium } = localRequire("playwright");+import http from "node:http";+import { promises as fs } from "node:fs";+import path from "node:path";+import { fileURLToPath } from "node:url";++const __dirname = path.dirname(fileURLToPath(import.meta.url));+const repoRoot = path.resolve(__dirname, "..");+const storybookRoot = path.join(repoRoot, "ui", "storybook-static");+const outDir = process.argv[2]+ ? path.resolve(process.argv[2])+ : path.join(repoRoot, "screenshots", "pap-2351");++const MIME = {+ ".html": "text/html",+ ".js": "application/javascript",+ ".mjs": "application/javascript",+ ".css": "text/css",+ ".json": "application/json",+ ".svg": "image/svg+xml",+ ".png": "image/png",+ ".jpg": "image/jpeg",+ ".woff": "font/woff",+ ".woff2": "font/woff2",+ ".ico": "image/x-icon",+ ".map": "application/json",+};++function startStaticServer(rootDir) {+ return new Promise((resolve) => {+ const server = http.createServer(async (req, res) => {+ try {+ const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);+ let filePath = path.join(rootDir, urlPath === "/" ? "index.html" : urlPath);+ let stat;+ try {+ stat = await fs.stat(filePath);+ } catch {+ stat = null;+ }+ if (stat?.isDirectory()) {+ filePath = path.join(filePath, "index.html");+ stat = await fs.stat(filePath).catch(() => null);+ }+ if (!stat) {+ res.statusCode = 404;+ res.end("not found");+ return;+ }+ const ext = path.extname(filePath).toLowerCase();+ res.setHeader("content-type", MIME[ext] ?? "application/octet-stream");+ res.setHeader("cache-control", "no-cache");+ const data = await fs.readFile(filePath);+ res.end(data);+ } catch (err) {+ res.statusCode = 500;+ res.end(err.message);+ }+ });+ server.listen(0, "127.0.0.1", () => {+ const address = server.address();+ const port = typeof address === "object" && address ? address.port : 0;+ resolve({ server, baseUrl: `http://127.0.0.1:${port}` });+ });+ });+}++const SHOTS = [+ {+ storyId: "product-secrets--binding-picker",+ label: "secrets-binding-picker",+ viewport: { width: 1440, height: 900 },+ theme: "dark",+ },+];++async function main() {+ await fs.mkdir(outDir, { recursive: true });+ const { server, baseUrl } = await startStaticServer(storybookRoot);+ const browser = await chromium.launch();+ const ctx = await browser.newContext({ deviceScaleFactor: 1 });+ const page = await ctx.newPage();+ const captured = [];+ try {+ for (const shot of SHOTS) {+ await page.setViewportSize(shot.viewport);+ const url = `${baseUrl}/iframe.html?id=${encodeURIComponent(shot.storyId)}&viewMode=story&globals=theme:${shot.theme}`;+ await page.goto(url, { waitUntil: "networkidle", timeout: 30_000 });+ // Allow the storybook fixture to swap CompanyContext to the storybook id and+ // for the picker's useQuery to settle from cache.+ await page.waitForTimeout(1500);+ const dest = path.join(outDir, `${shot.label}.png`);+ await page.screenshot({ path: dest, fullPage: false });+ captured.push(dest);+ console.log("captured", dest);+ }+ } finally {+ await browser.close();+ server.close();+ }+ console.log(JSON.stringify({ captured }, null, 2));+}++main().catch((err) => {+ console.error(err);+ process.exit(1);+});diff --git a/server/src/__tests__/agent-instructions-routes.test.ts b/server/src/__tests__/agent-instructions-routes.test.tsindex 3db0eba825..c29fca2437 100644--- a/server/src/__tests__/agent-instructions-routes.test.ts+++ b/server/src/__tests__/agent-instructions-routes.test.ts@@ -53,6 +53,14 @@ vi.mock("../services/index.js", () => ({workspaceOperationService: () => ({}),}));+vi.mock("../services/secrets.js", () => ({+ secretService: () => mockSecretService,+}));++vi.mock("../services/environments.js", () => ({+ environmentService: () => mockEnvironmentService,+}));+vi.mock("../adapters/index.js", () => ({findServerAdapter: mockFindServerAdapter,listAdapterModels: vi.fn(),@@ -75,6 +83,14 @@ function registerModuleMocks() {workspaceOperationService: () => ({}),}));+ vi.doMock("../services/secrets.js", () => ({+ secretService: () => mockSecretService,+ }));++ vi.doMock("../services/environments.js", () => ({+ environmentService: () => mockEnvironmentService,+ }));+vi.doMock("../adapters/index.js", () => ({findServerAdapter: mockFindServerAdapter,listAdapterModels: vi.fn(),diff --git a/server/src/__tests__/aws-secrets-manager-provider.test.ts b/server/src/__tests__/aws-secrets-manager-provider.test.tsnew file mode 100644index 0000000000..488f341599--- /dev/null+++ b/server/src/__tests__/aws-secrets-manager-provider.test.ts@@ -0,0 +1,820 @@+import { afterEach, describe, expect, it, vi } from "vitest";+import { createAwsSecretsManagerProvider } from "../secrets/aws-secrets-manager-provider.js";+import { SecretProviderClientError } from "../secrets/types.js";++describe("awsSecretsManagerProvider", () => {+ const previousEnv = {+ PAPERCLIP_SECRETS_AWS_REGION: process.env.PAPERCLIP_SECRETS_AWS_REGION,+ AWS_REGION: process.env.AWS_REGION,+ AWS_DEFAULT_REGION: process.env.AWS_DEFAULT_REGION,+ PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID: process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID,+ PAPERCLIP_SECRETS_AWS_KMS_KEY_ID: process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID,+ AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID,+ AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,+ AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN,+ };++ afterEach(() => {+ vi.restoreAllMocks();+ for (const [key, value] of Object.entries(previousEnv)) {+ if (value === undefined) {+ delete process.env[key];+ } else {+ process.env[key] = value;+ }+ }+ });++ it("creates Paperclip-managed AWS secrets without persisting plaintext in provider material", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret(input) {+ calls.push({ op: "createSecret", input });+ return {+ ARN: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ VersionId: "aws-version-1",+ };+ },+ async putSecretValue(input) {+ calls.push({ op: "putSecretValue", input });+ return { ARN: String(input.SecretId), VersionId: "unused" };+ },+ async getSecretValue(input) {+ calls.push({ op: "getSecretValue", input });+ return { SecretString: "resolved-value", VersionId: "unused" };+ },+ async deleteSecret(input) {+ calls.push({ op: "deleteSecret", input });+ return {};+ },+ },+ });++ const prepared = await provider.createSecret({+ value: "super-secret-value",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/attacker",+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 1,+ },+ });++ expect(calls).toEqual([+ expect.objectContaining({+ op: "createSecret",+ input: expect.objectContaining({+ Name: "paperclip/prod-use1/company-1/openai-api-key",+ KmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ }),+ }),+ ]);+ expect(JSON.stringify(prepared)).not.toContain("super-secret-value");+ expect(prepared.externalRef).toContain("paperclip/prod-use1/company-1/openai-api-key");+ expect(prepared.providerVersionRef).toBe("aws-version-1");+ });++ it("creates AWS secrets from selected provider vault config without deployment env fallback", async () => {+ delete process.env.PAPERCLIP_SECRETS_AWS_REGION;+ delete process.env.AWS_REGION;+ delete process.env.AWS_DEFAULT_REGION;+ delete process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID;+ delete process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID;++ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ gateway: {+ async createSecret(input) {+ calls.push({ op: "createSecret", input });+ return {+ ARN: "arn:aws:secretsmanager:us-west-2:123456789012:secret:clip/prod-us-west/company-1/openai-api-key",+ VersionId: "aws-version-1",+ };+ },+ async putSecretValue(input) {+ calls.push({ op: "putSecretValue", input });+ return { ARN: String(input.SecretId), VersionId: "unused" };+ },+ async getSecretValue(input) {+ calls.push({ op: "getSecretValue", input });+ return { SecretString: "resolved-value", VersionId: "unused" };+ },+ async deleteSecret(input) {+ calls.push({ op: "deleteSecret", input });+ return {};+ },+ },+ });++ const providerConfig = {+ id: "vault-1",+ provider: "aws_secrets_manager" as const,+ status: "ready",+ config: {+ region: "us-west-2",+ namespace: "prod-us-west",+ secretNamePrefix: "clip",+ ownerTag: "platform",+ environmentTag: "production",+ },+ };++ const health = await provider.healthCheck({ providerConfig });+ const prepared = await provider.createSecret({+ value: "super-secret-value",+ providerConfig,+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 1,+ },+ });++ expect(health.status).toBe("ok");+ expect(health.details).toMatchObject({+ region: "us-west-2",+ prefix: "clip",+ deploymentId: "prod-us-west",+ kmsKeyConfigured: false,+ });+ expect(calls).toEqual([+ expect.objectContaining({+ op: "createSecret",+ input: expect.objectContaining({+ Name: "clip/prod-us-west/company-1/openai-api-key",+ SecretString: "super-secret-value",+ Tags: expect.arrayContaining([+ { Key: "paperclip:provider-owner", Value: "platform" },+ { Key: "paperclip:environment", Value: "production" },+ ]),+ }),+ }),+ ]);+ expect(calls[0]?.input).not.toHaveProperty("KmsKeyId");+ expect(JSON.stringify(prepared)).not.toContain("super-secret-value");+ expect(prepared.externalRef).toContain("clip/prod-us-west/company-1/openai-api-key");+ });++ it("signs AWS Secrets Manager JSON requests with default runtime credentials", async () => {+ process.env.AWS_ACCESS_KEY_ID = "AKIA_TEST_ACCESS";+ process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";+ process.env.AWS_SESSION_TOKEN = "test-session-token";++ const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(+ new Response(+ JSON.stringify({+ ARN: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/company-1/openai-api-key",+ VersionId: "aws-version-1",+ }),+ { status: 200 },+ ),+ );+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ });++ await provider.createSecret({+ value: "super-secret-value",+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 1,+ },+ });++ expect(fetchMock).toHaveBeenCalledTimes(1);+ const [url, init] = fetchMock.mock.calls[0]!;+ const headers = init?.headers as Record<string, string>;+ expect(String(url)).toBe("https://secretsmanager.us-east-1.amazonaws.com/");+ expect(headers["x-amz-target"]).toBe("secretsmanager.CreateSecret");+ expect(headers["x-amz-security-token"]).toBe("test-session-token");+ expect(headers.authorization).toContain("Credential=AKIA_TEST_ACCESS/");+ expect(headers.authorization).toContain("/us-east-1/secretsmanager/aws4_request");+ expect(headers.authorization).toContain("SignedHeaders=");+ expect(headers.authorization).toContain("Signature=");+ expect(init?.signal).toBeInstanceOf(AbortSignal);+ });++ it("creates new AWS secret versions against a namespace-valid existing secret reference", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue(input) {+ calls.push({ op: "putSecretValue", input });+ return {+ ARN: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ VersionId: "aws-version-2",+ };+ },+ async getSecretValue() {+ throw new Error("not used");+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ },+ });++ const prepared = await provider.createVersion({+ value: "rotated-secret-value",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ });++ expect(calls).toEqual([+ {+ op: "putSecretValue",+ input: {+ SecretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ SecretString: "rotated-secret-value",+ VersionStages: ["PAPERCLIP_PENDING"],+ },+ },+ ]);+ expect(JSON.stringify(prepared)).not.toContain("rotated-secret-value");+ expect(prepared.providerVersionRef).toBe("aws-version-2");+ });++ it("rejects out-of-namespace refs for managed AWS secret version writes", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue(input) {+ calls.push({ op: "putSecretValue", input });+ return { Name: String(input.SecretId), VersionId: "aws-version-2" };+ },+ async getSecretValue() {+ throw new Error("not used");+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ },+ });++ await expect(+ provider.createVersion({+ value: "rotated-secret-value",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/attacker",+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ }),+ ).rejects.toThrow(/drifted outside the derived deployment\/company scope/i);++ expect(calls).toEqual([]);+ });++ it("stores linked external references as metadata-only provider material", async () => {+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ });++ const prepared = await provider.linkExternalSecret({+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/external",+ providerVersionRef: "linked-version-7",+ });++ expect(prepared.externalRef).toBe(+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/external",+ );+ expect(prepared.providerVersionRef).toBe("linked-version-7");+ expect(prepared.valueSha256).toBeTruthy();+ });++ it("rejects linked external references under the Paperclip-managed namespace", async () => {+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ });++ await expect(+ provider.linkExternalSecret({+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-2/openai-api-key",+ providerVersionRef: "linked-version-7",+ }),+ ).rejects.toThrow(/Paperclip-managed namespace/i);+ });++ it("lists remote AWS secrets with metadata only and never resolves plaintext", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue() {+ throw new Error("GetSecretValue must not be used for remote import preview");+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ async listSecrets(input) {+ calls.push({ op: "listSecrets", input });+ return {+ NextToken: "token-2",+ SecretList: [+ {+ ARN: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ Name: "prod/openai",+ Description: "OpenAI API key",+ CreatedDate: new Date("2026-05-06T00:00:00.000Z"),+ Tags: [{ Key: "team", Value: "platform" }],+ },+ ],+ };+ },+ },+ });++ const listed = await provider.listRemoteSecrets?.({+ query: "openai",+ nextToken: "token-1",+ pageSize: 25,+ });++ expect(calls).toEqual([+ {+ op: "listSecrets",+ input: {+ MaxResults: 25,+ NextToken: "token-1",+ IncludePlannedDeletion: false,+ Filters: [{ Key: "all", Values: ["openai"] }],+ },+ },+ ]);+ expect(listed).toEqual({+ nextToken: "token-2",+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "prod/openai",+ providerVersionRef: null,+ metadata: expect.objectContaining({+ createdDate: "2026-05-06T00:00:00.000Z",+ hasDescription: true,+ tagCount: 1,+ }),+ },+ ],+ });+ expect(JSON.stringify(listed)).not.toContain("SecretString");+ expect(JSON.stringify(listed)).not.toContain("OpenAI API key");+ expect(JSON.stringify(listed)).not.toContain("team");+ });++ it("redacts AWS provider exception text when remote listing fails", async () => {+ const rawProviderMessage =+ "AccessDeniedException: User: arn:aws:sts::123456789012:assumed-role/prod/Paperclip is not authorized to perform secretsmanager:ListSecrets on arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai";+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue() {+ throw new Error("not used");+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ async listSecrets() {+ throw new Error(rawProviderMessage);+ },+ },+ });++ let thrown: unknown;+ try {+ await provider.listRemoteSecrets?.({});+ } catch (error) {+ thrown = error;+ }++ expect(thrown).toBeInstanceOf(SecretProviderClientError);+ expect(thrown).toMatchObject({+ code: "access_denied",+ status: 403,+ message: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ rawMessage: rawProviderMessage,+ });+ expect(thrown instanceof Error ? thrown.message : String(thrown)).not.toContain("arn:aws");+ expect(thrown instanceof Error ? thrown.message : String(thrown)).not.toContain("123456789012");+ });++ it("resolves AWS secret values by provider version reference", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue(input) {+ calls.push({ op: "getSecretValue", input });+ return { SecretString: "resolved-secret-value", VersionId: "aws-version-2" };+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ },+ });++ const resolved = await provider.resolveVersion({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ versionId: "aws-version-2",+ source: "managed",+ },+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ providerVersionRef: "aws-version-2",+ context: {+ companyId: "company-1",+ secretId: "secret-1",+ secretKey: "openai-api-key",+ version: 2,+ },+ });++ expect(resolved).toBe("resolved-secret-value");+ expect(calls).toEqual([+ {+ op: "getSecretValue",+ input: {+ SecretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ VersionId: "aws-version-2",+ VersionStage: undefined,+ },+ },+ ]);+ });++ it("rejects managed resolve attempts when stored refs drift outside the derived scope", async () => {+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue() {+ throw new Error("should not be called");+ },+ async deleteSecret() {+ throw new Error("not used");+ },+ },+ });++ await expect(+ provider.resolveVersion({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-2/openai-api-key",+ versionId: "aws-version-2",+ source: "managed",+ },+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-2/openai-api-key",+ providerVersionRef: "aws-version-2",+ context: {+ companyId: "company-1",+ secretId: "secret-1",+ secretKey: "openai-api-key",+ version: 2,+ },+ }),+ ).rejects.toThrow(/drifted outside the derived deployment\/company scope/i);+ });++ it("warns when AWS provider configuration is incomplete and blocks managed writes", async () => {+ delete process.env.PAPERCLIP_SECRETS_AWS_REGION;+ delete process.env.AWS_REGION;+ delete process.env.AWS_DEFAULT_REGION;+ delete process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID;+ delete process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID;++ const provider = createAwsSecretsManagerProvider();+ const health = await provider.healthCheck();++ expect(health.status).toBe("warn");+ expect(health.message).toContain("missing PAPERCLIP_SECRETS_AWS_REGION");+ expect(health.warnings).toEqual(+ expect.arrayContaining([+ expect.stringContaining("Missing required non-secret AWS provider config"),+ expect.stringContaining("AWS bootstrap credentials must be available"),+ expect.stringContaining("Do not store AWS root credentials"),+ ]),+ );+ expect(health.details).toMatchObject({+ missingConfig: [+ "PAPERCLIP_SECRETS_AWS_REGION or AWS_REGION/AWS_DEFAULT_REGION",+ "PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID",+ "PAPERCLIP_SECRETS_AWS_KMS_KEY_ID",+ ],+ credentialSource: "AWS SDK default credential provider chain",+ });+ await expect(+ provider.createSecret({+ value: "super-secret-value",+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 1,+ },+ }),+ ).rejects.toThrow(/PAPERCLIP_SECRETS_AWS_REGION|AWS_REGION/i);+ });++ it("deletes only Paperclip-managed AWS secrets", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue() {+ throw new Error("not used");+ },+ async deleteSecret(input) {+ calls.push({ op: "deleteSecret", input });+ return {};+ },+ },+ });++ await provider.deleteOrArchive({+ mode: "delete",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ versionId: null,+ source: "managed",+ },+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ });+ await expect(+ provider.deleteOrArchive({+ mode: "delete",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/attacker",+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/attacker",+ versionId: null,+ source: "managed",+ },+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ }),+ ).rejects.toThrow(/drifted outside the derived deployment\/company scope/i);+ await provider.deleteOrArchive({+ mode: "delete",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/external",+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/external",+ versionId: "linked-version-7",+ source: "external_reference",+ },+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ });++ expect(calls).toEqual([+ {+ op: "deleteSecret",+ input: {+ SecretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ RecoveryWindowInDays: 30,+ },+ },+ ]);+ });++ it("archives pending Paperclip-managed AWS versions without deleting the secret", async () => {+ const calls: Array<{ op: string; input: Record<string, unknown> }> = [];+ const provider = createAwsSecretsManagerProvider({+ config: {+ region: "us-east-1",+ endpoint: "https://secretsmanager.us-east-1.amazonaws.com",+ deploymentId: "prod-use1",+ prefix: "paperclip",+ kmsKeyId: "arn:aws:kms:us-east-1:123456789012:key/test",+ environmentTag: "production",+ providerOwnerTag: "paperclip",+ deleteRecoveryWindowDays: 30,+ },+ gateway: {+ async createSecret() {+ throw new Error("not used");+ },+ async putSecretValue() {+ throw new Error("not used");+ },+ async getSecretValue() {+ throw new Error("not used");+ },+ async deleteSecret(input) {+ calls.push({ op: "deleteSecret", input });+ return {};+ },+ async updateSecretVersionStage(input) {+ calls.push({ op: "updateSecretVersionStage", input });+ return {};+ },+ },+ });++ await provider.deleteOrArchive({+ mode: "archive",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ versionId: "aws-version-2",+ source: "managed",+ },+ context: {+ companyId: "company-1",+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 2,+ },+ });++ expect(calls).toEqual([+ {+ op: "updateSecretVersionStage",+ input: {+ SecretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key",+ VersionStage: "PAPERCLIP_PENDING",+ RemoveFromVersionId: "aws-version-2",+ },+ },+ ]);+ });+});diff --git a/server/src/__tests__/claude-local-execute.test.ts b/server/src/__tests__/claude-local-execute.test.tsindex c34a576a86..73eeb82554 100644--- a/server/src/__tests__/claude-local-execute.test.ts+++ b/server/src/__tests__/claude-local-execute.test.ts@@ -648,7 +648,7 @@ describe("claude execute", () => {else process.env.PATH = previousPath;await fs.rm(root, { recursive: true, force: true });}- });+ }, 10_000);it("reuses a stable Paperclip-managed Claude prompt bundle across equivalent runs", async () => {const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-claude-execute-bundle-"));diff --git a/server/src/__tests__/company-portability.test.ts b/server/src/__tests__/company-portability.test.tsindex 33e01da7af..df1d8e7fda 100644--- a/server/src/__tests__/company-portability.test.ts+++ b/server/src/__tests__/company-portability.test.ts@@ -497,6 +497,70 @@ describe("company portability", () => {expect(asTextFile(exported.files[".paperclip.yaml"])).toContain("requireBoardApprovalForNewAgents: true");});+ it("exports legacy inline sensitive env values as declarations without values", async () => {+ const portability = companyPortabilityService({} as any);+ agentSvc.list.mockResolvedValue([+ {+ id: "agent-inline-secret",+ name: "InlineSecretAgent",+ status: "idle",+ role: "engineer",+ title: null,+ icon: null,+ reportsTo: null,+ capabilities: null,+ adapterType: "codex_local",+ adapterConfig: {+ env: {+ OPENAI_API_KEY: "sk-inline-secret-value",+ NODE_ENV: {+ type: "plain",+ value: "development",+ },+ },+ },+ runtimeConfig: {},+ budgetMonthlyCents: 0,+ permissions: {+ canCreateAgents: false,+ },+ metadata: null,+ },+ ]);++ const exported = await portability.exportBundle("company-1", {+ include: {+ company: true,+ agents: true,+ projects: false,+ issues: false,+ },+ });++ const serialized = JSON.stringify(exported);+ expect(serialized).not.toContain("sk-inline-secret-value");+ expect(exported.manifest.envInputs).toContainEqual({+ key: "OPENAI_API_KEY",+ description: "Optional default for OPENAI_API_KEY on agent inlinesecretagent",+ agentSlug: "inlinesecretagent",+ projectSlug: null,+ kind: "secret",+ requirement: "optional",+ defaultValue: "",+ portability: "portable",+ });+ expect(exported.manifest.envInputs).toContainEqual({+ key: "NODE_ENV",+ description: "Optional default for NODE_ENV on agent inlinesecretagent",+ agentSlug: "inlinesecretagent",+ projectSlug: null,+ kind: "plain",+ requirement: "optional",+ defaultValue: "development",+ portability: "portable",+ });+ });+it("exports default sidebar order into the Paperclip extension and manifest", async () => {const portability = companyPortabilityService({} as any);diff --git a/server/src/__tests__/cursor-local-execute.test.ts b/server/src/__tests__/cursor-local-execute.test.tsindex 9f8b49ca6c..67192ab6c1 100644--- a/server/src/__tests__/cursor-local-execute.test.ts+++ b/server/src/__tests__/cursor-local-execute.test.ts@@ -385,7 +385,7 @@ describe("cursor execute", () => {else process.env.HOME = previousHome;await fs.rm(root, { recursive: true, force: true });}- });+ }, 10_000);it("keeps explicit command overrides for remote sandbox execution", async () => {const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-cursor-sandbox-explicit-"));diff --git a/server/src/__tests__/environment-live-ssh.test.ts b/server/src/__tests__/environment-live-ssh.test.tsindex ad608c0bc2..303d7ff7d9 100644--- a/server/src/__tests__/environment-live-ssh.test.ts+++ b/server/src/__tests__/environment-live-ssh.test.ts@@ -161,9 +161,10 @@ describeLiveSsh("live SSH environment smoke", () => {}if (!resolvedConfig) {- throw new Error(+ console.warn("Live SSH smoke test could not resolve SSH config from env vars or env-lab fixture. Set PAPERCLIP_ENV_LIVE_SSH_NO_AUTO_FIXTURE=true to mark this suite skipped intentionally.",);+ return;}const config = resolvedConfig;@@ -171,7 +172,7 @@ describeLiveSsh("live SSH environment smoke", () => {const quotedRemoteWorkspacePath = JSON.stringify(config.remoteWorkspacePath);const result = await runSshCommand(config,- `sh -lc "cd ${quotedRemoteWorkspacePath} && which git && which tar && pwd"`,+ `cd ${quotedRemoteWorkspacePath} && which git && which tar && pwd`,{ timeoutMs: 30000, maxBuffer: 256 * 1024 },);diff --git a/server/src/__tests__/environment-routes.test.ts b/server/src/__tests__/environment-routes.test.tsindex 3c9ecdb4e0..6d74de22df 100644--- a/server/src/__tests__/environment-routes.test.ts+++ b/server/src/__tests__/environment-routes.test.ts@@ -36,10 +36,13 @@ const mockProbeEnvironment = vi.hoisted(() => vi.fn());const mockSecretService = vi.hoisted(() => ({create: vi.fn(),resolveSecretValue: vi.fn(),+ syncSecretRefsForTarget: vi.fn(),+ remove: vi.fn(),}));const mockValidatePluginEnvironmentDriverConfig = vi.hoisted(() => vi.fn());const mockValidatePluginSandboxProviderConfig = vi.hoisted(() => vi.fn());const mockListReadyPluginEnvironmentDrivers = vi.hoisted(() => vi.fn());+const mockResolvePluginSandboxProviderDriverByKey = vi.hoisted(() => vi.fn());const mockExecutionWorkspaceService = vi.hoisted(() => ({}));vi.mock("../services/index.js", () => ({@@ -69,6 +72,7 @@ vi.mock("../services/execution-workspaces.js", () => ({vi.mock("../services/plugin-environment-driver.js", () => ({listReadyPluginEnvironmentDrivers: mockListReadyPluginEnvironmentDrivers,+ resolvePluginSandboxProviderDriverByKey: mockResolvePluginSandboxProviderDriverByKey,validatePluginEnvironmentDriverConfig: mockValidatePluginEnvironmentDriverConfig,validatePluginSandboxProviderConfig: mockValidatePluginSandboxProviderConfig,}));@@ -96,6 +100,7 @@ let currentActor: Record<string, unknown> = {source: "local_implicit",};const routeOptions: Record<string, unknown> = {};+const originalSecretsProviderEnv = process.env.PAPERCLIP_SECRETS_PROVIDER;function createApp(actor: Record<string, unknown>, options: Record<string, unknown> = {}) {currentActor = actor;@@ -119,6 +124,11 @@ function createApp(actor: Record<string, unknown>, options: Record<string, unknodescribe("environment routes", () => {afterAll(async () => {+ if (originalSecretsProviderEnv === undefined) {+ delete process.env.PAPERCLIP_SECRETS_PROVIDER;+ } else {+ process.env.PAPERCLIP_SECRETS_PROVIDER = originalSecretsProviderEnv;+ }if (!server) return;await new Promise<void>((resolve, reject) => {server?.close((err) => {@@ -145,9 +155,14 @@ describe("environment routes", () => {mockProbeEnvironment.mockReset();mockSecretService.create.mockReset();mockSecretService.resolveSecretValue.mockReset();+ mockSecretService.syncSecretRefsForTarget.mockReset();+ mockSecretService.remove.mockReset();mockSecretService.create.mockResolvedValue({id: "11111111-1111-1111-1111-111111111111",});+ mockSecretService.syncSecretRefsForTarget.mockResolvedValue([]);+ mockSecretService.remove.mockResolvedValue(null);+ delete process.env.PAPERCLIP_SECRETS_PROVIDER;mockValidatePluginEnvironmentDriverConfig.mockReset();mockValidatePluginEnvironmentDriverConfig.mockImplementation(async ({ config }) => config);mockValidatePluginSandboxProviderConfig.mockReset();@@ -162,6 +177,29 @@ describe("environment routes", () => {configSchema: { type: "object" },},}));+ mockResolvePluginSandboxProviderDriverByKey.mockReset();+ mockResolvePluginSandboxProviderDriverByKey.mockImplementation(async ({ driverKey }) => (+ driverKey === "secure-plugin"+ ? {+ 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" },+ },+ },+ },+ }+ : null+ ));mockListReadyPluginEnvironmentDrivers.mockReset();mockListReadyPluginEnvironmentDrivers.mockResolvedValue([]);});@@ -555,6 +593,59 @@ describe("environment routes", () => {);});+ it("uses the configured provider for SSH private key secret materialization", async () => {+ process.env.PAPERCLIP_SECRETS_PROVIDER = "aws_secrets_manager";+ const environment = {+ ...createEnvironment(),+ id: "env-ssh",+ name: "SSH Fixture",+ driver: "ssh" as const,+ config: {+ host: "ssh.example.test",+ port: 22,+ username: "ssh-user",+ remoteWorkspacePath: "/srv/paperclip/workspace",+ privateKey: null,+ privateKeySecretRef: {+ type: "secret_ref",+ secretId: "11111111-1111-1111-1111-111111111111",+ version: "latest",+ },+ knownHosts: null,+ strictHostKeyChecking: true,+ },+ };+ mockEnvironmentService.create.mockResolvedValue(environment);+ const app = createApp({+ type: "board",+ userId: "user-1",+ source: "local_implicit",+ });++ const res = await request(app)+ .post("/api/companies/company-1/environments")+ .send({+ name: "SSH Fixture",+ driver: "ssh",+ config: {+ host: "ssh.example.test",+ username: "ssh-user",+ remoteWorkspacePath: "/srv/paperclip/workspace",+ privateKey: "super-secret-key",+ },+ });++ expect(res.status).toBe(201);+ expect(mockSecretService.create).toHaveBeenCalledWith(+ "company-1",+ expect.objectContaining({+ provider: "aws_secrets_manager",+ value: "super-secret-key",+ }),+ expect.any(Object),+ );+ });+it("rejects persisted fake sandbox environments", async () => {const app = createApp({type: "board",@@ -732,6 +823,78 @@ describe("environment routes", () => {);});+ it("uses the configured provider for schema-driven sandbox secret fields", async () => {+ process.env.PAPERCLIP_SECRETS_PROVIDER = "aws_secrets_manager";+ const environment = {+ ...createEnvironment(),+ id: "env-sandbox-secure-plugin",+ name: "Secure Sandbox",+ driver: "sandbox" as const,+ config: {+ provider: "secure-plugin",+ template: "base",+ apiKey: "11111111-1111-1111-1111-111111111111",+ timeoutMs: 450000,+ reuseLease: true,+ },+ };+ mockEnvironmentService.create.mockResolvedValue(environment);+ mockValidatePluginSandboxProviderConfig.mockResolvedValue({+ normalizedConfig: {+ template: "base",+ apiKey: "test-provider-key",+ timeoutMs: 450000,+ 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" },+ },+ },+ },+ });+ const pluginWorkerManager = {};+ const app = createApp({+ type: "board",+ userId: "user-1",+ source: "local_implicit",+ }, { pluginWorkerManager });++ const res = await request(app)+ .post("/api/companies/company-1/environments")+ .send({+ name: "Secure Sandbox",+ driver: "sandbox",+ config: {+ provider: "secure-plugin",+ template: "base",+ apiKey: "test-provider-key",+ timeoutMs: "450000",+ reuseLease: true,+ },+ });++ expect(res.status).toBe(201);+ expect(mockSecretService.create).toHaveBeenCalledWith(+ "company-1",+ expect.objectContaining({+ provider: "aws_secrets_manager",+ value: "test-provider-key",+ }),+ expect.any(Object),+ );+ });+it("validates plugin environment config through the plugin driver host", async () => {const environment = {...createEnvironment(),diff --git a/server/src/__tests__/environment-runtime-driver-contract.test.ts b/server/src/__tests__/environment-runtime-driver-contract.test.tsindex 067c040d26..53665ed9af 100644--- a/server/src/__tests__/environment-runtime-driver-contract.test.ts+++ b/server/src/__tests__/environment-runtime-driver-contract.test.ts@@ -118,6 +118,13 @@ describeEmbeddedPostgres("environment runtime driver contract", () => {provider: "local_encrypted",value: config.privateKey,});+ await secretService(db).createBinding({+ companyId,+ secretId: secret.id,+ targetType: "environment",+ targetId: environmentId,+ configPath: "privateKeySecretRef",+ });config = {...config,privateKey: null,diff --git a/server/src/__tests__/environment-runtime.test.ts b/server/src/__tests__/environment-runtime.test.tsindex ffda21c61e..292c32481e 100644--- a/server/src/__tests__/environment-runtime.test.ts+++ b/server/src/__tests__/environment-runtime.test.ts@@ -177,6 +177,13 @@ describeEmbeddedPostgres("environmentRuntimeService", () => {provider: "local_encrypted",value: config.privateKey,});+ await secretService(db).createBinding({+ companyId,+ secretId: secret.id,+ targetType: "environment",+ targetId: environmentId,+ configPath: "privateKeySecretRef",+ });config = {...config,privateKey: null,@@ -548,6 +555,13 @@ describeEmbeddedPostgres("environmentRuntimeService", () => {driver: "sandbox",config: providerConfig,};+ await secretService(db).createBinding({+ companyId,+ secretId: apiSecret.id,+ targetType: "environment",+ targetId: environment.id,+ configPath: "apiKey",+ });await environmentService(db).update(environment.id, {driver: "sandbox",name: environment.name,diff --git a/server/src/__tests__/heartbeat-process-recovery.test.ts b/server/src/__tests__/heartbeat-process-recovery.test.tsindex 2b917879e3..45842b428f 100644--- a/server/src/__tests__/heartbeat-process-recovery.test.ts+++ b/server/src/__tests__/heartbeat-process-recovery.test.ts@@ -2080,6 +2080,83 @@ describeEmbeddedPostgres("heartbeat orphaned process recovery", () => {expect(comments[0]?.body).toContain(`Recovery issue: [${recovery.identifier}]`);});+ it("blocks an already stranded recovery issue without creating a recovery child", async () => {+ const { companyId, issueId } = await seedStrandedIssueFixture({+ status: "todo",+ runStatus: "failed",+ retryReason: "assignment_recovery",+ });+ const sourceIssueId = randomUUID();+ const sourceRunId = randomUUID();+ const issuePrefix = `T${companyId.replace(/-/g, "").slice(0, 6).toUpperCase()}`;++ await db.insert(issues).values({+ id: sourceIssueId,+ companyId,+ title: "Original source issue",+ status: "blocked",+ priority: "medium",+ issueNumber: 2,+ identifier: `${issuePrefix}-2`,+ });+ await db+ .update(issues)+ .set({+ title: "Recover stalled issue from previous adapter failure",+ parentId: sourceIssueId,+ originKind: "stranded_issue_recovery",+ originId: sourceIssueId,+ originRunId: sourceRunId,+ originFingerprint: [+ "stranded_issue_recovery",+ companyId,+ sourceIssueId,+ sourceRunId,+ ].join(":"),+ })+ .where(eq(issues.id, issueId));+ const heartbeat = heartbeatService(db);++ const result = await heartbeat.reconcileStrandedAssignedIssues();+ expect(result.dispatchRequeued).toBe(0);+ expect(result.escalated).toBe(1);+ expect(result.issueIds).toEqual([issueId]);++ const recoveryIssues = await db+ .select()+ .from(issues)+ .where(and(eq(issues.companyId, companyId), eq(issues.originKind, "stranded_issue_recovery")));+ expect(recoveryIssues).toHaveLength(1);+ expect(recoveryIssues[0]).toMatchObject({+ id: issueId,+ status: "blocked",+ parentId: sourceIssueId,+ originId: sourceIssueId,+ originRunId: sourceRunId,+ });+ expect(recoveryIssues[0]?.checkoutRunId).toBeNull();+ expect(recoveryIssues[0]?.executionRunId).toBeNull();++ const blockerRelations = await db+ .select()+ .from(issueRelations)+ .where(+ and(+ eq(issueRelations.companyId, companyId),+ eq(issueRelations.relatedIssueId, issueId),+ eq(issueRelations.type, "blocks"),+ ),+ );+ expect(blockerRelations).toHaveLength(0);++ const comments = await db.select().from(issueComments).where(eq(issueComments.issueId, issueId));+ expect(comments).toHaveLength(1);+ expect(comments[0]?.body).toContain("stopped automatic stranded-work recovery");+ expect(comments[0]?.body).toContain("recovery issues do not create nested `stranded_issue_recovery` issues");+ expect(comments[0]?.body).toContain(`Recovery issue: [${recoveryIssues[0]?.identifier}]`);+ expect(comments[0]?.body).toContain("Next action:");+ });+it("assigns open unassigned blockers back to their creator agent", async () => {const companyId = randomUUID();const creatorAgentId = randomUUID();diff --git a/server/src/__tests__/heartbeat-project-env.test.ts b/server/src/__tests__/heartbeat-project-env.test.tsindex 8490b04e41..55653be369 100644--- a/server/src/__tests__/heartbeat-project-env.test.ts+++ b/server/src/__tests__/heartbeat-project-env.test.ts@@ -17,6 +17,17 @@ describe("resolveExecutionRunAdapterConfig", () => {other: "value",},secretKeys: new Set(["AGENT_SECRET"]),+ manifest: [+ {+ configPath: "env.AGENT_SECRET",+ envKey: "AGENT_SECRET",+ secretId: "secret-agent",+ secretKey: "agent-secret",+ version: 1,+ provider: "local_encrypted",+ outcome: "success",+ },+ ],});const resolveEnvBindings = vi.fn().mockResolvedValue({env: {@@ -24,6 +35,17 @@ describe("resolveExecutionRunAdapterConfig", () => {PROJECT_ONLY: "project-only",},secretKeys: new Set(["PROJECT_SECRET"]),+ manifest: [+ {+ configPath: "env.PROJECT_SECRET",+ envKey: "PROJECT_SECRET",+ secretId: "secret-project",+ secretKey: "project-secret",+ version: 1,+ provider: "local_encrypted",+ outcome: "success",+ },+ ],});const result = await resolveExecutionRunAdapterConfig({@@ -45,12 +67,19 @@ describe("resolveExecutionRunAdapterConfig", () => {},});expect(Array.from(result.secretKeys).sort()).toEqual(["AGENT_SECRET", "PROJECT_SECRET"]);+ expect(result.secretManifest.map((entry) => entry.secretId).sort()).toEqual([+ "secret-agent",+ "secret-project",+ ]);+ expect(JSON.stringify(result.secretManifest)).not.toContain("agent-only");+ expect(JSON.stringify(result.secretManifest)).not.toContain("project-only");});it("skips project env resolution when the project has no bindings", async () => {const resolveAdapterConfigForRuntime = vi.fn().mockResolvedValue({config: { env: { AGENT_ONLY: "agent-only" } },secretKeys: new Set<string>(),+ manifest: [],});const resolveEnvBindings = vi.fn();@@ -65,6 +94,7 @@ describe("resolveExecutionRunAdapterConfig", () => {});expect(result.resolvedConfig.env).toEqual({ AGENT_ONLY: "agent-only" });+ expect(result.secretManifest).toEqual([]);expect(resolveEnvBindings).not.toHaveBeenCalled();});});diff --git a/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts b/server/src/__tests__/heartbeat-stale-queue-invalidation.test.tsindex 4641d09f04..357140a13c 100644--- a/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts+++ b/server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts@@ -144,6 +144,7 @@ describeEmbeddedPostgres("heartbeat stale queued-run invalidation", () => {await db.delete(documents);await db.delete(issueRelations);await db.delete(issueTreeHolds);+ await db.delete(issueComments);await db.delete(issues);await db.delete(heartbeatRunEvents);await db.delete(activityLog);diff --git a/server/src/__tests__/plugin-routes-authz.test.ts b/server/src/__tests__/plugin-routes-authz.test.tsindex faf3487bf6..52e678b46d 100644--- a/server/src/__tests__/plugin-routes-authz.test.ts+++ b/server/src/__tests__/plugin-routes-authz.test.ts@@ -224,6 +224,30 @@ describe.sequential("plugin install and upgrade authz", () => {expect(mockLifecycle.disable).not.toHaveBeenCalled();}, 20_000);+ it("rejects plugin config saves that contain secret refs even for instance admins", async () => {+ readyPlugin();++ const { app } = await createApp({+ type: "board",+ userId: "admin-1",+ source: "session",+ isInstanceAdmin: true,+ companyIds: [companyA],+ });++ const res = await request(app)+ .post(`/api/plugins/${pluginId}/config`)+ .send({+ configJson: {+ apiKeyRef: "77777777-7777-4777-8777-777777777777",+ },+ });++ expect(res.status).toBe(422);+ expect(res.body.error).toMatch(/secret references are disabled/i);+ expect(mockRegistry.upsertConfig).not.toHaveBeenCalled();+ }, 20_000);+it("allows instance admins to upgrade plugins", async () => {const pluginId = "11111111-1111-4111-8111-111111111111";mockRegistry.getById.mockResolvedValue({diff --git a/server/src/__tests__/plugin-secrets-handler.test.ts b/server/src/__tests__/plugin-secrets-handler.test.tsnew file mode 100644index 0000000000..ec89c8722c--- /dev/null+++ b/server/src/__tests__/plugin-secrets-handler.test.ts@@ -0,0 +1,29 @@+import { describe, expect, it } from "vitest";+import {+ createPluginSecretsHandler,+ PLUGIN_SECRET_REFS_DISABLED_MESSAGE,+} from "../services/plugin-secrets-handler.js";++describe("createPluginSecretsHandler", () => {+ it("fails closed for plugin secret resolution until company scoping lands", async () => {+ const handler = createPluginSecretsHandler({+ db: {} as never,+ pluginId: "11111111-1111-4111-8111-111111111111",+ });++ await expect(+ handler.resolve({ secretRef: "77777777-7777-4777-8777-777777777777" }),+ ).rejects.toThrow(PLUGIN_SECRET_REFS_DISABLED_MESSAGE);+ });++ it("still rejects malformed secret refs before the feature-disable guard", async () => {+ const handler = createPluginSecretsHandler({+ db: {} as never,+ pluginId: "11111111-1111-4111-8111-111111111111",+ });++ await expect(+ handler.resolve({ secretRef: "not-a-uuid" }),+ ).rejects.toThrow(/invalid secret reference/i);+ });+});diff --git a/server/src/__tests__/routines-service.test.ts b/server/src/__tests__/routines-service.test.tsindex 9da3270d37..70fe9d0500 100644--- a/server/src/__tests__/routines-service.test.ts+++ b/server/src/__tests__/routines-service.test.ts@@ -1,6 +1,6 @@import { createHmac, randomUUID } from "node:crypto";import { eq } from "drizzle-orm";-import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";import {activityLog,agents,@@ -26,10 +26,12 @@ import {} from "./helpers/embedded-postgres.js";import { issueService } from "../services/issues.ts";import { instanceSettingsService } from "../services/instance-settings.ts";+import * as providerRegistry from "../secrets/provider-registry.ts";import { routineService } from "../services/routines.ts";const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;+const originalSecretsProviderEnv = process.env.PAPERCLIP_SECRETS_PROVIDER;if (!embeddedPostgresSupport.supported) {console.warn(@@ -47,6 +49,11 @@ describeEmbeddedPostgres("routine service live-execution coalescing", () => {}, 20_000);afterEach(async () => {+ if (originalSecretsProviderEnv === undefined) {+ delete process.env.PAPERCLIP_SECRETS_PROVIDER;+ } else {+ process.env.PAPERCLIP_SECRETS_PROVIDER = originalSecretsProviderEnv;+ }await db.delete(activityLog);await db.delete(issueInboxArchives);await db.delete(issueReadStates);@@ -1272,6 +1279,82 @@ describeEmbeddedPostgres("routine service live-execution coalescing", () => {expect(run.linkedIssueId).toBeTruthy();});+ it("uses the configured provider for generated webhook trigger secrets", async () => {+ process.env.PAPERCLIP_SECRETS_PROVIDER = "aws_secrets_manager";+ const originalGetSecretProvider = providerRegistry.getSecretProvider;+ const getSecretProviderSpy = vi.spyOn(providerRegistry, "getSecretProvider").mockImplementation((provider) => {+ if (provider !== "aws_secrets_manager") {+ return originalGetSecretProvider(provider);+ }+ return {+ id: "aws_secrets_manager",+ descriptor: () => ({+ id: "aws_secrets_manager",+ label: "AWS Secrets Manager",+ supportsManaged: true,+ supportsExternalReference: true,+ }),+ validateConfig: async () => ({ ok: true, warnings: [] }),+ createSecret: async ({ value }) => ({+ material: { source: "managed", secretId: "arn:aws:secretsmanager:stub", versionId: "v1" },+ valueSha256: `sha:${value}`,+ fingerprintSha256: `sha:${value}`,+ externalRef: "arn:aws:secretsmanager:stub",+ providerVersionRef: "v1",+ }),+ createVersion: async ({ value }) => ({+ material: { source: "managed", secretId: "arn:aws:secretsmanager:stub", versionId: "v2" },+ valueSha256: `sha:${value}`,+ fingerprintSha256: `sha:${value}`,+ externalRef: "arn:aws:secretsmanager:stub",+ providerVersionRef: "v2",+ }),+ linkExternalSecret: async ({ externalRef, providerVersionRef }) => ({+ material: { source: "external", secretId: externalRef, versionId: providerVersionRef ?? null },+ valueSha256: "external",+ fingerprintSha256: "external",+ externalRef,+ providerVersionRef: providerVersionRef ?? null,+ }),+ resolveVersion: async () => "resolved-secret",+ deleteOrArchive: async () => undefined,+ healthCheck: async () => ({+ provider: "aws_secrets_manager",+ status: "ok",+ message: "stubbed",+ }),+ };+ });++ try {+ const { routine, svc } = await seedFixture();+ const { trigger } = await svc.createTrigger(+ routine.id,+ {+ kind: "webhook",+ signingMode: "hmac_sha256",+ replayWindowSec: 300,+ },+ {},+ );++ const [secret] = await db+ .select({+ id: companySecrets.id,+ provider: companySecrets.provider,+ })+ .from(companySecrets)+ .where(eq(companySecrets.id, trigger.secretId!));++ expect(secret).toMatchObject({+ id: trigger.secretId,+ provider: "aws_secrets_manager",+ });+ } finally {+ getSecretProviderSpy.mockRestore();+ }+ });+it("accepts GitHub-style X-Hub-Signature-256 with github_hmac signing mode", async () => {const { routine, svc } = await seedFixture();const { trigger, secretMaterial } = await svc.createTrigger(diff --git a/server/src/__tests__/secret-provider-registry.test.ts b/server/src/__tests__/secret-provider-registry.test.tsnew file mode 100644index 0000000000..326fd40682--- /dev/null+++ b/server/src/__tests__/secret-provider-registry.test.ts@@ -0,0 +1,70 @@+import { randomBytes } from "node:crypto";+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";+import os from "node:os";+import path from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import { checkSecretProviders, listSecretProviders } from "../secrets/provider-registry.js";++describe("secret provider registry", () => {+ const previousKeyFile = process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE;+ const previousMasterKey = process.env.PAPERCLIP_SECRETS_MASTER_KEY;+ const tmpDirs: string[] = [];++ afterEach(() => {+ if (previousKeyFile === undefined) {+ delete process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE;+ } else {+ process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE = previousKeyFile;+ }+ if (previousMasterKey === undefined) {+ delete process.env.PAPERCLIP_SECRETS_MASTER_KEY;+ } else {+ process.env.PAPERCLIP_SECRETS_MASTER_KEY = previousMasterKey;+ }+ for (const dir of tmpDirs.splice(0)) {+ rmSync(dir, { recursive: true, force: true });+ }+ });++ it("describes managed and external-reference provider capabilities", () => {+ const descriptors = listSecretProviders();++ expect(descriptors).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ id: "local_encrypted",+ supportsManagedValues: true,+ supportsExternalReferences: false,+ configured: true,+ }),+ expect.objectContaining({+ id: "aws_secrets_manager",+ supportsManagedValues: true,+ supportsExternalReferences: true,+ configured: false,+ }),+ ]),+ );+ });++ it("warns when the local encrypted key file is readable by group or others", async () => {+ const dir = path.join(os.tmpdir(), `paperclip-secret-provider-${randomBytes(6).toString("hex")}`);+ tmpDirs.push(dir);+ mkdirSync(dir, { recursive: true });+ const keyFile = path.join(dir, "master.key");+ writeFileSync(keyFile, randomBytes(32).toString("base64"), { encoding: "utf8", mode: 0o644 });+ chmodSync(keyFile, 0o644);+ process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE = keyFile;+ delete process.env.PAPERCLIP_SECRETS_MASTER_KEY;++ const checks = await checkSecretProviders();+ const local = checks.find((check) => check.provider === "local_encrypted");++ expect(local).toMatchObject({+ status: "warn",+ details: { keyFilePath: keyFile },+ });+ expect(local?.warnings?.join("\n")).toContain("chmod 600");+ expect(local?.backupGuidance?.join("\n")).toContain("database");+ });+});diff --git a/server/src/__tests__/secrets-routes.test.ts b/server/src/__tests__/secrets-routes.test.tsnew file mode 100644index 0000000000..86d4b7cb1e--- /dev/null+++ b/server/src/__tests__/secrets-routes.test.ts@@ -0,0 +1,454 @@+import express from "express";+import request from "supertest";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { secretRoutes } from "../routes/secrets.js";+import { errorHandler } from "../middleware/error-handler.js";+import { HttpError, unprocessable } from "../errors.js";++const mockSecretService = vi.hoisted(() => ({+ listProviders: vi.fn(),+ checkProviders: vi.fn(),+ listProviderConfigs: vi.fn(),+ getProviderConfigById: vi.fn(),+ createProviderConfig: vi.fn(),+ updateProviderConfig: vi.fn(),+ disableProviderConfig: vi.fn(),+ setDefaultProviderConfig: vi.fn(),+ checkProviderConfigHealth: vi.fn(),+ getById: vi.fn(),+ create: vi.fn(),+ update: vi.fn(),+ remove: vi.fn(),+ previewRemoteImport: vi.fn(),+ importRemoteSecrets: vi.fn(),+}));+const mockLogActivity = vi.hoisted(() => vi.fn());++vi.mock("../services/index.js", () => ({+ secretService: () => mockSecretService,+ logActivity: mockLogActivity,+}));++function createApp(actor: Record<string, unknown> = {+ type: "board",+ userId: "user-1",+ source: "session",+ companyIds: ["company-1"],+ memberships: [{ companyId: "company-1", status: "active", membershipRole: "admin" }],+}) {+ const app = express();+ app.use(express.json());+ app.use((req, _res, next) => {+ (req as any).actor = actor;+ next();+ });+ app.use("/api", secretRoutes({} as any));+ app.use(errorHandler);+ return app;+}++describe("secret routes", () => {+ beforeEach(() => {+ for (const mock of Object.values(mockSecretService)) {+ mock.mockReset();+ }+ mockLogActivity.mockReset();+ });++ it("returns provider health checks for board callers with company access", async () => {+ mockSecretService.checkProviders.mockResolvedValue([+ {+ provider: "local_encrypted",+ status: "ok",+ message: "Local encrypted provider configured",+ backupGuidance: ["Back up the key file together with database backups."],+ },+ ]);++ const res = await request(createApp()).get("/api/companies/company-1/secret-providers/health");++ expect(res.status).toBe(200);+ expect(res.body).toEqual({+ providers: [+ {+ provider: "local_encrypted",+ status: "ok",+ message: "Local encrypted provider configured",+ backupGuidance: ["Back up the key file together with database backups."],+ },+ ],+ });+ });++ it("rejects managed secret creation when externalRef is supplied", async () => {+ const res = await request(createApp()).post("/api/companies/company-1/secrets").send({+ name: "OpenAI API Key",+ managedMode: "paperclip_managed",+ value: "secret-value",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/other",+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/Managed secrets cannot set externalRef/);+ expect(mockSecretService.create).not.toHaveBeenCalled();+ });++ it("rejects provider vault routes for non-board actors", async () => {+ const res = await request(createApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ })).get("/api/companies/company-1/secret-provider-configs");++ expect(res.status).toBe(403);+ expect(mockSecretService.listProviderConfigs).not.toHaveBeenCalled();+ });++ it("rejects provider vault cross-company access before calling the service", async () => {+ const res = await request(createApp({+ type: "board",+ userId: "user-1",+ source: "session",+ companyIds: ["company-2"],+ memberships: [{ companyId: "company-2", status: "active", membershipRole: "admin" }],+ })).get("/api/companies/company-1/secret-provider-configs");++ expect(res.status).toBe(403);+ expect(mockSecretService.listProviderConfigs).not.toHaveBeenCalled();+ });++ it("rejects sensitive provider vault config fields", async () => {+ const res = await request(createApp()).post("/api/companies/company-1/secret-provider-configs").send({+ provider: "aws_secrets_manager",+ displayName: "AWS prod",+ config: {+ region: "us-east-1",+ accessKeyId: "AKIA...",+ },+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/sensitive field/i);+ expect(mockSecretService.createProviderConfig).not.toHaveBeenCalled();+ });++ it("rejects ready status for coming-soon provider vaults", async () => {+ const res = await request(createApp()).post("/api/companies/company-1/secret-provider-configs").send({+ provider: "vault",+ displayName: "Vault draft",+ status: "ready",+ config: {+ address: "https://vault.example.com",+ },+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/locked while coming soon/i);+ expect(mockSecretService.createProviderConfig).not.toHaveBeenCalled();+ });++ it("rejects credential-bearing Vault provider vault addresses before persistence", async () => {+ const res = await request(createApp()).post("/api/companies/company-1/secret-provider-configs").send({+ provider: "vault",+ displayName: "Vault draft",+ config: {+ address: "https://user:[email protected]",+ },+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/origin-only HTTP\(S\) URL/i);+ expect(mockSecretService.createProviderConfig).not.toHaveBeenCalled();+ });++ it.each([+ "https://vault.example.com?token=hvs.x",+ "https://vault.example.com#token=hvs.x",+ ])("rejects token-bearing Vault provider vault address %s before persistence", async (address) => {+ const res = await request(createApp()).post("/api/companies/company-1/secret-provider-configs").send({+ provider: "vault",+ displayName: "Vault draft",+ config: { address },+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/origin-only HTTP\(S\) URL/i);+ expect(mockSecretService.createProviderConfig).not.toHaveBeenCalled();+ });++ it("rejects unsafe Vault provider vault address patches before persistence", async () => {+ const res = await request(createApp()).patch("/api/secret-provider-configs/vault-1").send({+ config: {+ address: "https://vault.example.com#token=hvs.x",+ },+ });++ expect(res.status).toBe(400);+ expect(JSON.stringify(res.body)).toMatch(/origin-only HTTP\(S\) URL/i);+ expect(mockSecretService.getProviderConfigById).not.toHaveBeenCalled();+ expect(mockSecretService.updateProviderConfig).not.toHaveBeenCalled();+ });++ it("creates provider vaults and logs safe activity details", async () => {+ const createdAt = new Date("2026-05-06T00:00:00.000Z");+ mockSecretService.createProviderConfig.mockResolvedValue({+ id: "11111111-1111-4111-8111-111111111111",+ companyId: "company-1",+ provider: "aws_secrets_manager",+ displayName: "AWS prod",+ status: "ready",+ isDefault: true,+ config: { region: "us-east-1" },+ healthStatus: null,+ healthCheckedAt: null,+ healthMessage: null,+ healthDetails: null,+ disabledAt: null,+ createdByAgentId: null,+ createdByUserId: "user-1",+ createdAt,+ updatedAt: createdAt,+ });++ const res = await request(createApp()).post("/api/companies/company-1/secret-provider-configs").send({+ provider: "aws_secrets_manager",+ displayName: "AWS prod",+ isDefault: true,+ config: { region: "us-east-1" },+ });++ expect(res.status).toBe(201);+ expect(mockSecretService.createProviderConfig).toHaveBeenCalledWith(+ "company-1",+ {+ provider: "aws_secrets_manager",+ displayName: "AWS prod",+ status: undefined,+ isDefault: true,+ config: { region: "us-east-1" },+ },+ { userId: "user-1", agentId: null },+ );+ expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({+ action: "secret_provider_config.created",+ details: {+ provider: "aws_secrets_manager",+ displayName: "AWS prod",+ status: "ready",+ isDefault: true,+ },+ }));+ expect(JSON.stringify(mockLogActivity.mock.calls)).not.toContain("accessKey");+ });++ it("rejects remote import preview for non-board actors", async () => {+ const res = await request(createApp({+ type: "agent",+ agentId: "agent-1",+ companyId: "company-1",+ })).post("/api/companies/company-1/secrets/remote-import/preview").send({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ });++ expect(res.status).toBe(403);+ expect(mockSecretService.previewRemoteImport).not.toHaveBeenCalled();+ });++ it("previews remote imports and logs only aggregate metadata", async () => {+ mockSecretService.previewRemoteImport.mockResolvedValue({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ provider: "aws_secrets_manager",+ nextToken: null,+ candidates: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ remoteName: "prod/openai",+ name: "openai",+ key: "openai",+ providerVersionRef: null,+ providerMetadata: { description: "OpenAI API key" },+ status: "ready",+ importable: true,+ conflicts: [],+ },+ ],+ });++ const res = await request(createApp())+ .post("/api/companies/company-1/secrets/remote-import/preview")+ .send({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ query: "openai",+ pageSize: 25,+ });++ expect(res.status).toBe(200);+ expect(mockSecretService.previewRemoteImport).toHaveBeenCalledWith("company-1", {+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ query: "openai",+ nextToken: undefined,+ pageSize: 25,+ });+ expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({+ action: "secret.remote_import.previewed",+ details: {+ provider: "aws_secrets_manager",+ candidateCount: 1,+ readyCount: 1,+ duplicateCount: 0,+ conflictCount: 0,+ },+ }));+ expect(JSON.stringify(mockLogActivity.mock.calls)).not.toContain("prod/openai");+ });++ it("returns sanitized remote import preview provider errors", async () => {+ mockSecretService.previewRemoteImport.mockRejectedValue(+ new HttpError(+ 403,+ "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ { code: "access_denied" },+ ),+ );++ const res = await request(createApp())+ .post("/api/companies/company-1/secrets/remote-import/preview")+ .send({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ });++ expect(res.status).toBe(403);+ expect(res.body).toEqual({+ error: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ details: { code: "access_denied" },+ });+ expect(JSON.stringify(res.body)).not.toContain("arn:aws");+ expect(JSON.stringify(res.body)).not.toContain("123456789012");+ expect(mockLogActivity).not.toHaveBeenCalled();+ });++ it("imports remote references and logs aggregate row counts", async () => {+ mockSecretService.importRemoteSecrets.mockResolvedValue({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ provider: "aws_secrets_manager",+ importedCount: 1,+ skippedCount: 0,+ errorCount: 0,+ results: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ status: "imported",+ reason: null,+ secretId: "22222222-2222-4222-8222-222222222222",+ conflicts: [],+ },+ ],+ });++ const res = await request(createApp())+ .post("/api/companies/company-1/secrets/remote-import")+ .send({+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ description: "Operator-entered Paperclip description",+ },+ ],+ });++ expect(res.status).toBe(200);+ expect(mockSecretService.importRemoteSecrets).toHaveBeenCalledWith(+ "company-1",+ {+ providerConfigId: "11111111-1111-4111-8111-111111111111",+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ description: "Operator-entered Paperclip description",+ },+ ],+ },+ { userId: "user-1", agentId: null },+ );+ expect(mockLogActivity).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({+ action: "secret.remote_import.completed",+ details: {+ provider: "aws_secrets_manager",+ importedCount: 1,+ skippedCount: 0,+ errorCount: 0,+ },+ }));+ expect(JSON.stringify(mockLogActivity.mock.calls)).not.toContain("prod/openai");+ });++ it("surfaces update-route externalRef retarget rejection without logging raw refs", async () => {+ mockSecretService.getById.mockResolvedValue({+ id: "22222222-2222-4222-8222-222222222222",+ companyId: "company-1",+ name: "OpenAI API key",+ key: "openai-api-key",+ provider: "aws_secrets_manager",+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/original",+ });+ mockSecretService.update.mockRejectedValue(+ unprocessable("External reference secrets cannot be retargeted through generic update"),+ );++ const res = await request(createApp())+ .patch("/api/secrets/22222222-2222-4222-8222-222222222222")+ .send({+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/repointed",+ });++ expect(res.status).toBe(422);+ expect(mockSecretService.update).toHaveBeenCalledWith(+ "22222222-2222-4222-8222-222222222222",+ expect.objectContaining({+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/repointed",+ }),+ );+ expect(mockLogActivity).not.toHaveBeenCalled();+ expect(JSON.stringify(mockLogActivity.mock.calls)).not.toContain("shared/repointed");+ });++ it("allows DELETE to retry cleanup for already soft-deleted secrets", async () => {+ const secret = {+ id: "33333333-3333-4333-8333-333333333333",+ companyId: "company-1",+ name: "OpenAI API Key__deleted__33333333-3333-4333-8333-333333333333",+ key: "openai-api-key__deleted__33333333-3333-4333-8333-333333333333",+ provider: "aws_secrets_manager",+ managedMode: "paperclip_managed",+ status: "deleted",+ };+ mockSecretService.getById.mockResolvedValue(secret);+ mockSecretService.remove.mockResolvedValue(secret);++ const res = await request(createApp()).delete(+ "/api/secrets/33333333-3333-4333-8333-333333333333",+ );++ expect(res.status).toBe(200);+ expect(res.body).toEqual({ ok: true });+ expect(mockSecretService.remove).toHaveBeenCalledWith(+ "33333333-3333-4333-8333-333333333333",+ );+ expect(mockLogActivity).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ action: "secret.deleted",+ companyId: "company-1",+ entityId: secret.id,+ }),+ );+ });+});diff --git a/server/src/__tests__/secrets-service.test.ts b/server/src/__tests__/secrets-service.test.tsnew file mode 100644index 0000000000..01f1304165--- /dev/null+++ b/server/src/__tests__/secrets-service.test.ts@@ -0,0 +1,1672 @@+import { randomUUID } from "node:crypto";+import { mkdirSync, rmSync } from "node:fs";+import os from "node:os";+import path from "node:path";+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";+import { eq } from "drizzle-orm";+import {+ agents,+ companies,+ companySecretBindings,+ companySecretProviderConfigs,+ companySecretVersions,+ companySecrets,+ createDb,+ secretAccessEvents,+} from "@paperclipai/db";+import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js";+import { awsSecretsManagerProvider } from "../secrets/aws-secrets-manager-provider.js";+import { localEncryptedProvider } from "../secrets/local-encrypted-provider.js";+import { SecretProviderClientError } from "../secrets/types.js";+import { secretService } from "../services/secrets.js";++const embeddedPostgresSupport = await getEmbeddedPostgresTestSupport();+const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip;++if (!embeddedPostgresSupport.supported) {+ console.warn(+ `Skipping secrets service tests on this host: ${embeddedPostgresSupport.reason ?? "unsupported environment"}`,+ );+}++describeEmbeddedPostgres("secretService", () => {+ let stopDb: (() => Promise<void>) | null = null;+ let db!: ReturnType<typeof createDb>;+ const previousKeyFile = process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE;+ const secretsTmpDir = path.join(os.tmpdir(), `paperclip-secrets-service-${randomUUID()}`);++ beforeAll(async () => {+ mkdirSync(secretsTmpDir, { recursive: true });+ process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE = path.join(secretsTmpDir, "master.key");+ const started = await startEmbeddedPostgresTestDatabase("secrets-service");+ stopDb = started.cleanup;+ db = createDb(started.connectionString);+ });++ afterEach(async () => {+ vi.restoreAllMocks();+ await db.delete(secretAccessEvents);+ await db.delete(companySecretBindings);+ await db.delete(companySecretVersions);+ await db.delete(companySecrets);+ await db.delete(companySecretProviderConfigs);+ await db.delete(agents);+ await db.delete(companies);+ });++ afterAll(async () => {+ await stopDb?.();+ if (previousKeyFile === undefined) {+ delete process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE;+ } else {+ process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE = previousKeyFile;+ }+ rmSync(secretsTmpDir, { recursive: true, force: true });+ });++ async function seedCompany(name = "Acme") {+ const companyId = randomUUID();+ await db.insert(companies).values({+ id: companyId,+ name,+ issuePrefix: `T${companyId.slice(0, 7)}`.toUpperCase(),+ status: "active",+ createdAt: new Date(),+ updatedAt: new Date(),+ });+ return companyId;+ }++ it("rejects cross-company secret references during env normalization", async () => {+ const companyA = await seedCompany("A");+ const companyB = await seedCompany("B");+ const svc = secretService(db);+ const foreignSecret = await svc.create(companyB, {+ name: `foreign-${randomUUID()}`,+ provider: "local_encrypted",+ value: "secret-value",+ });++ await expect(+ svc.normalizeEnvBindingsForPersistence(companyA, {+ API_KEY: { type: "secret_ref", secretId: foreignSecret.id, version: "latest" },+ }),+ ).rejects.toThrow(/same company/i);+ });++ it("prevents duplicate bindings for a target config path", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const firstSecret = await svc.create(companyId, {+ name: `first-${randomUUID()}`,+ provider: "local_encrypted",+ value: "one",+ });+ const secondSecret = await svc.create(companyId, {+ name: `second-${randomUUID()}`,+ provider: "local_encrypted",+ value: "two",+ });++ await svc.createBinding({+ companyId,+ secretId: firstSecret.id,+ targetType: "agent",+ targetId: "agent-1",+ configPath: "env.API_KEY",+ });++ await expect(+ svc.createBinding({+ companyId,+ secretId: secondSecret.id,+ targetType: "agent",+ targetId: "agent-1",+ configPath: "env.API_KEY",+ }),+ ).rejects.toThrow(/already exists/i);+ });++ it("reports reference counts and resolves binding target labels", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `referenced-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });+ const [agent] = await db+ .insert(agents)+ .values({+ companyId,+ name: "CodexCoder",+ role: "engineer",+ adapterType: "codex_local",+ adapterConfig: {},+ })+ .returning();++ await svc.syncEnvBindingsForTarget(+ companyId,+ { targetType: "agent", targetId: agent!.id },+ {+ OPENAI_API_KEY: { type: "secret_ref", secretId: secret.id, version: "latest" },+ },+ );++ const listed = await svc.list(companyId);+ expect(listed.find((row) => row.id === secret.id)?.referenceCount).toBe(1);++ const bindings = await svc.listBindingReferences(companyId, secret.id);+ expect(bindings).toHaveLength(1);+ expect(bindings[0]?.target).toMatchObject({+ type: "agent",+ id: agent!.id,+ label: "CodexCoder",+ href: "/agents/codexcoder",+ status: "idle",+ });+ });++ it("enforces binding context and records value-free access events", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `runtime-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });+ const env = {+ API_KEY: { type: "secret_ref" as const, secretId: secret.id, version: "latest" as const },+ };++ await svc.syncEnvBindingsForTarget(companyId, { targetType: "agent", targetId: "agent-1" }, env);++ await expect(+ svc.resolveEnvBindings(companyId, env, {+ consumerType: "agent",+ consumerId: "agent-2",+ actorType: "agent",+ actorId: "agent-2",+ }),+ ).rejects.toThrow(/not bound/i);++ const resolved = await svc.resolveEnvBindings(companyId, env, {+ consumerType: "agent",+ consumerId: "agent-1",+ actorType: "agent",+ actorId: "agent-1",+ });++ expect(resolved.env.API_KEY).toBe("runtime-secret");+ const events = await svc.listAccessEvents(companyId, secret.id);+ expect(events).toHaveLength(2);+ expect(events.map((event) => event.outcome).sort()).toEqual(["failure", "success"]);+ expect(JSON.stringify(events)).not.toContain("runtime-secret");+ });++ it("scopes env binding sync deletes to the env path prefix", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const runtimeSecret = await svc.create(companyId, {+ name: `runtime-ref-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });+ const envSecret = await svc.create(companyId, {+ name: `env-ref-${randomUUID()}`,+ provider: "local_encrypted",+ value: "env-secret",+ });++ await svc.createBinding({+ companyId,+ secretId: runtimeSecret.id,+ targetType: "agent",+ targetId: "agent-1",+ configPath: "runtime.token",+ });+ await svc.syncEnvBindingsForTarget(+ companyId,+ { targetType: "agent", targetId: "agent-1" },+ {+ API_KEY: { type: "secret_ref", secretId: envSecret.id, version: "latest" },+ },+ );+ await svc.syncEnvBindingsForTarget(+ companyId,+ { targetType: "agent", targetId: "agent-1" },+ {},+ );++ const bindings = await db+ .select()+ .from(companySecretBindings)+ .where(eq(companySecretBindings.targetId, "agent-1"));+ expect(bindings.map((binding) => binding.configPath)).toEqual(["runtime.token"]);+ });++ it("returns resolved secrets even when success metadata writes fail", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `metadata-write-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });+ const env = {+ API_KEY: { type: "secret_ref" as const, secretId: secret.id, version: "latest" as const },+ };+ await svc.syncEnvBindingsForTarget(companyId, { targetType: "agent", targetId: "agent-1" }, env);++ vi.spyOn(db, "update").mockImplementationOnce(+ () => ({+ set: () => ({+ where: () => Promise.reject(new Error("metadata write failed")),+ }),+ }) as ReturnType<typeof db.update>,+ );++ const resolved = await svc.resolveEnvBindings(companyId, env, {+ consumerType: "agent",+ consumerId: "agent-1",+ actorType: "agent",+ actorId: "agent-1",+ });++ expect(resolved.env.API_KEY).toBe("runtime-secret");+ });++ it("stores external references without requiring or persisting secret values", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });++ const secret = await svc.create(companyId, {+ name: `external-${randomUUID()}`,+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/test",+ providerVersionRef: "version-1",+ });++ expect(secret.managedMode).toBe("external_reference");+ expect(secret.externalRef).toBe("arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/test");++ const versions = await db+ .select()+ .from(companySecretVersions)+ .where(eq(companySecretVersions.secretId, secret.id));+ expect(versions).toHaveLength(1);+ expect(versions[0]?.providerVersionRef).toBe("version-1");+ expect(JSON.stringify(versions[0])).not.toContain("runtime-secret");+ expect(JSON.stringify(versions[0])).not.toContain("sk-");++ await expect(+ svc.resolveSecretValue(companyId, secret.id, "latest", {+ consumerType: "system",+ consumerId: "system",+ configPath: "env.EXTERNAL_SECRET",+ }),+ ).rejects.toThrow(/not bound/i);+ });++ it("preserves the original resolution error when failure access logging fails", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `resolution-failure-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });+ await svc.createBinding({+ companyId,+ secretId: secret.id,+ targetType: "system",+ targetId: "system",+ configPath: "env.API_KEY",+ });+ vi.spyOn(localEncryptedProvider, "resolveVersion").mockRejectedValueOnce(+ new Error("provider resolution failed"),+ );++ await expect(+ svc.resolveSecretValue(companyId, secret.id, "latest", {+ consumerType: "system",+ consumerId: "system",+ configPath: "env.API_KEY",+ heartbeatRunId: randomUUID(),+ }),+ ).rejects.toThrow("provider resolution failed");+ });++ it("keeps one default provider vault per company provider", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);++ const first = await svc.createProviderConfig(companyId, {+ provider: "local_encrypted",+ displayName: "Local primary",+ isDefault: true,+ config: {},+ });+ const second = await svc.createProviderConfig(companyId, {+ provider: "local_encrypted",+ displayName: "Local secondary",+ isDefault: true,+ config: {},+ });++ const rows = await svc.listProviderConfigs(companyId);+ expect(rows.find((row) => row.id === first.id)?.isDefault).toBe(false);+ expect(rows.find((row) => row.id === second.id)?.isDefault).toBe(true);+ });++ it("does not set a disabled provider vault as default", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const vault = await svc.createProviderConfig(companyId, {+ provider: "local_encrypted",+ displayName: "Local disabled",+ config: {},+ });++ await svc.disableProviderConfig(vault.id);+ await expect(svc.setDefaultProviderConfig(vault.id)).rejects.toThrow(+ /ready or warning/i,+ );+ });++ it("hides soft-deleted secrets and allows name/key reuse", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secretName = `reusable-${randomUUID()}`;+ const secret = await svc.create(companyId, {+ name: secretName,+ key: "reusable-key",+ provider: "local_encrypted",+ value: "first-value",+ });++ await svc.remove(secret.id);+ const listed = await svc.list(companyId);+ const recreated = await svc.create(companyId, {+ name: secretName,+ key: "reusable-key",+ provider: "local_encrypted",+ value: "second-value",+ });++ expect(listed.map((row) => row.id)).not.toContain(secret.id);+ expect(recreated.id).not.toBe(secret.id);+ expect(recreated.name).toBe(secretName);+ expect(recreated.key).toBe("reusable-key");+ });++ it("rejects bindings and env refs to soft-deleted external reference secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const deleted = await svc.create(companyId, {+ name: "Deleted external",+ key: "deleted-external",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/deleted",+ });+ await svc.update(deleted.id, { status: "deleted" });++ await expect(+ svc.createBinding({+ companyId,+ secretId: deleted.id,+ targetType: "agent",+ targetId: "agent-1",+ configPath: "env.API_KEY",+ }),+ ).rejects.toThrow(/not found/i);+ await expect(+ svc.normalizeEnvBindingsForPersistence(companyId, {+ API_KEY: { type: "secret_ref", secretId: deleted.id, version: "latest" },+ }),+ ).rejects.toThrow(/not found/i);+ });++ it("rejects updates to already soft-deleted external reference secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const deleted = await svc.create(companyId, {+ name: "Deleted patch target",+ key: "deleted-patch-target",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/deleted-patch-target",+ });+ await svc.update(deleted.id, { status: "deleted" });++ await expect(svc.update(deleted.id, { status: "active" })).rejects.toThrow(+ /not found/i,+ );+ });++ it("allows re-importing a remote secret after the prior external reference is soft-deleted", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const externalRef =+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/reimportable";+ const deleted = await svc.create(companyId, {+ name: "Deleted external",+ key: "deleted-external",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef,+ });++ await svc.update(deleted.id, { status: "deleted" });+ vi.spyOn(awsSecretsManagerProvider, "listRemoteSecrets").mockResolvedValue({+ secrets: [+ {+ externalRef,+ name: "prod/reimportable",+ providerVersionRef: null,+ metadata: { arn: externalRef },+ },+ ],+ });++ const preview = await svc.previewRemoteImport(companyId, {+ providerConfigId: awsVault.id,+ });+ const result = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef,+ name: "Reimported external",+ key: "reimported-external",+ },+ ],+ });++ expect(preview.candidates[0]).toMatchObject({+ status: "ready",+ importable: true,+ conflicts: [],+ });+ expect(result).toMatchObject({ importedCount: 1, skippedCount: 0, errorCount: 0 });+ });++ it("ignores soft-deleted name and key conflicts during remote import", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const deleted = await svc.create(companyId, {+ name: "Deleted external",+ key: "deleted-external",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/deleted-old",+ });+ await svc.update(deleted.id, { status: "deleted" });+ vi.spyOn(awsSecretsManagerProvider, "listRemoteSecrets").mockResolvedValue({+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/deleted-new",+ name: "Deleted external",+ providerVersionRef: null,+ metadata: {},+ },+ ],+ });++ const preview = await svc.previewRemoteImport(companyId, {+ providerConfigId: awsVault.id,+ });+ const result = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/deleted-new",+ name: "Deleted external",+ key: "deleted-external",+ },+ ],+ });++ expect(preview.candidates[0]).toMatchObject({+ status: "ready",+ importable: true,+ conflicts: [],+ });+ expect(result).toMatchObject({ importedCount: 1, skippedCount: 0, errorCount: 0 });+ });++ it("rejects provider vaults from another company when creating a secret", async () => {+ const companyA = await seedCompany("A");+ const companyB = await seedCompany("B");+ const svc = secretService(db);+ const foreignVault = await svc.createProviderConfig(companyB, {+ provider: "local_encrypted",+ displayName: "Foreign vault",+ config: {},+ });++ await expect(+ svc.create(companyA, {+ name: `managed-${randomUUID()}`,+ provider: "local_encrypted",+ providerConfigId: foreignVault.id,+ value: "runtime-secret",+ }),+ ).rejects.toThrow(/same company/i);+ });++ it("blocks coming-soon provider vaults from secret selection", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const draftVault = await svc.createProviderConfig(companyId, {+ provider: "gcp_secret_manager",+ displayName: "GCP draft",+ config: { projectId: "paperclip-prod1" },+ });++ expect(draftVault.status).toBe("coming_soon");+ await expect(+ svc.create(companyId, {+ name: `draft-${randomUUID()}`,+ provider: "gcp_secret_manager",+ providerConfigId: draftVault.id,+ value: "runtime-secret",+ }),+ ).rejects.toThrow(/coming soon/i);+ });++ it("passes selected provider vault config through create, rotate, and resolve", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: {+ region: "us-east-1",+ namespace: "prod-use1",+ secretNamePrefix: "paperclip",+ },+ });++ const createSpy = vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/openai-api-key",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/openai-api-key",+ providerVersionRef: "aws-version-1",+ });+ const createVersionSpy = vi.spyOn(awsSecretsManagerProvider, "createVersion").mockResolvedValue({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/openai-api-key",+ versionId: "aws-version-2",+ source: "managed",+ },+ valueSha256: "value-sha-2",+ fingerprintSha256: "fingerprint-sha-2",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/openai-api-key",+ providerVersionRef: "aws-version-2",+ });+ const resolveSpy = vi.spyOn(awsSecretsManagerProvider, "resolveVersion").mockResolvedValue("resolved-secret");++ const secret = await svc.create(companyId, {+ name: `aws-managed-${randomUUID()}`,+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ value: "runtime-secret",+ });+ const rotated = await svc.rotate(secret.id, { value: "rotated-runtime-secret" });+ const resolved = await svc.resolveSecretValue(companyId, rotated.id, "latest");++ expect(resolved).toBe("resolved-secret");+ expect(createSpy).toHaveBeenCalledWith(expect.objectContaining({+ providerConfig: expect.objectContaining({+ id: awsVault.id,+ provider: "aws_secrets_manager",+ config: expect.objectContaining({ region: "us-east-1", namespace: "prod-use1" }),+ }),+ }));+ expect(createVersionSpy).toHaveBeenCalledWith(expect.objectContaining({+ providerConfig: expect.objectContaining({ id: awsVault.id }),+ }));+ expect(resolveSpy).toHaveBeenCalledWith(expect.objectContaining({+ providerConfig: expect.objectContaining({ id: awsVault.id }),+ providerVersionRef: "aws-version-2",+ }));+ expect(JSON.stringify(resolveSpy.mock.calls[0]?.[0])).not.toContain("resolved-secret");+ });++ it("cleans up managed provider secrets when create persistence fails", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const prepared = {+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/create-rollback",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/create-rollback",+ providerVersionRef: "aws-version-1",+ };+ vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue(prepared);+ const deleteSpy = vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockResolvedValue();+ vi.spyOn(db, "transaction").mockRejectedValueOnce(new Error("db insert failed"));++ await expect(+ svc.create(companyId, {+ name: "Create Rollback",+ key: "create-rollback",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ value: "runtime-secret",+ }),+ ).rejects.toThrow("db insert failed");++ expect(deleteSpy).toHaveBeenCalledWith(expect.objectContaining({+ material: prepared.material,+ externalRef: prepared.externalRef,+ mode: "delete",+ providerConfig: expect.objectContaining({ id: awsVault.id }),+ context: {+ companyId,+ secretKey: "create-rollback",+ secretName: "Create Rollback",+ version: 1,+ },+ }));+ });++ it("keeps a local cleanup handle when create rollback cleanup fails", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const prepared = {+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/create-cleanup-handle",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/create-cleanup-handle",+ providerVersionRef: "aws-version-1",+ };+ vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue(prepared);+ vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockRejectedValue(+ new Error("cleanup failed"),+ );+ vi.spyOn(db, "transaction").mockRejectedValueOnce(new Error("db activate failed"));++ await expect(+ svc.create(companyId, {+ name: "Create Cleanup Handle",+ key: "create-cleanup-handle",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ value: "runtime-secret",+ }),+ ).rejects.toThrow("db activate failed");++ const persisted = await svc.getByName(companyId, "Create Cleanup Handle");+ expect(persisted).toMatchObject({+ key: "create-cleanup-handle",+ status: "archived",+ externalRef: prepared.externalRef,+ latestVersion: 1,+ });++ const version = await db+ .select()+ .from(companySecretVersions)+ .where(eq(companySecretVersions.secretId, persisted!.id))+ .then((rows) => rows[0] ?? null);+ expect(version).toMatchObject({+ version: 1,+ status: "disabled",+ material: prepared.material,+ });+ });++ it("archives managed provider versions when rotate persistence fails", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-rollback",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-rollback",+ providerVersionRef: "aws-version-1",+ });+ const secret = await svc.create(companyId, {+ name: "Rotate Rollback",+ key: "rotate-rollback",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ value: "runtime-secret",+ });+ const prepared = {+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-rollback",+ versionId: "aws-version-2",+ source: "managed",+ },+ valueSha256: "value-sha-2",+ fingerprintSha256: "fingerprint-sha-2",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-rollback",+ providerVersionRef: "aws-version-2",+ };+ vi.spyOn(awsSecretsManagerProvider, "createVersion").mockResolvedValue(prepared);+ const deleteSpy = vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockResolvedValue();+ vi.spyOn(db, "transaction").mockRejectedValueOnce(new Error("db rotate failed"));++ await expect(svc.rotate(secret.id, { value: "rotated-runtime-secret" })).rejects.toThrow(+ "db rotate failed",+ );++ expect(deleteSpy).toHaveBeenCalledWith(expect.objectContaining({+ material: prepared.material,+ externalRef: prepared.externalRef,+ mode: "archive",+ providerConfig: expect.objectContaining({ id: awsVault.id }),+ context: {+ companyId,+ secretKey: "rotate-rollback",+ secretName: "Rotate Rollback",+ version: 2,+ },+ }));+ });++ it("keeps a disabled version cleanup handle when rotate rollback cleanup fails", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-cleanup-handle",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-cleanup-handle",+ providerVersionRef: "aws-version-1",+ });+ const secret = await svc.create(companyId, {+ name: "Rotate Cleanup Handle",+ key: "rotate-cleanup-handle",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ value: "runtime-secret",+ });+ const prepared = {+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-cleanup-handle",+ versionId: "aws-version-2",+ source: "managed",+ },+ valueSha256: "value-sha-2",+ fingerprintSha256: "fingerprint-sha-2",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/rotate-cleanup-handle",+ providerVersionRef: "aws-version-2",+ };+ vi.spyOn(awsSecretsManagerProvider, "createVersion").mockResolvedValue(prepared);+ vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockRejectedValue(+ new Error("cleanup failed"),+ );+ vi.spyOn(db, "transaction").mockRejectedValueOnce(new Error("db rotate failed"));++ await expect(svc.rotate(secret.id, { value: "rotated-runtime-secret" })).rejects.toThrow(+ "db rotate failed",+ );++ const persisted = await svc.getById(secret.id);+ expect(persisted?.latestVersion).toBe(1);++ const versions = await db+ .select()+ .from(companySecretVersions)+ .where(eq(companySecretVersions.secretId, secret.id));+ expect(versions).toEqual(expect.arrayContaining([+ expect.objectContaining({ version: 1, status: "current" }),+ expect.objectContaining({+ version: 2,+ status: "disabled",+ material: prepared.material,+ }),+ ]));+ });++ it("rejects generic provider vault reassignment for managed secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const firstVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS primary",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const secondVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS secondary",+ config: { region: "us-west-2", namespace: "prod-usw2" },+ });+ vi.spyOn(awsSecretsManagerProvider, "createSecret").mockResolvedValue({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/vault-reassign",+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company/vault-reassign",+ providerVersionRef: "aws-version-1",+ });+ const secret = await svc.create(companyId, {+ name: "Vault Reassign",+ key: "vault-reassign",+ provider: "aws_secrets_manager",+ providerConfigId: firstVault.id,+ value: "runtime-secret",+ });++ await expect(svc.update(secret.id, { providerConfigId: secondVault.id })).rejects.toThrow(+ /managed secrets cannot change provider vault/i,+ );+ const persisted = await svc.getById(secret.id);+ expect(persisted?.providerConfigId).toBe(firstVault.id);+ });++ it("rejects rotation for non-active secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `disabled-rotation-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });++ await svc.update(secret.id, { status: "disabled" });+ await expect(svc.rotate(secret.id, { value: "rotated-runtime-secret" })).rejects.toThrow(+ /non-active/i,+ );++ const stored = await db+ .select({ latestVersion: companySecrets.latestVersion })+ .from(companySecrets)+ .where(eq(companySecrets.id, secret.id))+ .then((rows) => rows[0]);+ expect(stored?.latestVersion).toBe(1);+ });++ it("previews AWS remote import candidates with duplicate and collision enrichment", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const duplicate = await svc.create(companyId, {+ name: "Existing duplicate",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/duplicate",+ });+ const nameConflict = await svc.create(companyId, {+ name: "Prod Conflict",+ provider: "local_encrypted",+ value: "runtime-secret",+ });++ const listSpy = vi.spyOn(awsSecretsManagerProvider, "listRemoteSecrets").mockResolvedValue({+ nextToken: "next-page",+ secrets: [+ {+ externalRef: duplicate.externalRef!,+ name: "prod/duplicate",+ providerVersionRef: null,+ metadata: { arn: duplicate.externalRef },+ },+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/conflict",+ name: nameConflict.name,+ providerVersionRef: null,+ metadata: { arn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/conflict" },+ },+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/ready",+ name: "prod/ready",+ providerVersionRef: null,+ metadata: { arn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/ready" },+ },+ ],+ });++ const preview = await svc.previewRemoteImport(companyId, {+ providerConfigId: awsVault.id,+ query: "prod",+ pageSize: 25,+ });++ expect(listSpy).toHaveBeenCalledWith(expect.objectContaining({+ providerConfig: expect.objectContaining({ id: awsVault.id }),+ query: "prod",+ pageSize: 25,+ }));+ expect(preview.nextToken).toBe("next-page");+ expect(preview.candidates.map((candidate) => candidate.status)).toEqual([+ "duplicate",+ "conflict",+ "ready",+ ]);+ expect(preview.candidates[0]?.conflicts[0]).toMatchObject({+ type: "exact_reference",+ existingSecretId: duplicate.id,+ });+ expect(preview.candidates[1]?.conflicts[0]).toMatchObject({+ type: "name",+ existingSecretId: nameConflict.id,+ });+ expect(preview.candidates[2]).toMatchObject({+ importable: true,+ name: "prod/ready",+ key: "prod-ready",+ });+ expect(preview.candidates[2]?.providerMetadata).toBeNull();+ });++ it("sanitizes AWS remote import preview provider errors before crossing the service boundary", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const rawProviderMessage =+ "AccessDeniedException: User: arn:aws:sts::123456789012:assumed-role/prod/Paperclip is not authorized to perform secretsmanager:ListSecrets";++ vi.spyOn(awsSecretsManagerProvider, "listRemoteSecrets").mockRejectedValueOnce(+ new SecretProviderClientError({+ code: "access_denied",+ provider: "aws_secrets_manager",+ operation: "listSecrets",+ message: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ rawMessage: rawProviderMessage,+ }),+ );++ let thrown: unknown;+ try {+ await svc.previewRemoteImport(companyId, { providerConfigId: awsVault.id });+ } catch (error) {+ thrown = error;+ }++ expect(thrown).toMatchObject({+ status: 403,+ message: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ details: { code: "access_denied" },+ });+ expect(JSON.stringify(thrown)).not.toContain("arn:aws");+ expect(JSON.stringify(thrown)).not.toContain("123456789012");+ expect(thrown instanceof Error ? thrown.message : String(thrown)).not.toContain("arn:aws");+ });++ it("imports AWS remote references row-by-row without fetching plaintext", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const duplicate = await svc.create(companyId, {+ name: "Existing duplicate",+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/duplicate",+ });++ const resolveSpy = vi.spyOn(awsSecretsManagerProvider, "resolveVersion");+ const result = await svc.importRemoteSecrets(+ companyId,+ {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef: duplicate.externalRef!,+ name: "Existing duplicate",+ key: "existing-duplicate",+ },+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ description: " Operator-entered production OpenAI key ",+ providerMetadata: { arn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai" },+ },+ ],+ },+ { userId: "user-1" },+ );++ expect(result.importedCount).toBe(1);+ expect(result.skippedCount).toBe(1);+ expect(result.results.map((row) => row.status)).toEqual(["skipped", "imported"]);+ expect(result.results[0]).toMatchObject({+ reason: "exact_reference_duplicate",+ conflicts: [expect.objectContaining({ type: "exact_reference", existingSecretId: duplicate.id })],+ });+ expect(resolveSpy).not.toHaveBeenCalled();++ const imported = await db+ .select()+ .from(companySecrets)+ .where(eq(companySecrets.key, "openai-api-key"))+ .then((rows) => rows[0]);+ expect(imported).toMatchObject({+ companyId,+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ createdByUserId: "user-1",+ providerMetadata: null,+ description: "Operator-entered production OpenAI key",+ });++ const versions = await db+ .select()+ .from(companySecretVersions)+ .where(eq(companySecretVersions.secretId, imported!.id));+ expect(versions).toHaveLength(1);+ expect(JSON.stringify(versions[0])).not.toContain("runtime-secret");+ expect(JSON.stringify(versions[0])).not.toContain("sk-");+ });++ it("sanitizes AWS remote import row provider errors", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const rawProviderMessage =+ "AccessDeniedException: User: arn:aws:sts::123456789012:assumed-role/prod/Paperclip is not authorized to perform secretsmanager:DescribeSecret on arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai";+ vi.spyOn(awsSecretsManagerProvider, "linkExternalSecret").mockRejectedValueOnce(+ new SecretProviderClientError({+ code: "access_denied",+ provider: "aws_secrets_manager",+ operation: "linkExternalSecret",+ message: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ rawMessage: rawProviderMessage,+ }),+ );++ const result = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ },+ ],+ });++ expect(result).toMatchObject({+ importedCount: 0,+ skippedCount: 0,+ errorCount: 1,+ results: [+ expect.objectContaining({+ status: "error",+ reason: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ }),+ ],+ });+ expect(JSON.stringify(result)).not.toContain(rawProviderMessage);+ expect(JSON.stringify(result.results[0]?.reason)).not.toContain("arn:aws");+ expect(JSON.stringify(result.results[0]?.reason)).not.toContain("123456789012");+ });++ it("rejects Paperclip-managed AWS namespace refs during preview and import commit", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });++ vi.spyOn(awsSecretsManagerProvider, "listRemoteSecrets").mockResolvedValue({+ secrets: [+ {+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-b/openai",+ name: "paperclip/prod-use1/company-b/openai",+ providerVersionRef: null,+ metadata: {+ arn: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-b/openai",+ description: "must not leak",+ tags: [{ Key: "paperclip:company-id", Value: "company-b" }],+ },+ },+ ],+ });++ const preview = await svc.previewRemoteImport(companyId, {+ providerConfigId: awsVault.id,+ });++ expect(preview.candidates[0]).toMatchObject({+ status: "conflict",+ importable: false,+ conflicts: [expect.objectContaining({ type: "provider_guardrail" })],+ providerMetadata: null,+ });+ expect(JSON.stringify(preview)).not.toContain("must not leak");+ expect(JSON.stringify(preview)).not.toContain("paperclip:company-id");++ const result = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef:+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-b/openai",+ name: "Foreign managed secret",+ key: "foreign-managed-secret",+ providerMetadata: {+ description: "client-submitted metadata must not persist",+ tags: [{ Key: "paperclip:company-id", Value: "company-b" }],+ },+ },+ ],+ });++ expect(result).toMatchObject({+ importedCount: 0,+ skippedCount: 0,+ errorCount: 1,+ results: [expect.objectContaining({ status: "error" })],+ });+ expect(result.results[0]?.reason).toMatch(/Paperclip-managed namespace/i);+ const imported = await db.select().from(companySecrets).where(eq(companySecrets.key, "foreign-managed-secret"));+ expect(imported).toHaveLength(0);+ });++ it("skips duplicate AWS remote imports for the same provider vault and canonical ref", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });++ const first = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ },+ ],+ });+ const second = await svc.importRemoteSecrets(companyId, {+ providerConfigId: awsVault.id,+ secrets: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/openai",+ name: "OpenAI API key duplicate",+ key: "openai-api-key-duplicate",+ },+ ],+ });++ expect(first.importedCount).toBe(1);+ expect(second).toMatchObject({+ importedCount: 0,+ skippedCount: 1,+ errorCount: 0,+ results: [expect.objectContaining({ reason: "exact_reference_duplicate" })],+ });+ const imported = await db.select().from(companySecrets).where(eq(companySecrets.providerConfigId, awsVault.id));+ expect(imported).toHaveLength(1);+ });++ it("rejects remote import for disabled or cross-company provider vaults", async () => {+ const companyA = await seedCompany("A");+ const companyB = await seedCompany("B");+ const svc = secretService(db);+ const disabledVault = await svc.createProviderConfig(companyA, {+ provider: "aws_secrets_manager",+ displayName: "AWS disabled",+ status: "disabled",+ config: { region: "us-east-1" },+ });+ const foreignVault = await svc.createProviderConfig(companyB, {+ provider: "aws_secrets_manager",+ displayName: "AWS foreign",+ config: { region: "us-east-1" },+ });++ await expect(+ svc.previewRemoteImport(companyA, { providerConfigId: disabledVault.id }),+ ).rejects.toThrow(/disabled/i);+ await expect(+ svc.previewRemoteImport(companyA, { providerConfigId: foreignVault.id }),+ ).rejects.toThrow(/same company/i);+ });++ it("rejects externalRef overrides on managed secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `managed-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });++ await expect(+ svc.update(secret.id, {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/company-b/openai-api-key",+ }),+ ).rejects.toThrow(/Managed secrets cannot override externalRef/i);++ await expect(+ svc.rotate(secret.id, {+ value: "rotated-runtime-secret",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/company-b/openai-api-key",+ }),+ ).rejects.toThrow(/Managed secrets cannot override externalRef/i);+ });++ it("rejects generic update retargeting for external reference secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const awsVault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ config: { region: "us-east-1", namespace: "prod-use1" },+ });+ const secret = await svc.create(companyId, {+ name: `external-${randomUUID()}`,+ provider: "aws_secrets_manager",+ providerConfigId: awsVault.id,+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/original",+ });++ await expect(+ svc.update(secret.id, {+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/repointed",+ }),+ ).rejects.toThrow(/cannot be retargeted/i);++ const persisted = await svc.getById(secret.id);+ expect(persisted?.externalRef).toBe(+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:shared/original",+ );+ });++ it("rejects generic soft deletion for managed secrets", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `managed-delete-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });++ await expect(svc.update(secret.id, { status: "deleted" })).rejects.toThrow(+ /DELETE \/secrets\/:id/i,+ );++ const persisted = await svc.getById(secret.id);+ expect(persisted?.status).toBe("active");+ });++ it("passes managed AWS secret context into provider delete during removal", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const externalRef =+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/openai-api-key";++ const secret = await db+ .insert(companySecrets)+ .values({+ companyId,+ key: "openai-api-key",+ name: "OpenAI API Key",+ provider: "aws_secrets_manager",+ managedMode: "paperclip_managed",+ externalRef,+ latestVersion: 1,+ status: "active",+ })+ .returning()+ .then((rows) => rows[0]);++ await db.insert(companySecretVersions).values({+ secretId: secret.id,+ version: 1,+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: externalRef,+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ providerVersionRef: "aws-version-1",+ status: "current",+ });++ const deleteSpy = vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockResolvedValue();++ const removed = await svc.remove(secret.id);+ const persisted = await db+ .select()+ .from(companySecrets)+ .where(eq(companySecrets.id, secret.id))+ .then((rows) => rows[0] ?? null);++ expect(removed?.id).toBe(secret.id);+ expect(deleteSpy).toHaveBeenCalledTimes(1);+ expect(deleteSpy).toHaveBeenCalledWith({+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: externalRef,+ versionId: "aws-version-1",+ source: "managed",+ },+ externalRef,+ context: {+ companyId,+ secretKey: "openai-api-key",+ secretName: "OpenAI API Key",+ version: 1,+ },+ mode: "delete",+ providerConfig: null,+ });+ expect(persisted).toBeNull();+ });++ it("renames name and key during removal before provider deletion", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const externalRef =+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/remove-failure";+ const secret = await db+ .insert(companySecrets)+ .values({+ companyId,+ key: "remove-failure",+ name: "Remove Failure",+ provider: "aws_secrets_manager",+ managedMode: "paperclip_managed",+ externalRef,+ latestVersion: 1,+ status: "active",+ })+ .returning()+ .then((rows) => rows[0]);++ await db.insert(companySecretVersions).values({+ secretId: secret.id,+ version: 1,+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: externalRef,+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ providerVersionRef: "aws-version-1",+ status: "current",+ });+ vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockRejectedValueOnce(+ new Error("provider delete failed"),+ );++ await expect(svc.remove(secret.id)).rejects.toThrow("provider delete failed");+ const persisted = await db+ .select()+ .from(companySecrets)+ .where(eq(companySecrets.id, secret.id))+ .then((rows) => rows[0] ?? null);+ const recreated = await svc.create(companyId, {+ name: "Remove Failure",+ key: "remove-failure",+ provider: "local_encrypted",+ value: "replacement",+ });++ expect(persisted).toMatchObject({+ status: "deleted",+ key: `remove-failure__deleted__${secret.id}`,+ name: `Remove Failure__deleted__${secret.id}`,+ });+ expect(recreated.id).not.toBe(secret.id);+ });++ it("treats missing provider secrets as already removed during removal retry", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const externalRef =+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod-use1/company-1/retry-delete";+ const secretId = randomUUID();+ await db.insert(companySecrets).values({+ id: secretId,+ companyId,+ key: `retry-delete__deleted__${secretId}`,+ name: `Retry Delete__deleted__${secretId}`,+ provider: "aws_secrets_manager",+ managedMode: "paperclip_managed",+ externalRef,+ latestVersion: 1,+ status: "deleted",+ deletedAt: new Date(),+ });+ await db.insert(companySecretVersions).values({+ secretId,+ version: 1,+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: externalRef,+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ providerVersionRef: "aws-version-1",+ status: "current",+ });+ const deleteSpy = vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockRejectedValueOnce(+ new SecretProviderClientError({+ code: "not_found",+ provider: "aws_secrets_manager",+ operation: "delete_secret",+ message: "Secret not found.",+ }),+ );++ await expect(svc.remove(secretId)).resolves.toMatchObject({ id: secretId });+ const persisted = await db+ .select()+ .from(companySecrets)+ .where(eq(companySecrets.id, secretId))+ .then((rows) => rows[0] ?? null);++ expect(deleteSpy).toHaveBeenCalledTimes(1);+ expect(persisted).toBeNull();+ });++ it("removes DB rows even when the attached provider vault is disabled", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const vault = await svc.createProviderConfig(companyId, {+ provider: "aws_secrets_manager",+ displayName: "AWS disabled later",+ config: {+ region: "us-east-1",+ namespace: "prod",+ },+ });+ const externalRef =+ "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/company-1/openai-api-key";+ const secret = await db+ .insert(companySecrets)+ .values({+ companyId,+ key: "openai-api-key",+ name: "OpenAI API Key",+ provider: "aws_secrets_manager",+ providerConfigId: vault.id,+ managedMode: "paperclip_managed",+ externalRef,+ latestVersion: 1,+ status: "active",+ })+ .returning()+ .then((rows) => rows[0]);++ await db.insert(companySecretVersions).values({+ secretId: secret.id,+ version: 1,+ material: {+ scheme: "aws_secrets_manager_v1",+ secretId: externalRef,+ versionId: "aws-version-1",+ source: "managed",+ },+ valueSha256: "value-sha-1",+ fingerprintSha256: "fingerprint-sha-1",+ providerVersionRef: "aws-version-1",+ status: "current",+ });+ await svc.disableProviderConfig(vault.id);+ const deleteSpy = vi.spyOn(awsSecretsManagerProvider, "deleteOrArchive").mockResolvedValue();++ await expect(svc.remove(secret.id)).resolves.toMatchObject({ id: secret.id });+ const persisted = await db+ .select()+ .from(companySecrets)+ .where(eq(companySecrets.id, secret.id))+ .then((rows) => rows[0] ?? null);++ expect(deleteSpy).not.toHaveBeenCalled();+ expect(persisted).toBeNull();+ });++ it("refuses to resolve secrets once they are disabled or archived", async () => {+ const companyId = await seedCompany();+ const svc = secretService(db);+ const secret = await svc.create(companyId, {+ name: `managed-${randomUUID()}`,+ provider: "local_encrypted",+ value: "runtime-secret",+ });++ await svc.update(secret.id, { status: "disabled" });+ await expect(svc.resolveSecretValue(companyId, secret.id, "latest")).rejects.toThrow(+ /not active/i,+ );++ await svc.update(secret.id, { status: "archived" });+ await expect(svc.resolveSecretValue(companyId, secret.id, "latest")).rejects.toThrow(+ /not active/i,+ );+ });+});diff --git a/server/src/config.ts b/server/src/config.tsindex 77b8a3f0cf..90d6cbf6b1 100644--- a/server/src/config.ts+++ b/server/src/config.ts@@ -120,11 +120,6 @@ export function loadConfig(): Config {const fileDatabaseBackup = fileConfig?.database.backup;const fileSecrets = fileConfig?.secrets;const fileStorage = fileConfig?.storage;- const strictModeFromEnv = process.env.PAPERCLIP_SECRETS_STRICT_MODE;- const secretsStrictMode =- strictModeFromEnv !== undefined- ? strictModeFromEnv === "true"- : (fileSecrets?.strictMode ?? false);const providerFromEnvRaw = process.env.PAPERCLIP_SECRETS_PROVIDER;const providerFromEnv =@@ -168,6 +163,11 @@ export function loadConfig(): Config {? (deploymentModeFromEnvRaw as DeploymentMode): null;const deploymentMode: DeploymentMode = deploymentModeFromEnv ?? fileConfig?.server.deploymentMode ?? "local_trusted";+ const strictModeFromEnv = process.env.PAPERCLIP_SECRETS_STRICT_MODE;+ const secretsStrictMode =+ strictModeFromEnv !== undefined+ ? strictModeFromEnv === "true"+ : (fileSecrets?.strictMode ?? deploymentMode === "authenticated");const deploymentExposureFromEnvRaw = process.env.PAPERCLIP_DEPLOYMENT_EXPOSURE;const deploymentExposureFromEnv =deploymentExposureFromEnvRaw &&diff --git a/server/src/routes/agents.ts b/server/src/routes/agents.tsindex ce830140e4..d1b6d78cb9 100644--- a/server/src/routes/agents.ts+++ b/server/src/routes/agents.ts@@ -2189,6 +2189,14 @@ export function agentRoutes(lastHeartbeatAt: null,});const agent = await materializeDefaultInstructionsBundleForNewAgent(createdAgent, instructionsBundle);+ const agentEnv = asRecord(agent.adapterConfig)?.env;+ if (agentEnv) {+ await secretsSvc.syncEnvBindingsForTarget?.(+ companyId,+ { targetType: "agent", targetId: agent.id },+ agentEnv,+ );+ }const actor = getActorInfo(req);await logActivity(db, {@@ -2665,6 +2673,14 @@ export function agentRoutes(res.status(404).json({ error: "Agent not found" });return;}+ if (touchesAdapterConfiguration) {+ const agentEnv = asRecord(agent.adapterConfig)?.env;+ await secretsSvc.syncEnvBindingsForTarget?.(+ agent.companyId,+ { targetType: "agent", targetId: agent.id },+ agentEnv,+ );+ }await logActivity(db, {companyId: agent.companyId,diff --git a/server/src/routes/environments.ts b/server/src/routes/environments.tsindex fd7976cada..2c0daded97 100644--- a/server/src/routes/environments.ts+++ b/server/src/routes/environments.ts@@ -17,6 +17,7 @@ import {projectService,} from "../services/index.js";import {+ collectEnvironmentSecretRefs,normalizeEnvironmentConfigForPersistence,normalizeEnvironmentConfigForProbe,parseEnvironmentDriverConfig,@@ -26,6 +27,7 @@ import {import { probeEnvironment } from "../services/environment-probe.js";import { secretService } from "../services/secrets.js";import { listReadyPluginEnvironmentDrivers } from "../services/plugin-environment-driver.js";+import { getConfiguredSecretProvider } from "../secrets/configured-provider.js";import { assertCompanyAccess, getActorInfo } from "./authz.js";import type { PluginWorkerManager } from "../services/plugin-worker-manager.js";import { environmentService } from "../services/environments.js";@@ -202,6 +204,7 @@ export function environmentRoutes(companyId,environmentName: req.body.name,driver: req.body.driver,+ secretProvider: getConfiguredSecretProvider(),config: req.body.config,actor: {agentId: actor.agentId,@@ -211,6 +214,11 @@ export function environmentRoutes(}),};const environment = await svc.create(companyId, input);+ await secrets.syncSecretRefsForTarget(+ companyId,+ { targetType: "environment", targetId: environment.id },+ await collectEnvironmentSecretRefs({ db, environment }),+ );await logActivity(db, {companyId,actorType: actor.actorType,@@ -305,6 +313,7 @@ export function environmentRoutes(companyId: existing.companyId,environmentName: nextName,driver: nextDriver,+ secretProvider: getConfiguredSecretProvider(),config: configSource,actor: {agentId: actor.agentId,@@ -320,6 +329,13 @@ export function environmentRoutes(res.status(404).json({ error: "Environment not found" });return;}+ if (patch.config !== undefined || patch.driver !== undefined) {+ await secrets.syncSecretRefsForTarget(+ environment.companyId,+ { targetType: "environment", targetId: environment.id },+ await collectEnvironmentSecretRefs({ db, environment }),+ );+ }await logActivity(db, {companyId: environment.companyId,actorType: actor.actorType,diff --git a/server/src/routes/plugins.ts b/server/src/routes/plugins.tsindex 35b6081260..75a206b154 100644--- a/server/src/routes/plugins.ts+++ b/server/src/routes/plugins.ts@@ -73,6 +73,10 @@ import {requireLocalFolderDeclaration,setStoredLocalFolder,} from "../services/plugin-local-folders.js";+import {+ extractSecretRefPathsFromConfig,+ PLUGIN_SECRET_REFS_DISABLED_MESSAGE,+} from "../services/plugin-secrets-handler.js";import { badRequest, forbidden, notFound, unauthorized, unprocessable } from "../errors.js";/** UI slot declaration extracted from plugin manifest */@@ -1941,6 +1945,12 @@ export function pluginRoutes(}try {+ const secretRefsByPath = extractSecretRefPathsFromConfig(body.configJson, schema);+ if (secretRefsByPath.size > 0) {+ res.status(422).json({ error: PLUGIN_SECRET_REFS_DISABLED_MESSAGE });+ return;+ }+const result = await registry.upsertConfig(plugin.id, {configJson: body.configJson,});diff --git a/server/src/routes/projects.ts b/server/src/routes/projects.tsindex ea9debea5b..eccf3f7f74 100644--- a/server/src/routes/projects.ts+++ b/server/src/routes/projects.ts@@ -142,6 +142,13 @@ export function projectRoutes(db: Db) {);}const project = await svc.create(companyId, projectData);+ if (project.env) {+ await secretsSvc.syncEnvBindingsForTarget?.(+ companyId,+ { targetType: "project", targetId: project.id },+ project.env,+ );+ }let createdWorkspaceId: string | null = null;if (workspace) {const createdWorkspace = await svc.createWorkspace(project.id, workspace);@@ -207,6 +214,13 @@ export function projectRoutes(db: Db) {res.status(404).json({ error: "Project not found" });return;}+ if (body.env !== undefined) {+ await secretsSvc.syncEnvBindingsForTarget?.(+ project.companyId,+ { targetType: "project", targetId: project.id },+ project.env,+ );+ }const actor = getActorInfo(req);await logActivity(db, {diff --git a/server/src/routes/secrets.ts b/server/src/routes/secrets.tsindex 1ea99ee136..be9d503f3d 100644--- a/server/src/routes/secrets.ts+++ b/server/src/routes/secrets.ts@@ -1,25 +1,23 @@import { Router } from "express";import type { Db } from "@paperclipai/db";import {- SECRET_PROVIDERS,- type SecretProvider,+ createSecretProviderConfigSchema,createSecretSchema,+ remoteSecretImportPreviewSchema,+ remoteSecretImportSchema,rotateSecretSchema,+ updateSecretProviderConfigSchema,updateSecretSchema,} from "@paperclipai/shared";import { validate } from "../middleware/validate.js";import { assertBoard, assertCompanyAccess } from "./authz.js";import { logActivity, secretService } from "../services/index.js";+import { getConfiguredSecretProvider } from "../secrets/configured-provider.js";export function secretRoutes(db: Db) {const router = Router();const svc = secretService(db);- const configuredDefaultProvider = process.env.PAPERCLIP_SECRETS_PROVIDER;- const defaultProvider = (- configuredDefaultProvider && SECRET_PROVIDERS.includes(configuredDefaultProvider as SecretProvider)- ? configuredDefaultProvider- : "local_encrypted"- ) as SecretProvider;+ const defaultProvider = getConfiguredSecretProvider();router.get("/companies/:companyId/secret-providers", (req, res) => {assertBoard(req);@@ -28,6 +26,205 @@ export function secretRoutes(db: Db) {res.json(svc.listProviders());});+ router.get("/companies/:companyId/secret-providers/health", async (req, res) => {+ assertBoard(req);+ const companyId = req.params.companyId as string;+ assertCompanyAccess(req, companyId);+ const checks = await svc.checkProviders();+ res.json({ providers: checks });+ });++ router.get("/companies/:companyId/secret-provider-configs", async (req, res) => {+ assertBoard(req);+ const companyId = req.params.companyId as string;+ assertCompanyAccess(req, companyId);+ res.json(await svc.listProviderConfigs(companyId));+ });++ router.post("/companies/:companyId/secret-provider-configs", validate(createSecretProviderConfigSchema), async (req, res) => {+ assertBoard(req);+ const companyId = req.params.companyId as string;+ assertCompanyAccess(req, companyId);++ const created = await svc.createProviderConfig(+ companyId,+ {+ provider: req.body.provider,+ displayName: req.body.displayName,+ status: req.body.status,+ isDefault: req.body.isDefault,+ config: req.body.config,+ },+ { userId: req.actor.userId ?? "board", agentId: null },+ );++ await logActivity(db, {+ companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret_provider_config.created",+ entityType: "secret_provider_config",+ entityId: created.id,+ details: {+ provider: created.provider,+ displayName: created.displayName,+ status: created.status,+ isDefault: created.isDefault,+ },+ });++ res.status(201).json(created);+ });++ router.get("/secret-provider-configs/:id", async (req, res) => {+ assertBoard(req);+ const existing = await svc.getProviderConfigById(req.params.id as string);+ if (!existing) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);+ res.json(existing);+ });++ router.patch("/secret-provider-configs/:id", validate(updateSecretProviderConfigSchema), async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getProviderConfigById(id);+ if (!existing) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);++ const updated = await svc.updateProviderConfig(id, {+ displayName: req.body.displayName,+ status: req.body.status,+ isDefault: req.body.isDefault,+ config: req.body.config,+ });+ if (!updated) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }++ await logActivity(db, {+ companyId: updated.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret_provider_config.updated",+ entityType: "secret_provider_config",+ entityId: updated.id,+ details: {+ provider: updated.provider,+ displayName: updated.displayName,+ status: updated.status,+ isDefault: updated.isDefault,+ },+ });++ res.json(updated);+ });++ router.delete("/secret-provider-configs/:id", async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getProviderConfigById(id);+ if (!existing) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);++ const disabled = await svc.disableProviderConfig(id);+ if (!disabled) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }++ await logActivity(db, {+ companyId: disabled.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret_provider_config.disabled",+ entityType: "secret_provider_config",+ entityId: disabled.id,+ details: {+ provider: disabled.provider,+ displayName: disabled.displayName,+ status: disabled.status,+ },+ });++ res.json(disabled);+ });++ router.post("/secret-provider-configs/:id/default", async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getProviderConfigById(id);+ if (!existing) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);++ const updated = await svc.setDefaultProviderConfig(id);+ if (!updated) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }++ await logActivity(db, {+ companyId: updated.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret_provider_config.default_set",+ entityType: "secret_provider_config",+ entityId: updated.id,+ details: {+ provider: updated.provider,+ displayName: updated.displayName,+ isDefault: updated.isDefault,+ },+ });++ res.json(updated);+ });++ router.post("/secret-provider-configs/:id/health", async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getProviderConfigById(id);+ if (!existing) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);++ const health = await svc.checkProviderConfigHealth(id);+ if (!health) {+ res.status(404).json({ error: "Provider vault not found" });+ return;+ }++ await logActivity(db, {+ companyId: existing.companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret_provider_config.health_checked",+ entityType: "secret_provider_config",+ entityId: existing.id,+ details: {+ provider: existing.provider,+ status: health.status,+ code: health.details.code,+ },+ });++ res.json(health);+ });+router.get("/companies/:companyId/secrets", async (req, res) => {assertBoard(req);const companyId = req.params.companyId as string;@@ -45,10 +242,15 @@ export function secretRoutes(db: Db) {companyId,{name: req.body.name,+ key: req.body.key,provider: req.body.provider ?? defaultProvider,+ providerConfigId: req.body.providerConfigId,+ managedMode: req.body.managedMode,value: req.body.value,description: req.body.description,externalRef: req.body.externalRef,+ providerVersionRef: req.body.providerVersionRef,+ providerMetadata: req.body.providerMetadata,},{ userId: req.actor.userId ?? "board", agentId: null },);@@ -66,6 +268,77 @@ export function secretRoutes(db: Db) {res.status(201).json(created);});+ router.post(+ "/companies/:companyId/secrets/remote-import/preview",+ validate(remoteSecretImportPreviewSchema),+ async (req, res) => {+ assertBoard(req);+ const companyId = req.params.companyId as string;+ assertCompanyAccess(req, companyId);++ const preview = await svc.previewRemoteImport(companyId, {+ providerConfigId: req.body.providerConfigId,+ query: req.body.query,+ nextToken: req.body.nextToken,+ pageSize: req.body.pageSize,+ });++ await logActivity(db, {+ companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret.remote_import.previewed",+ entityType: "secret_provider_config",+ entityId: preview.providerConfigId,+ details: {+ provider: preview.provider,+ candidateCount: preview.candidates.length,+ readyCount: preview.candidates.filter((candidate) => candidate.status === "ready").length,+ duplicateCount: preview.candidates.filter((candidate) => candidate.status === "duplicate").length,+ conflictCount: preview.candidates.filter((candidate) => candidate.status === "conflict").length,+ },+ });++ res.json(preview);+ },+ );++ router.post(+ "/companies/:companyId/secrets/remote-import",+ validate(remoteSecretImportSchema),+ async (req, res) => {+ assertBoard(req);+ const companyId = req.params.companyId as string;+ assertCompanyAccess(req, companyId);++ const result = await svc.importRemoteSecrets(+ companyId,+ {+ providerConfigId: req.body.providerConfigId,+ secrets: req.body.secrets,+ },+ { userId: req.actor.userId ?? "board", agentId: null },+ );++ await logActivity(db, {+ companyId,+ actorType: "user",+ actorId: req.actor.userId ?? "board",+ action: "secret.remote_import.completed",+ entityType: "secret_provider_config",+ entityId: result.providerConfigId,+ details: {+ provider: result.provider,+ importedCount: result.importedCount,+ skippedCount: result.skippedCount,+ errorCount: result.errorCount,+ },+ });++ res.json(result);+ },+ );+router.post("/secrets/:id/rotate", validate(rotateSecretSchema), async (req, res) => {assertBoard(req);const id = req.params.id as string;@@ -75,12 +348,18 @@ export function secretRoutes(db: Db) {return;}assertCompanyAccess(req, existing.companyId);+ if (existing.status === "deleted") {+ res.status(404).json({ error: "Secret not found" });+ return;+ }const rotated = await svc.rotate(id,{value: req.body.value,externalRef: req.body.externalRef,+ providerVersionRef: req.body.providerVersionRef,+ providerConfigId: req.body.providerConfigId,},{ userId: req.actor.userId ?? "board", agentId: null },);@@ -107,11 +386,19 @@ export function secretRoutes(db: Db) {return;}assertCompanyAccess(req, existing.companyId);+ if (existing.status === "deleted") {+ res.status(404).json({ error: "Secret not found" });+ return;+ }const updated = await svc.update(id, {name: req.body.name,+ key: req.body.key,+ status: req.body.status,+ providerConfigId: req.body.providerConfigId,description: req.body.description,externalRef: req.body.externalRef,+ providerMetadata: req.body.providerMetadata,});if (!updated) {@@ -132,6 +419,32 @@ export function secretRoutes(db: Db) {res.json(updated);});+ router.get("/secrets/:id/usage", async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getById(id);+ if (!existing) {+ res.status(404).json({ error: "Secret not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);+ const bindings = await svc.listBindingReferences(existing.companyId, existing.id);+ res.json({ secretId: existing.id, bindings });+ });++ router.get("/secrets/:id/access-events", async (req, res) => {+ assertBoard(req);+ const id = req.params.id as string;+ const existing = await svc.getById(id);+ if (!existing) {+ res.status(404).json({ error: "Secret not found" });+ return;+ }+ assertCompanyAccess(req, existing.companyId);+ const events = await svc.listAccessEvents(existing.companyId, existing.id);+ res.json(events);+ });+router.delete("/secrets/:id", async (req, res) => {assertBoard(req);const id = req.params.id as string;diff --git a/server/src/secrets/aws-secrets-manager-provider.ts b/server/src/secrets/aws-secrets-manager-provider.tsnew file mode 100644index 0000000000..8c638594ae--- /dev/null+++ b/server/src/secrets/aws-secrets-manager-provider.ts@@ -0,0 +1,1053 @@+import { createHash, createHmac } from "node:crypto";+import { S3Client } from "@aws-sdk/client-s3";+import type { DeploymentMode } from "@paperclipai/shared";+import { unprocessable } from "../errors.js";+import type {+ PreparedSecretVersion,+ RemoteSecretListResult,+ SecretProviderClientErrorCode,+ SecretProviderHealthCheck,+ SecretProviderModule,+ SecretProviderValidationResult,+ SecretProviderVaultRuntimeConfig,+ SecretProviderWriteContext,+ StoredSecretVersionMaterial,+} from "./types.js";+import { SecretProviderClientError } from "./types.js";++const AWS_SECRETS_MANAGER_SCHEME = "aws_secrets_manager_v1";+const DEFAULT_PREFIX = "paperclip";+const DEFAULT_OWNER_TAG = "paperclip";+const DEFAULT_VERSION_STAGE = "AWSCURRENT";+const PAPERCLIP_PENDING_VERSION_STAGE = "PAPERCLIP_PENDING";+const DEFAULT_DELETE_RECOVERY_WINDOW_DAYS = 30;+const AWS_SECRETS_MANAGER_REQUEST_TIMEOUT_MS = 30_000;+const AWS_CREDENTIAL_CACHE_TTL_MS = 5 * 60_000;+const AWS_CREDENTIAL_EXPIRATION_SKEW_MS = 60_000;+const AWS_RUNTIME_CREDENTIAL_WARNING =+ "AWS bootstrap credentials must be available to the Paperclip server runtime through the AWS SDK default credential provider chain: IAM role/workload identity, AWS_PROFILE/SSO/shared credentials, web identity, container/instance metadata, or short-lived shell credentials.";+const AWS_CREDENTIAL_CUSTODY_WARNING =+ "Do not store AWS root credentials or long-lived IAM user access keys in Paperclip company_secrets; the AWS provider bootstrap belongs in deployment infrastructure, the process environment, an AWS profile, or the orchestrator secret store.";++interface AwsSecretsManagerMaterial extends StoredSecretVersionMaterial {+ scheme: typeof AWS_SECRETS_MANAGER_SCHEME;+ secretId: string;+ versionId: string | null;+ source: "managed" | "external_reference";+}++interface AwsSecretsManagerConfig {+ region: string;+ endpoint: string;+ deploymentId: string;+ prefix: string;+ kmsKeyId: string | null;+ environmentTag: string;+ providerOwnerTag: string;+ deleteRecoveryWindowDays: number;+}++interface AwsSecretsManagerTag {+ Key: string;+ Value: string;+}++interface AwsSecretsManagerListSecretEntry {+ ARN?: string;+ Name?: string;+ Description?: string;+ KmsKeyId?: string;+ CreatedDate?: string | number | Date;+ LastAccessedDate?: string | number | Date;+ LastChangedDate?: string | number | Date;+ DeletedDate?: string | number | Date;+ Tags?: AwsSecretsManagerTag[];+}++interface AwsCredentialIdentity {+ accessKeyId: string;+ secretAccessKey: string;+ sessionToken?: string;+}++interface CachedAwsCredentialProvider {+ client: S3Client;+ credentials: AwsCredentialIdentity | null;+ expiresAt: number;+ pending: Promise<AwsCredentialIdentity> | null;+}++type ManagedSecretNamespaceContext = Pick<SecretProviderWriteContext, "companyId" | "secretKey">;++const awsCredentialProviders = new Map<string, CachedAwsCredentialProvider>();++interface AwsSecretsManagerGateway {+ createSecret(input: {+ Name: string;+ SecretString: string;+ KmsKeyId?: string;+ Description?: string;+ Tags: AwsSecretsManagerTag[];+ }): Promise<{+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>;+ putSecretValue(input: {+ SecretId: string;+ SecretString: string;+ VersionStages?: string[];+ }): Promise<{+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>;+ getSecretValue(input: {+ SecretId: string;+ VersionId?: string;+ VersionStage?: string;+ }): Promise<{+ SecretString?: string;+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>;+ deleteSecret(input: {+ SecretId: string;+ RecoveryWindowInDays: number;+ }): Promise<unknown>;+ updateSecretVersionStage?(input: {+ SecretId: string;+ VersionStage: string;+ RemoveFromVersionId?: string;+ MoveToVersionId?: string;+ }): Promise<unknown>;+ listSecrets?(input: {+ MaxResults?: number;+ NextToken?: string;+ Filters?: Array<{+ Key: "all" | "name" | "description" | "tag-key" | "tag-value" | "primary-region" | "owning-service";+ Values: string[];+ }>;+ IncludePlannedDeletion?: boolean;+ }): Promise<{+ SecretList?: AwsSecretsManagerListSecretEntry[];+ NextToken?: string;+ }>;+}++function sha256Hex(value: string): string {+ return createHash("sha256").update(value).digest("hex");+}++function hmac(key: string | Buffer, value: string) {+ return createHmac("sha256", key).update(value).digest();+}++function awsDateParts(now = new Date()) {+ const iso = now.toISOString().replace(/[:-]|\.\d{3}/g, "");+ return {+ amzDate: iso,+ dateStamp: iso.slice(0, 8),+ };+}++function canonicalHeaderValue(value: string) {+ return value.trim().replace(/\s+/g, " ");+}++function signAwsSecretsManagerRequest(input: {+ endpoint: URL;+ region: string;+ operation: string;+ body: string;+ credentials: AwsCredentialIdentity;+}) {+ const { amzDate, dateStamp } = awsDateParts();+ const payloadHash = sha256Hex(input.body);+ const headers: Record<string, string> = {+ "content-type": "application/x-amz-json-1.1",+ host: input.endpoint.host,+ "x-amz-content-sha256": payloadHash,+ "x-amz-date": amzDate,+ "x-amz-target": `secretsmanager.${input.operation}`,+ };+ if (input.credentials.sessionToken) {+ headers["x-amz-security-token"] = input.credentials.sessionToken;+ }++ const sortedHeaderNames = Object.keys(headers).sort();+ const canonicalHeaders = sortedHeaderNames+ .map((name) => `${name}:${canonicalHeaderValue(headers[name] ?? "")}\n`)+ .join("");+ const signedHeaders = sortedHeaderNames.join(";");+ const canonicalRequest = [+ "POST",+ input.endpoint.pathname || "/",+ "",+ canonicalHeaders,+ signedHeaders,+ payloadHash,+ ].join("\n");+ const credentialScope = `${dateStamp}/${input.region}/secretsmanager/aws4_request`;+ const stringToSign = [+ "AWS4-HMAC-SHA256",+ amzDate,+ credentialScope,+ sha256Hex(canonicalRequest),+ ].join("\n");+ const dateKey = hmac(`AWS4${input.credentials.secretAccessKey}`, dateStamp);+ const regionKey = hmac(dateKey, input.region);+ const serviceKey = hmac(regionKey, "secretsmanager");+ const signingKey = hmac(serviceKey, "aws4_request");+ const signature = createHmac("sha256", signingKey).update(stringToSign).digest("hex");++ return {+ ...headers,+ authorization:+ `AWS4-HMAC-SHA256 Credential=${input.credentials.accessKeyId}/${credentialScope}, ` ++ `SignedHeaders=${signedHeaders}, Signature=${signature}`,+ };+}++async function loadAwsCredentials(region: string): Promise<AwsCredentialIdentity> {+ const now = Date.now();+ let cached = awsCredentialProviders.get(region);+ if (!cached) {+ // S3Client is only used as a carrier for the AWS SDK default credential provider chain.+ // No S3 API calls are made here; switch to defaultProvider({ region }) if we add that dependency.+ cached = {+ client: new S3Client({ region }),+ credentials: null,+ expiresAt: 0,+ pending: null,+ };+ awsCredentialProviders.set(region, cached);+ }++ if (cached.credentials && cached.expiresAt > now) return cached.credentials;+ if (cached.pending) return cached.pending;++ cached.pending = (async () => {+ const credentialSource = cached.client.config.credentials;+ const credentials = typeof credentialSource === "function"+ ? await credentialSource()+ : await credentialSource;+ if (!credentials?.accessKeyId || !credentials.secretAccessKey) {+ throw new Error("AWS SDK default credential provider chain did not return credentials");+ }+ const resolved = {+ accessKeyId: credentials.accessKeyId,+ secretAccessKey: credentials.secretAccessKey,+ sessionToken: credentials.sessionToken,+ };+ const expiration = (credentials as { expiration?: Date }).expiration?.getTime();+ cached.credentials = resolved;+ cached.expiresAt = Math.min(+ now + AWS_CREDENTIAL_CACHE_TTL_MS,+ expiration ? expiration - AWS_CREDENTIAL_EXPIRATION_SKEW_MS : Number.POSITIVE_INFINITY,+ );+ return resolved;+ })().finally(() => {+ if (cached) cached.pending = null;+ });++ return cached.pending;+}++function configuredAwsSecretsManagerDescriptor() {+ return {+ id: "aws_secrets_manager" as const,+ label: "AWS Secrets Manager",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: true,+ configured: canLoadAwsSecretsManagerConfig(),+ };+}++function canLoadAwsSecretsManagerConfig() {+ return getAwsConfigReadiness().missingConfig.length === 0;+}++function asOptionalNonEmptyString(value: unknown): string | null {+ return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;+}++function readProviderVaultConfig(input: SecretProviderVaultRuntimeConfig): AwsSecretsManagerConfig {+ if (input.provider !== "aws_secrets_manager") {+ throw unprocessable("AWS Secrets Manager provider received a mismatched provider vault");+ }+ if (input.status === "disabled") {+ throw unprocessable("AWS Secrets Manager provider vault is disabled");+ }+ if (input.status === "coming_soon") {+ throw unprocessable("AWS Secrets Manager provider vault runtime is locked while coming soon");+ }+ const region = asOptionalNonEmptyString(input.config.region);+ if (!region) {+ throw unprocessable("AWS Secrets Manager provider vault requires non-secret config: region");+ }+ const recoveryWindowRaw = process.env.PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS?.trim();+ const recoveryWindow = recoveryWindowRaw ? Number(recoveryWindowRaw) : DEFAULT_DELETE_RECOVERY_WINDOW_DAYS;+ if (!Number.isFinite(recoveryWindow) || recoveryWindow < 7 || recoveryWindow > 30) {+ throw unprocessable(+ "PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS must be an integer between 7 and 30",+ );+ }++ return {+ region,+ endpoint:+ process.env.PAPERCLIP_SECRETS_AWS_ENDPOINT?.trim() ||+ `https://secretsmanager.${region}.amazonaws.com`,+ deploymentId: sanitizePathSegment(+ asOptionalNonEmptyString(input.config.namespace) ?? input.id,+ ),+ prefix: sanitizePathSegment(+ asOptionalNonEmptyString(input.config.secretNamePrefix) || DEFAULT_PREFIX,+ ),+ kmsKeyId: asOptionalNonEmptyString(input.config.kmsKeyId),+ environmentTag:+ asOptionalNonEmptyString(input.config.environmentTag) ||+ process.env.NODE_ENV?.trim() ||+ "unknown",+ providerOwnerTag:+ asOptionalNonEmptyString(input.config.ownerTag) || DEFAULT_OWNER_TAG,+ deleteRecoveryWindowDays: recoveryWindow,+ };+}++function getAwsConfigReadiness() {+ const region = (+ process.env.PAPERCLIP_SECRETS_AWS_REGION ??+ process.env.AWS_REGION ??+ process.env.AWS_DEFAULT_REGION+ )?.trim();+ const deploymentId = process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID?.trim();+ const kmsKeyId = process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID?.trim();+ const missingConfig: string[] = [];++ if (!region) {+ missingConfig.push("PAPERCLIP_SECRETS_AWS_REGION or AWS_REGION/AWS_DEFAULT_REGION");+ }+ if (!deploymentId) {+ missingConfig.push("PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID");+ }+ if (!kmsKeyId) {+ missingConfig.push("PAPERCLIP_SECRETS_AWS_KMS_KEY_ID");+ }++ return {+ missingConfig,+ region: region || null,+ deploymentId: deploymentId || null,+ kmsKeyConfigured: Boolean(kmsKeyId),+ credentialSources: describeDetectedAwsCredentialSources(),+ };+}++function describeDetectedAwsCredentialSources() {+ const sources: string[] = [];+ if (process.env.AWS_PROFILE?.trim()) sources.push("AWS_PROFILE/shared config");+ if (process.env.AWS_ACCESS_KEY_ID?.trim() && process.env.AWS_SECRET_ACCESS_KEY?.trim()) {+ sources.push("temporary AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY environment credentials");+ }+ if (process.env.AWS_WEB_IDENTITY_TOKEN_FILE?.trim() && process.env.AWS_ROLE_ARN?.trim()) {+ sources.push("AWS web identity token");+ }+ if (+ process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI?.trim() ||+ process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI?.trim()+ ) {+ sources.push("AWS container credentials endpoint");+ }+ if (process.env.AWS_SHARED_CREDENTIALS_FILE?.trim() || process.env.AWS_CONFIG_FILE?.trim()) {+ sources.push("custom AWS shared credentials/config file");+ }+ return sources;+}++function loadAwsSecretsManagerConfig(): AwsSecretsManagerConfig {+ const readiness = getAwsConfigReadiness();+ const region =+ process.env.PAPERCLIP_SECRETS_AWS_REGION?.trim() ||+ process.env.AWS_REGION?.trim() ||+ process.env.AWS_DEFAULT_REGION?.trim();+ const deploymentId = process.env.PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID?.trim();+ const kmsKeyId = process.env.PAPERCLIP_SECRETS_AWS_KMS_KEY_ID?.trim();++ if (readiness.missingConfig.length > 0) {+ throw unprocessable(+ `AWS Secrets Manager provider requires non-secret config: ${readiness.missingConfig.join(", ")}`,+ );+ }+ if (!region) {+ throw unprocessable(+ "AWS Secrets Manager provider requires PAPERCLIP_SECRETS_AWS_REGION or AWS_REGION",+ );+ }+ if (!deploymentId) {+ throw unprocessable(+ "AWS Secrets Manager provider requires PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID",+ );+ }+ if (!kmsKeyId) {+ throw unprocessable(+ "AWS Secrets Manager provider requires PAPERCLIP_SECRETS_AWS_KMS_KEY_ID",+ );+ }++ const recoveryWindowRaw = process.env.PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS?.trim();+ const recoveryWindow = recoveryWindowRaw ? Number(recoveryWindowRaw) : DEFAULT_DELETE_RECOVERY_WINDOW_DAYS;+ if (!Number.isFinite(recoveryWindow) || recoveryWindow < 7 || recoveryWindow > 30) {+ throw unprocessable(+ "PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS must be an integer between 7 and 30",+ );+ }++ return {+ region,+ endpoint:+ process.env.PAPERCLIP_SECRETS_AWS_ENDPOINT?.trim() ||+ `https://secretsmanager.${region}.amazonaws.com`,+ deploymentId,+ prefix: sanitizePathSegment(process.env.PAPERCLIP_SECRETS_AWS_PREFIX?.trim() || DEFAULT_PREFIX),+ kmsKeyId,+ environmentTag:+ process.env.PAPERCLIP_SECRETS_AWS_ENVIRONMENT?.trim() ||+ process.env.NODE_ENV?.trim() ||+ "unknown",+ providerOwnerTag:+ process.env.PAPERCLIP_SECRETS_AWS_PROVIDER_OWNER?.trim() || DEFAULT_OWNER_TAG,+ deleteRecoveryWindowDays: recoveryWindow,+ };+}++function sanitizePathSegment(input: string) {+ return input+ .trim()+ .replace(/[^A-Za-z0-9/_+=.@-]+/g, "-")+ .replace(/\/+/g, "/")+ .replace(/^\/+|\/+$/g, "");+}++function buildManagedSecretName(+ config: AwsSecretsManagerConfig,+ context: ManagedSecretNamespaceContext | undefined,+) {+ if (!context) {+ throw unprocessable("AWS Secrets Manager provider requires secret context for managed values");+ }+ return [+ sanitizePathSegment(config.prefix),+ sanitizePathSegment(config.deploymentId),+ sanitizePathSegment(context.companyId),+ sanitizePathSegment(context.secretKey),+ ]+ .filter(Boolean)+ .join("/");+}++function buildManagedSecretId(+ config: AwsSecretsManagerConfig,+ context: ManagedSecretNamespaceContext | undefined,+) {+ return buildManagedSecretName(config, context);+}++function escapeRegExp(value: string) {+ return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");+}++function extractAwsSecretName(externalRef: string) {+ const trimmed = externalRef.trim();+ const arnMatch = /^arn:[^:]+:secretsmanager:[^:]*:[^:]*:secret:(.+)$/i.exec(trimmed);+ return arnMatch?.[1] ?? trimmed;+}++function isManagedSecretRefForContext(+ config: AwsSecretsManagerConfig,+ context: ManagedSecretNamespaceContext | undefined,+ externalRef: string | null | undefined,+) {+ if (!externalRef?.trim()) return false;+ const expectedName = buildManagedSecretName(config, context);+ const actualName = extractAwsSecretName(externalRef);+ return new RegExp(`^${escapeRegExp(expectedName)}(?:-[A-Za-z0-9]{6})?$`).test(actualName);+}++function isManagedSecretNamespaceRef(+ config: AwsSecretsManagerConfig,+ externalRef: string | null | undefined,+) {+ if (!externalRef?.trim()) return false;+ const namespacePrefix = [+ sanitizePathSegment(config.prefix),+ sanitizePathSegment(config.deploymentId),+ ]+ .filter(Boolean)+ .join("/");+ if (!namespacePrefix) return false;+ const actualName = extractAwsSecretName(externalRef);+ return actualName === namespacePrefix || actualName.startsWith(`${namespacePrefix}/`);+}++function assertNotManagedNamespaceExternalRef(+ config: AwsSecretsManagerConfig,+ externalRef: string,+) {+ if (!isManagedSecretNamespaceRef(config, externalRef)) return;+ throw unprocessable(+ "AWS Paperclip-managed namespace secrets cannot be imported as external references",+ );+}++function resolveManagedSecretRef(input: {+ config: AwsSecretsManagerConfig;+ context: ManagedSecretNamespaceContext | undefined;+ externalRefs: Array<string | null | undefined>;+}) {+ let sawNonEmptyExternalRef = false;+ for (const externalRef of input.externalRefs) {+ if (externalRef?.trim()) {+ sawNonEmptyExternalRef = true;+ }+ if (externalRef?.trim() && isManagedSecretRefForContext(input.config, input.context, externalRef)) {+ return externalRef.trim();+ }+ }+ if (sawNonEmptyExternalRef) {+ throw unprocessable(+ "AWS Secrets Manager managed secret ref drifted outside the derived deployment/company scope",+ );+ }+ return buildManagedSecretId(input.config, input.context);+}++function buildManagedSecretTags(+ config: AwsSecretsManagerConfig,+ context: SecretProviderWriteContext | undefined,+): AwsSecretsManagerTag[] {+ if (!context) return [];+ return [+ { Key: "paperclip:managed-by", Value: "paperclip" },+ { Key: "paperclip:provider-owner", Value: config.providerOwnerTag },+ { Key: "paperclip:deployment-id", Value: config.deploymentId },+ { Key: "paperclip:company-id", Value: context.companyId },+ { Key: "paperclip:secret-key", Value: context.secretKey },+ { Key: "paperclip:environment", Value: config.environmentTag },+ ];+}++function createExternalReferenceMaterial(+ externalRef: string,+ providerVersionRef: string | null,+): PreparedSecretVersion {+ const normalizedExternalRef = externalRef.trim();+ const normalizedProviderVersionRef = providerVersionRef?.trim() || null;+ const fingerprint = sha256Hex(+ `${AWS_SECRETS_MANAGER_SCHEME}:${normalizedExternalRef}:${normalizedProviderVersionRef ?? ""}`,+ );+ return {+ material: {+ scheme: AWS_SECRETS_MANAGER_SCHEME,+ secretId: normalizedExternalRef,+ versionId: normalizedProviderVersionRef,+ source: "external_reference",+ },+ valueSha256: fingerprint,+ fingerprintSha256: fingerprint,+ externalRef: normalizedExternalRef,+ providerVersionRef: normalizedProviderVersionRef,+ };+}++function createManagedMaterial(secretId: string, versionId: string | null): AwsSecretsManagerMaterial {+ return {+ scheme: AWS_SECRETS_MANAGER_SCHEME,+ secretId,+ versionId,+ source: "managed",+ };+}++function serializeAwsDate(value: string | number | Date | undefined): string | null {+ if (value === undefined) return null;+ const date = value instanceof Date ? value : new Date(value);+ return Number.isNaN(date.getTime()) ? null : date.toISOString();+}++function createRemoteSecretMetadata(entry: AwsSecretsManagerListSecretEntry): Record<string, unknown> {+ return {+ createdDate: serializeAwsDate(entry.CreatedDate),+ lastAccessedDate: serializeAwsDate(entry.LastAccessedDate),+ lastChangedDate: serializeAwsDate(entry.LastChangedDate),+ deletedDate: serializeAwsDate(entry.DeletedDate),+ hasDescription: Boolean(entry.Description),+ hasKmsKey: Boolean(entry.KmsKeyId),+ tagCount: Array.isArray(entry.Tags) ? entry.Tags.length : 0,+ };+}++function asAwsSecretsManagerMaterial(value: StoredSecretVersionMaterial): AwsSecretsManagerMaterial {+ if (+ value &&+ typeof value === "object" &&+ value.scheme === AWS_SECRETS_MANAGER_SCHEME &&+ typeof value.secretId === "string" &&+ (typeof value.versionId === "string" || value.versionId === null) &&+ (value.source === "managed" || value.source === "external_reference")+ ) {+ return value as AwsSecretsManagerMaterial;+ }+ throw unprocessable("Invalid AWS Secrets Manager material");+}++function classifyAwsProviderError(message: string): SecretProviderClientErrorCode {+ if (/ResourceExistsException|AlreadyExists/i.test(message)) return "conflict";+ if (/ResourceNotFoundException|NotFound/i.test(message)) return "not_found";+ if (/AccessDeniedException|AccessDenied|UnrecognizedClientException|InvalidClientTokenId|not authorized/i.test(message)) {+ return "access_denied";+ }+ if (/Throttl|TooManyRequests|RequestLimitExceeded|Rate exceeded/i.test(message)) return "throttled";+ if (/ValidationException|InvalidParameter|InvalidRequest/i.test(message)) return "invalid_request";+ if (/fetch failed|ECONN|ENOTFOUND|ETIMEDOUT|network|timeout/i.test(message)) return "provider_unavailable";+ return "provider_error";+}++function awsProviderSafeMessage(code: SecretProviderClientErrorCode): string {+ switch (code) {+ case "access_denied":+ return "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.";+ case "throttled":+ return "AWS Secrets Manager throttled the request. Wait and try again.";+ case "not_found":+ return "AWS Secrets Manager could not find the requested secret.";+ case "conflict":+ return "AWS Secrets Manager reported that the requested secret already exists.";+ case "invalid_request":+ return "AWS Secrets Manager rejected the request.";+ case "provider_unavailable":+ return "AWS Secrets Manager is unavailable right now.";+ case "provider_error":+ default:+ return "AWS Secrets Manager request failed.";+ }+}++function normalizeAwsError(operation: string, error: unknown): never {+ const rawMessage = error instanceof Error ? error.message : String(error);+ const code = classifyAwsProviderError(rawMessage);+ throw new SecretProviderClientError({+ code,+ provider: "aws_secrets_manager",+ operation,+ message: awsProviderSafeMessage(code),+ rawMessage,+ cause: error,+ });+}++class AwsSecretsManagerJsonGateway implements AwsSecretsManagerGateway {+ private readonly endpoint: URL;++ constructor(private readonly config: AwsSecretsManagerConfig) {+ this.endpoint = new URL(config.endpoint);+ }++ createSecret(input: {+ Name: string;+ SecretString: string;+ KmsKeyId?: string;+ Description?: string;+ Tags: AwsSecretsManagerTag[];+ }) {+ return this.call<{+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>("CreateSecret", input);+ }++ putSecretValue(input: {+ SecretId: string;+ SecretString: string;+ VersionStages?: string[];+ }) {+ return this.call<{+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>("PutSecretValue", input);+ }++ getSecretValue(input: {+ SecretId: string;+ VersionId?: string;+ VersionStage?: string;+ }) {+ return this.call<{+ SecretString?: string;+ ARN?: string;+ Name?: string;+ VersionId?: string;+ }>("GetSecretValue", input);+ }++ deleteSecret(input: {+ SecretId: string;+ RecoveryWindowInDays: number;+ }) {+ return this.call("DeleteSecret", input);+ }++ updateSecretVersionStage(input: {+ SecretId: string;+ VersionStage: string;+ RemoveFromVersionId?: string;+ MoveToVersionId?: string;+ }) {+ return this.call("UpdateSecretVersionStage", input);+ }++ listSecrets(input: {+ MaxResults?: number;+ NextToken?: string;+ Filters?: Array<{+ Key: "all" | "name" | "description" | "tag-key" | "tag-value" | "primary-region" | "owning-service";+ Values: string[];+ }>;+ IncludePlannedDeletion?: boolean;+ }) {+ return this.call<{+ SecretList?: AwsSecretsManagerListSecretEntry[];+ NextToken?: string;+ }>("ListSecrets", input);+ }++ private async call<T>(operation: string, payload: Record<string, unknown>): Promise<T> {+ const body = JSON.stringify(payload);+ const credentials = await loadAwsCredentials(this.config.region);+ const headers = signAwsSecretsManagerRequest({+ endpoint: this.endpoint,+ region: this.config.region,+ operation,+ body,+ credentials,+ });+ const response = await fetch(this.endpoint, {+ method: "POST",+ headers,+ body,+ signal: AbortSignal.timeout(AWS_SECRETS_MANAGER_REQUEST_TIMEOUT_MS),+ });+ const text = await response.text();+ const parsed = text ? (JSON.parse(text) as Record<string, unknown>) : {};++ if (!response.ok) {+ const code = String(parsed.__type ?? parsed.code ?? parsed.Code ?? response.statusText ?? "UnknownError");+ const message = String(parsed.message ?? parsed.Message ?? code);+ const rawMessage = `${code}: ${message}`;+ const clientCode = classifyAwsProviderError(rawMessage);+ throw new SecretProviderClientError({+ code: clientCode,+ provider: "aws_secrets_manager",+ operation,+ message: awsProviderSafeMessage(clientCode),+ rawMessage,+ });+ }++ return parsed as T;+ }+}++export function createAwsSecretsManagerProvider(+ options?: {+ config?: AwsSecretsManagerConfig;+ gateway?: AwsSecretsManagerGateway;+ },+): SecretProviderModule {+ function resolveConfig(providerConfig?: SecretProviderVaultRuntimeConfig | null) {+ if (providerConfig) return readProviderVaultConfig(providerConfig);+ return options?.config ?? loadAwsSecretsManagerConfig();+ }++ function resolveGateway(config: AwsSecretsManagerConfig) {+ return options?.gateway ?? new AwsSecretsManagerJsonGateway(config);+ }++ async function validateConfig(+ input?: {+ deploymentMode?: DeploymentMode;+ strictMode?: boolean;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ },+ ): Promise<SecretProviderValidationResult> {+ const warnings: string[] = [];+ if (input?.deploymentMode === "authenticated" && input.strictMode !== true) {+ warnings.push("Strict secret mode should be enabled for authenticated deployments");+ }+ const config = resolveConfig(input?.providerConfig);+ if (!config.prefix) {+ warnings.push("PAPERCLIP_SECRETS_AWS_PREFIX should be set to a deployment-scoped prefix");+ }+ return { ok: true, warnings };+ }++ async function healthCheck(+ input?: {+ deploymentMode?: DeploymentMode;+ strictMode?: boolean;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ },+ ): Promise<SecretProviderHealthCheck> {+ try {+ const validation = await validateConfig(input);+ const config = resolveConfig(input?.providerConfig);+ const readiness = getAwsConfigReadiness();+ const warnings = [...validation.warnings];+ if (+ process.env.AWS_ACCESS_KEY_ID?.trim() &&+ process.env.AWS_SECRET_ACCESS_KEY?.trim()+ ) {+ warnings.push(+ "AWS static environment credentials are visible to this process; use only short-lived shell credentials locally and prefer IAM role/workload identity for hosted deployments.",+ );+ }+ return {+ provider: "aws_secrets_manager",+ status: warnings.length > 0 ? "warn" : "ok",+ message:+ "AWS Secrets Manager provider config is present; AWS credentials are resolved by the server runtime through the AWS SDK default credential provider chain.",+ warnings,+ details: {+ region: config.region,+ prefix: config.prefix,+ deploymentId: config.deploymentId,+ kmsKeyConfigured: Boolean(config.kmsKeyId),+ credentialSource: "AWS SDK default credential provider chain",+ detectedCredentialSources: readiness.credentialSources,+ },+ backupGuidance: [+ "Back up Paperclip metadata separately from AWS-managed secrets.",+ "Restoring access requires the Paperclip database plus the same AWS secret namespace and KMS permissions.",+ ],+ };+ } catch (error) {+ const readiness = getAwsConfigReadiness();+ const providerConfigMissing = input?.providerConfig && !asOptionalNonEmptyString(input.providerConfig.config.region)+ ? ["region"]+ : [];+ const missingConfig = input?.providerConfig ? providerConfigMissing : readiness.missingConfig;+ return {+ provider: "aws_secrets_manager",+ status: "warn",+ message:+ missingConfig.length > 0+ ? `AWS Secrets Manager provider is not ready: missing ${missingConfig.join(", ")}.`+ : error instanceof Error+ ? error.message+ : String(error),+ warnings: [+ ...(missingConfig.length > 0+ ? [`Missing required non-secret AWS provider config: ${missingConfig.join(", ")}.`]+ : []),+ AWS_RUNTIME_CREDENTIAL_WARNING,+ AWS_CREDENTIAL_CUSTODY_WARNING,+ "Managed secret create/rotate/resolve calls will fail until AWS provider configuration is complete.",+ ],+ details: {+ missingConfig,+ requiredProviderConfig: input?.providerConfig+ ? ["region"]+ : [+ "PAPERCLIP_SECRETS_AWS_REGION or AWS_REGION/AWS_DEFAULT_REGION",+ "PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID",+ "PAPERCLIP_SECRETS_AWS_KMS_KEY_ID",+ ],+ optionalProviderConfig: [+ "PAPERCLIP_SECRETS_AWS_PREFIX",+ "PAPERCLIP_SECRETS_AWS_ENVIRONMENT",+ "PAPERCLIP_SECRETS_AWS_PROVIDER_OWNER",+ "PAPERCLIP_SECRETS_AWS_ENDPOINT",+ "PAPERCLIP_SECRETS_AWS_DELETE_RECOVERY_DAYS",+ ],+ credentialSource: "AWS SDK default credential provider chain",+ detectedCredentialSources: readiness.credentialSources,+ },+ };+ }+ }++ return {+ id: "aws_secrets_manager",+ descriptor() {+ return configuredAwsSecretsManagerDescriptor();+ },+ validateConfig,+ async createSecret(input) {+ const config = resolveConfig(input.providerConfig);+ const gateway = resolveGateway(config);+ const valueSha256 = sha256Hex(input.value);+ const secretId = buildManagedSecretId(config, input.context);++ try {+ const createInput = {+ Name: secretId,+ SecretString: input.value,+ ...(config.kmsKeyId ? { KmsKeyId: config.kmsKeyId } : {}),+ Description: input.context ? `Paperclip secret ${input.context.secretName}` : undefined,+ Tags: buildManagedSecretTags(config, input.context),+ };+ const created = await gateway.createSecret({+ ...createInput,+ });+ const normalizedSecretId = created.ARN ?? created.Name ?? secretId;+ return {+ material: createManagedMaterial(normalizedSecretId, created.VersionId ?? null),+ valueSha256,+ fingerprintSha256: valueSha256,+ externalRef: normalizedSecretId,+ providerVersionRef: created.VersionId ?? null,+ };+ } catch (error) {+ normalizeAwsError("createSecret", error);+ }+ },+ async createVersion(input) {+ const config = resolveConfig(input.providerConfig);+ const gateway = resolveGateway(config);+ const valueSha256 = sha256Hex(input.value);+ const secretId = resolveManagedSecretRef({+ config,+ context: input.context,+ externalRefs: [input.externalRef],+ });++ try {+ const created = await gateway.putSecretValue({+ SecretId: secretId,+ SecretString: input.value,+ VersionStages: [PAPERCLIP_PENDING_VERSION_STAGE],+ });+ const normalizedSecretId = created.ARN ?? created.Name ?? secretId;+ return {+ material: createManagedMaterial(normalizedSecretId, created.VersionId ?? null),+ valueSha256,+ fingerprintSha256: valueSha256,+ externalRef: normalizedSecretId,+ providerVersionRef: created.VersionId ?? null,+ };+ } catch (error) {+ normalizeAwsError("createVersion", error);+ }+ },+ async linkExternalSecret(input) {+ const config = resolveConfig(input.providerConfig);+ assertNotManagedNamespaceExternalRef(config, input.externalRef);+ return createExternalReferenceMaterial(input.externalRef, input.providerVersionRef ?? null);+ },+ async listRemoteSecrets(input): Promise<RemoteSecretListResult> {+ const config = resolveConfig(input.providerConfig);+ const gateway = resolveGateway(config);+ const query = input.query?.trim();+ const pageSize =+ input.pageSize && Number.isFinite(input.pageSize)+ ? Math.min(Math.max(Math.trunc(input.pageSize), 1), 100)+ : 50;++ try {+ if (!gateway.listSecrets) {+ throw new Error("ListSecrets gateway operation is unavailable");+ }+ const listed = await gateway.listSecrets({+ MaxResults: pageSize,+ NextToken: input.nextToken?.trim() || undefined,+ IncludePlannedDeletion: false,+ Filters: query ? [{ Key: "all", Values: [query] }] : undefined,+ });+ return {+ nextToken: listed.NextToken ?? null,+ secrets: (listed.SecretList ?? [])+ .filter((entry) => Boolean(entry.ARN ?? entry.Name))+ .map((entry) => ({+ externalRef: entry.ARN ?? entry.Name ?? "",+ name: entry.Name ?? entry.ARN ?? "",+ providerVersionRef: null,+ metadata: createRemoteSecretMetadata(entry),+ })),+ };+ } catch (error) {+ normalizeAwsError("listSecrets", error);+ }+ },+ async resolveVersion(input) {+ const config = resolveConfig(input.providerConfig);+ const gateway = resolveGateway(config);+ const material = asAwsSecretsManagerMaterial(input.material);+ const secretId =+ material.source === "managed"+ ? resolveManagedSecretRef({+ config,+ context: input.context,+ externalRefs: [input.externalRef, material.secretId],+ })+ : (input.externalRef ?? material.secretId);++ try {+ const resolved = await gateway.getSecretValue({+ SecretId: secretId,+ VersionId: input.providerVersionRef ?? material.versionId ?? undefined,+ VersionStage:+ input.providerVersionRef || material.versionId ? undefined : DEFAULT_VERSION_STAGE,+ });+ if (typeof resolved.SecretString !== "string") {+ throw new Error("SecretString was empty");+ }+ return resolved.SecretString;+ } catch (error) {+ normalizeAwsError("resolveVersion", error);+ }+ },+ async deleteOrArchive(input) {+ const material =+ input.material && typeof input.material === "object"+ ? asAwsSecretsManagerMaterial(input.material)+ : null;++ if (material?.source !== "managed") return;++ const config = resolveConfig(input.providerConfig);+ const gateway = resolveGateway(config);+ const secretId = resolveManagedSecretRef({+ config,+ context: input.context,+ externalRefs: [input.externalRef, material.secretId],+ });++ try {+ if (input.mode === "archive") {+ if (material.versionId && gateway.updateSecretVersionStage) {+ await gateway.updateSecretVersionStage({+ SecretId: secretId,+ VersionStage: PAPERCLIP_PENDING_VERSION_STAGE,+ RemoveFromVersionId: material.versionId,+ });+ }+ return;+ }+ await gateway.deleteSecret({+ SecretId: secretId,+ RecoveryWindowInDays: config.deleteRecoveryWindowDays,+ });+ } catch (error) {+ normalizeAwsError(input.mode === "archive" ? "updateSecretVersionStage" : "deleteSecret", error);+ }+ },+ healthCheck,+ };+}++export const awsSecretsManagerProvider = createAwsSecretsManagerProvider();diff --git a/server/src/secrets/configured-provider.ts b/server/src/secrets/configured-provider.tsnew file mode 100644index 0000000000..25dd821e65--- /dev/null+++ b/server/src/secrets/configured-provider.ts@@ -0,0 +1,8 @@+import { SECRET_PROVIDERS, type SecretProvider } from "@paperclipai/shared";++export function getConfiguredSecretProvider(): SecretProvider {+ const configuredProvider = process.env.PAPERCLIP_SECRETS_PROVIDER;+ return configuredProvider && SECRET_PROVIDERS.includes(configuredProvider as SecretProvider)+ ? configuredProvider as SecretProvider+ : "local_encrypted";+}diff --git a/server/src/secrets/external-stub-providers.ts b/server/src/secrets/external-stub-providers.tsindex 3e808abf80..bd2d2f2374 100644--- a/server/src/secrets/external-stub-providers.ts+++ b/server/src/secrets/external-stub-providers.ts@@ -1,23 +1,78 @@import { unprocessable } from "../errors.js";-import type { SecretProviderModule } from "./types.js";+import type { PreparedSecretVersion, SecretProviderModule } from "./types.js";+import { createHash } from "node:crypto";function unavailableProvider(id: "aws_secrets_manager" | "gcp_secret_manager" | "vault",label: string,): SecretProviderModule {+ function externalFingerprint(externalRef: string, providerVersionRef: string | null): string {+ return createHash("sha256")+ .update(`${id}:${externalRef}:${providerVersionRef ?? ""}`)+ .digest("hex");+ }++ function prepareExternalReference(input: {+ externalRef: string;+ providerVersionRef?: string | null;+ }): PreparedSecretVersion {+ const externalRef = input.externalRef.trim();+ const providerVersionRef = input.providerVersionRef?.trim() || null;+ const fingerprint = externalFingerprint(externalRef, providerVersionRef);+ return {+ material: {+ scheme: "external_reference_v1",+ provider: id,+ externalRef,+ providerVersionRef,+ },+ valueSha256: fingerprint,+ fingerprintSha256: fingerprint,+ externalRef,+ providerVersionRef,+ };+ }+return {id,- descriptor: {- id,- label,- requiresExternalRef: true,+ descriptor() {+ return {+ id,+ label,+ requiresExternalRef: true,+ supportsManagedValues: false,+ supportsExternalReferences: true,+ configured: false,+ };+ },+ async validateConfig() {+ return { ok: false, warnings: [`${id} provider is not configured in this deployment`] };+ },+ async createSecret() {+ throw unprocessable(`${id} provider is not configured for Paperclip-managed values`);},async createVersion() {- throw unprocessable(`${id} provider is not configured in this deployment`);+ throw unprocessable(`${id} provider is not configured for Paperclip-managed values`);+ },+ async linkExternalSecret(input) {+ return prepareExternalReference(input);},async resolveVersion() {throw unprocessable(`${id} provider is not configured in this deployment`);},+ async deleteOrArchive() {+ // External references are metadata-only in Paperclip for unconfigured providers.+ },+ async healthCheck() {+ return {+ provider: id,+ status: "warn",+ message: `${id} provider is available for external references but not configured for runtime resolution`,+ warnings: [+ "Linked external references can be stored as metadata, but runtime resolution will fail until this provider is configured.",+ ],+ };+ },};}diff --git a/server/src/secrets/local-encrypted-provider.ts b/server/src/secrets/local-encrypted-provider.tsindex a92ded202f..e19ccc470e 100644--- a/server/src/secrets/local-encrypted-provider.ts+++ b/server/src/secrets/local-encrypted-provider.ts@@ -1,7 +1,14 @@import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";-import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from "node:fs";+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";import path from "node:path";-import type { SecretProviderModule, StoredSecretVersionMaterial } from "./types.js";+import { resolveDefaultSecretsKeyFilePath } from "../home-paths.js";+import type {+ PreparedSecretVersion,+ SecretProviderHealthCheck,+ SecretProviderModule,+ SecretProviderValidationResult,+ StoredSecretVersionMaterial,+} from "./types.js";import { badRequest } from "../errors.js";interface LocalEncryptedMaterial extends StoredSecretVersionMaterial {@@ -14,7 +21,7 @@ interface LocalEncryptedMaterial extends StoredSecretVersionMaterial {function resolveMasterKeyFilePath() {const fromEnv = process.env.PAPERCLIP_SECRETS_MASTER_KEY_FILE;if (fromEnv && fromEnv.trim().length > 0) return path.resolve(fromEnv.trim());- return path.resolve(process.cwd(), "data/secrets/master.key");+ return resolveDefaultSecretsKeyFilePath();}function decodeMasterKey(raw: string): Buffer | null {@@ -52,6 +59,7 @@ function loadOrCreateMasterKey(): Buffer {const keyPath = resolveMasterKeyFilePath();if (existsSync(keyPath)) {+ enforceKeyFilePermissionsBestEffort(keyPath);const raw = readFileSync(keyPath, "utf8");const decoded = decodeMasterKey(raw);if (!decoded) {@@ -72,10 +80,118 @@ function loadOrCreateMasterKey(): Buffer {return generated;}+function enforceKeyFilePermissionsBestEffort(keyPath: string) {+ try {+ const mode = statSync(keyPath).mode & 0o777;+ if ((mode & 0o077) !== 0) {+ chmodSync(keyPath, 0o600);+ }+ } catch {+ // best effort only; health checks surface persistent permission problems.+ }+}+function sha256Hex(value: string): string {return createHash("sha256").update(value).digest("hex");}+function prepareManagedVersion(value: string): PreparedSecretVersion {+ const masterKey = loadOrCreateMasterKey();+ const valueSha256 = sha256Hex(value);+ return {+ material: encryptValue(masterKey, value),+ valueSha256,+ fingerprintSha256: valueSha256,+ externalRef: null,+ };+}++async function inspectLocalEncryptedHealth(): Promise<SecretProviderHealthCheck> {+ const envKeyRaw = process.env.PAPERCLIP_SECRETS_MASTER_KEY;+ if (envKeyRaw && envKeyRaw.trim().length > 0) {+ if (!decodeMasterKey(envKeyRaw)) {+ return {+ provider: "local_encrypted",+ status: "error",+ message:+ "PAPERCLIP_SECRETS_MASTER_KEY is invalid; expected 32-byte base64, 64-char hex, or raw 32-char string",+ };+ }+ return {+ provider: "local_encrypted",+ status: "ok",+ message: "Local encrypted provider is using PAPERCLIP_SECRETS_MASTER_KEY",+ backupGuidance: [+ "Back up the configured master key separately from the database.",+ "A restore needs both the database metadata and the same master key.",+ ],+ details: { keySource: "env" },+ };+ }++ const keyPath = resolveMasterKeyFilePath();+ if (!existsSync(keyPath)) {+ return {+ provider: "local_encrypted",+ status: "warn",+ message: `Secrets key file does not exist yet: ${keyPath}`,+ warnings: ["The first managed secret write will create this key file with 0600 permissions."],+ backupGuidance: [+ "Back up the key file together with database backups.",+ "The database alone cannot restore local encrypted secret values.",+ ],+ details: { keySource: "file", keyFilePath: keyPath },+ };+ }++ let mode: number | null = null;+ try {+ mode = statSync(keyPath).mode & 0o777;+ } catch (err) {+ return {+ provider: "local_encrypted",+ status: "error",+ message: `Could not stat secrets key file: ${err instanceof Error ? err.message : String(err)}`,+ details: { keySource: "file", keyFilePath: keyPath },+ };+ }++ try {+ const raw = readFileSync(keyPath, "utf8");+ if (!decodeMasterKey(raw)) {+ return {+ provider: "local_encrypted",+ status: "error",+ message: `Invalid key material in ${keyPath}`,+ details: { keySource: "file", keyFilePath: keyPath },+ };+ }+ } catch (err) {+ return {+ provider: "local_encrypted",+ status: "error",+ message: `Could not read secrets key file: ${err instanceof Error ? err.message : String(err)}`,+ details: { keySource: "file", keyFilePath: keyPath },+ };+ }++ const warnings =+ mode !== null && (mode & 0o077) !== 0+ ? [`Secrets key file permissions are ${mode.toString(8)}; run chmod 600 ${keyPath}`]+ : [];+ return {+ provider: "local_encrypted",+ status: warnings.length > 0 ? "warn" : "ok",+ message: `Local encrypted provider configured with key file ${keyPath}`,+ warnings,+ backupGuidance: [+ "Back up the key file together with database backups.",+ "The database alone cannot restore local encrypted secret values.",+ ],+ details: { keySource: "file", keyFilePath: keyPath },+ };+}+function encryptValue(masterKey: Buffer, value: string): LocalEncryptedMaterial {const iv = randomBytes(12);const cipher = createCipheriv("aes-256-gcm", masterKey, iv);@@ -115,21 +231,45 @@ function asLocalEncryptedMaterial(value: StoredSecretVersionMaterial): LocalEncrexport const localEncryptedProvider: SecretProviderModule = {id: "local_encrypted",- descriptor: {- id: "local_encrypted",- label: "Local encrypted (default)",- requiresExternalRef: false,- },- async createVersion(input) {- const masterKey = loadOrCreateMasterKey();+ descriptor() {return {- material: encryptValue(masterKey, input.value),- valueSha256: sha256Hex(input.value),- externalRef: null,+ id: "local_encrypted",+ label: "Local encrypted (default)",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: false,+ configured: true,};},+ async validateConfig(input): Promise<SecretProviderValidationResult> {+ const warnings: string[] = [];+ if (input?.deploymentMode === "authenticated" && input.strictMode !== true) {+ warnings.push("Strict secret mode should be enabled for authenticated deployments");+ }+ const health = await inspectLocalEncryptedHealth();+ if (health.status === "error") {+ throw badRequest(health.message);+ }+ warnings.push(...(health.warnings ?? []));+ return { ok: true, warnings };+ },+ async createSecret(input) {+ return prepareManagedVersion(input.value);+ },+ async createVersion(input) {+ return prepareManagedVersion(input.value);+ },+ async linkExternalSecret() {+ throw badRequest("local_encrypted does not support external reference secrets");+ },async resolveVersion(input) {const masterKey = loadOrCreateMasterKey();return decryptValue(masterKey, asLocalEncryptedMaterial(input.material));},+ async deleteOrArchive() {+ // Secret metadata deletion is handled in Paperclip DB; the local key is shared and must remain.+ },+ async healthCheck() {+ return inspectLocalEncryptedHealth();+ },};diff --git a/server/src/secrets/provider-registry.ts b/server/src/secrets/provider-registry.tsindex 95e16de8d7..f181b8b829 100644--- a/server/src/secrets/provider-registry.ts+++ b/server/src/secrets/provider-registry.ts@@ -1,11 +1,11 @@import type { SecretProvider, SecretProviderDescriptor } from "@paperclipai/shared";+import { awsSecretsManagerProvider } from "./aws-secrets-manager-provider.js";import { localEncryptedProvider } from "./local-encrypted-provider.js";import {- awsSecretsManagerProvider,gcpSecretManagerProvider,vaultProvider,} from "./external-stub-providers.js";-import type { SecretProviderModule } from "./types.js";+import type { SecretProviderHealthCheck, SecretProviderModule } from "./types.js";import { unprocessable } from "../errors.js";const providers: SecretProviderModule[] = [@@ -26,5 +26,9 @@ export function getSecretProvider(id: SecretProvider): SecretProviderModule {}export function listSecretProviders(): SecretProviderDescriptor[] {- return providers.map((provider) => provider.descriptor);+ return providers.map((provider) => provider.descriptor());+}++export async function checkSecretProviders(): Promise<SecretProviderHealthCheck[]> {+ return Promise.all(providers.map((provider) => provider.healthCheck()));}diff --git a/server/src/secrets/types.ts b/server/src/secrets/types.tsindex 5f9ed1b900..341163e6be 100644--- a/server/src/secrets/types.ts+++ b/server/src/secrets/types.ts@@ -1,22 +1,180 @@import type { SecretProvider, SecretProviderDescriptor } from "@paperclipai/shared";+import type { DeploymentMode } from "@paperclipai/shared";export interface StoredSecretVersionMaterial {[key: string]: unknown;}+export type SecretProviderHealthStatus = "ok" | "warn" | "error";++export interface SecretProviderHealthCheck {+ provider: SecretProvider;+ status: SecretProviderHealthStatus;+ message: string;+ warnings?: string[];+ backupGuidance?: string[];+ details?: Record<string, unknown>;+}++export interface SecretProviderValidationResult {+ ok: boolean;+ warnings: string[];+}++export interface PreparedSecretVersion {+ material: StoredSecretVersionMaterial;+ valueSha256: string;+ fingerprintSha256?: string;+ externalRef: string | null;+ providerVersionRef?: string | null;+}++export interface RemoteSecretListEntry {+ externalRef: string;+ name: string;+ providerVersionRef?: string | null;+ metadata?: Record<string, unknown> | null;+}++export interface RemoteSecretListResult {+ secrets: RemoteSecretListEntry[];+ nextToken?: string | null;+}++export type SecretProviderClientErrorCode =+ | "access_denied"+ | "throttled"+ | "not_found"+ | "conflict"+ | "invalid_request"+ | "provider_unavailable"+ | "provider_error";++export interface SecretProviderClientErrorOptions {+ code: SecretProviderClientErrorCode;+ provider: SecretProvider;+ operation: string;+ message: string;+ status?: number;+ rawMessage?: string | null;+ cause?: unknown;+}++const SECRET_PROVIDER_CLIENT_ERROR_STATUS: Record<SecretProviderClientErrorCode, number> = {+ access_denied: 403,+ throttled: 429,+ not_found: 404,+ conflict: 409,+ invalid_request: 422,+ provider_unavailable: 503,+ provider_error: 502,+};++export class SecretProviderClientError extends Error {+ readonly code: SecretProviderClientErrorCode;+ readonly provider: SecretProvider;+ readonly operation: string;+ readonly status: number;+ readonly rawMessage: string | null;++ constructor(options: SecretProviderClientErrorOptions) {+ super(options.message);+ this.name = "SecretProviderClientError";+ this.code = options.code;+ this.provider = options.provider;+ this.operation = options.operation;+ this.status = options.status ?? SECRET_PROVIDER_CLIENT_ERROR_STATUS[options.code];+ this.rawMessage = options.rawMessage ?? null;+ if (options.cause !== undefined) {+ Object.defineProperty(this, "cause", {+ value: options.cause,+ enumerable: false,+ configurable: true,+ });+ }+ }+}++export function isSecretProviderClientError(error: unknown): error is SecretProviderClientError {+ return error instanceof SecretProviderClientError;+}++export interface SecretProviderRuntimeContext {+ companyId: string;+ secretId: string;+ secretKey: string;+ version: number;+}++export interface SecretProviderVaultRuntimeConfig {+ id: string;+ provider: SecretProvider;+ status: string;+ config: Record<string, unknown>;+}++export interface SecretProviderWriteContext {+ companyId: string;+ secretKey: string;+ secretName: string;+ version: number;+}+export interface SecretProviderModule {id: SecretProvider;- descriptor: SecretProviderDescriptor;+ descriptor(): SecretProviderDescriptor;+ validateConfig(input?: {+ deploymentMode?: DeploymentMode;+ strictMode?: boolean;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<SecretProviderValidationResult>;+ createSecret(input: {+ value: string;+ externalRef?: string | null;+ context?: SecretProviderWriteContext;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<PreparedSecretVersion>;createVersion(input: {value: string;- externalRef: string | null;- }): Promise<{- material: StoredSecretVersionMaterial;- valueSha256: string;- externalRef: string | null;- }>;+ externalRef?: string | null;+ context?: SecretProviderWriteContext;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<PreparedSecretVersion>;+ linkExternalSecret(input: {+ externalRef: string;+ providerVersionRef?: string | null;+ context?: SecretProviderWriteContext;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<PreparedSecretVersion>;+ listRemoteSecrets?(input: {+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ query?: string | null;+ nextToken?: string | null;+ pageSize?: number;+ }): Promise<RemoteSecretListResult>;resolveVersion(input: {material: StoredSecretVersionMaterial;externalRef: string | null;+ providerVersionRef?: string | null;+ context?: SecretProviderRuntimeContext;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;}): Promise<string>;+ rotate?(input: {+ material: StoredSecretVersionMaterial;+ externalRef: string | null;+ providerVersionRef?: string | null;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<PreparedSecretVersion>;+ deleteOrArchive(input: {+ material?: StoredSecretVersionMaterial | null;+ externalRef: string | null;+ context?: SecretProviderWriteContext;+ mode: "archive" | "delete";+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<void>;+ healthCheck(input?: {+ deploymentMode?: DeploymentMode;+ strictMode?: boolean;+ providerConfig?: SecretProviderVaultRuntimeConfig | null;+ }): Promise<SecretProviderHealthCheck>;}diff --git a/server/src/services/environment-config.ts b/server/src/services/environment-config.tsindex 2c9bdf413b..e95fe37f7f 100644--- a/server/src/services/environment-config.ts+++ b/server/src/services/environment-config.ts@@ -9,6 +9,8 @@ import type {PluginEnvironmentConfig,PluginSandboxEnvironmentConfig,SandboxEnvironmentConfig,+ SecretProvider,+ SecretVersionSelector,SshEnvironmentConfig,} from "@paperclipai/shared";import { unprocessable } from "../errors.js";@@ -165,6 +167,7 @@ async function createEnvironmentSecret(input: {environmentName: string;driver: EnvironmentDriver;field: string;+ provider: SecretProvider;value: string;actor?: { userId?: string | null; agentId?: string | null };}) {@@ -172,7 +175,7 @@ async function createEnvironmentSecret(input: {input.companyId,{name: secretName(input),- provider: "local_encrypted",+ provider: input.provider,value: input.value,description: `Secret for ${input.environmentName} ${input.field}.`,},@@ -190,6 +193,7 @@ async function persistConfigSecretRefs(input: {companyId: string;environmentName: string;driver: EnvironmentDriver;+ secretProvider: SecretProvider;config: Record<string, unknown>;schema: Record<string, unknown> | null;actor?: { userId?: string | null; agentId?: string | null };@@ -213,6 +217,7 @@ async function persistConfigSecretRefs(input: {environmentName: input.environmentName,driver: input.driver,field: path.replace(/[^a-z0-9]+/gi, "-").toLowerCase(),+ provider: input.secretProvider,value: trimmed,actor: input.actor,});@@ -226,6 +231,11 @@ async function resolveConfigSecretRefsForRuntime(input: {companyId: string;config: Record<string, unknown>;schema: Record<string, unknown> | null;+ context: {+ consumerId: string;+ issueId?: string | null;+ heartbeatRunId?: string | null;+ };}): Promise<Record<string, unknown>> {const secrets = secretService(input.db);let nextConfig = { ...input.config };@@ -234,15 +244,52 @@ async function resolveConfigSecretRefsForRuntime(input: {if (typeof current !== "string") continue;const trimmed = current.trim();if (!isUuidSecretRef(trimmed)) continue;+ if (!input.context.consumerId) {+ throw unprocessable("Runtime secret resolution requires an environment id");+ }nextConfig = writeConfigValueAtPath(nextConfig,path,- await secrets.resolveSecretValue(input.companyId, trimmed, "latest"),+ await secrets.resolveSecretValue(input.companyId, trimmed, "latest", {+ consumerType: "environment",+ consumerId: input.context.consumerId,+ actorType: "system",+ actorId: null,+ issueId: input.context.issueId ?? null,+ heartbeatRunId: input.context.heartbeatRunId ?? null,+ configPath: path,+ }),);}return nextConfig;}+export async function collectEnvironmentSecretRefs(input: {+ db: Db;+ environment: Pick<Environment, "id" | "driver" | "config">;+}): Promise<Array<{ secretId: string; configPath: string; versionSelector?: SecretVersionSelector }>> {+ const parsed = parseEnvironmentDriverConfig(input.environment);+ if (parsed.driver === "ssh" && parsed.config.privateKeySecretRef) {+ return [{+ secretId: parsed.config.privateKeySecretRef.secretId,+ configPath: "privateKeySecretRef",+ versionSelector: parsed.config.privateKeySecretRef.version ?? "latest",+ }];+ }+ if (parsed.driver === "sandbox" && parsed.config.provider !== "fake") {+ const schema = await getSandboxProviderConfigSchema(input.db, parsed.config.provider);+ const refs: Array<{ secretId: string; configPath: string; versionSelector?: SecretVersionSelector }> = [];+ for (const path of collectSecretRefPaths(schema)) {+ const current = readConfigValueAtPath(parsed.config as Record<string, unknown>, path);+ if (typeof current === "string" && isUuidSecretRef(current.trim())) {+ refs.push({ secretId: current.trim(), configPath: path, versionSelector: "latest" });+ }+ }+ return refs;+ }+ return [];+}+export function stripSandboxProviderEnvelope(config: SandboxEnvironmentConfig): Record<string, unknown> {const { provider: _provider, ...driverConfig } = config as Record<string, unknown>;return driverConfig;@@ -340,6 +387,7 @@ export async function normalizeEnvironmentConfigForPersistence(input: {companyId: string;environmentName: string;driver: EnvironmentDriver;+ secretProvider: SecretProvider;config: Record<string, unknown> | null | undefined;actor?: { userId?: string | null; agentId?: string | null };pluginWorkerManager?: PluginWorkerManager;@@ -361,6 +409,7 @@ export async function normalizeEnvironmentConfigForPersistence(input: {environmentName: input.environmentName,driver: input.driver,field: "private-key",+ provider: input.secretProvider,value: privateKey,actor: input.actor,});@@ -404,6 +453,7 @@ export async function normalizeEnvironmentConfigForPersistence(input: {companyId: input.companyId,environmentName: input.environmentName,driver: input.driver,+ secretProvider: input.secretProvider,config: {provider: parsed.data.provider,...validated.normalizedConfig,@@ -442,10 +492,15 @@ export async function normalizeEnvironmentConfigForPersistence(input: {export async function resolveEnvironmentDriverConfigForRuntime(db: Db,companyId: string,- environment: Pick<Environment, "driver" | "config">,+ environment: Pick<Environment, "driver" | "config"> & Partial<Pick<Environment, "id">>,+ context?: { issueId?: string | null; heartbeatRunId?: string | null },): Promise<ParsedEnvironmentConfig> {const parsed = parseEnvironmentDriverConfig(environment);const secrets = secretService(db);+ const environmentId = environment.id;+ if (parsed.driver === "ssh" && parsed.config.privateKeySecretRef && !environmentId) {+ throw unprocessable("Runtime secret resolution requires an environment id");+ }if (parsed.driver === "ssh" && parsed.config.privateKeySecretRef) {return {@@ -456,6 +511,15 @@ export async function resolveEnvironmentDriverConfigForRuntime(companyId,parsed.config.privateKeySecretRef.secretId,parsed.config.privateKeySecretRef.version ?? "latest",+ {+ consumerType: "environment",+ consumerId: environmentId!,+ actorType: "system",+ actorId: null,+ issueId: context?.issueId ?? null,+ heartbeatRunId: context?.heartbeatRunId ?? null,+ configPath: "privateKeySecretRef",+ },),},};@@ -469,6 +533,11 @@ export async function resolveEnvironmentDriverConfigForRuntime(companyId,config: parsed.config as Record<string, unknown>,schema: await getSandboxProviderConfigSchema(db, parsed.config.provider),+ context: {+ consumerId: environmentId!,+ issueId: context?.issueId ?? null,+ heartbeatRunId: context?.heartbeatRunId ?? null,+ },}) as SandboxEnvironmentConfig,};}diff --git a/server/src/services/environment-runtime.ts b/server/src/services/environment-runtime.tsindex 733d03b295..292d630dcf 100644--- a/server/src/services/environment-runtime.ts+++ b/server/src/services/environment-runtime.ts@@ -228,7 +228,10 @@ function createSshEnvironmentDriver(db: Db): EnvironmentRuntimeDriver {driver: "ssh",async acquireRunLease(input) {- const parsed = await resolveEnvironmentDriverConfigForRuntime(db, input.companyId, input.environment);+ const parsed = await resolveEnvironmentDriverConfigForRuntime(db, input.companyId, input.environment, {+ issueId: input.issueId,+ heartbeatRunId: input.heartbeatRunId,+ });if (parsed.driver !== "ssh") {throw new Error(`Expected SSH environment config for driver "${input.environment.driver}".`);}@@ -346,6 +349,7 @@ function createSandboxEnvironmentDriver(const metadataConfig = sandboxConfigFromLeaseMetadataLoose(input.lease);if (metadataConfig && metadataConfig.provider === input.provider) {const parsed = await resolveEnvironmentDriverConfigForRuntime(db, input.lease.companyId, {+ id: input.environment.id,driver: "sandbox",config: sandboxConfigForLeaseMetadata(metadataConfig),});@@ -381,7 +385,10 @@ function createSandboxEnvironmentDriver(async acquireRunLease(input) {const storedParsed = parseEnvironmentDriverConfig(input.environment);- const parsed = await resolveEnvironmentDriverConfigForRuntime(db, input.companyId, input.environment);+ const parsed = await resolveEnvironmentDriverConfigForRuntime(db, input.companyId, input.environment, {+ issueId: input.issueId,+ heartbeatRunId: input.heartbeatRunId,+ });if (parsed.driver !== "sandbox" || storedParsed.driver !== "sandbox") {throw new Error(`Expected sandbox environment config for driver "${input.environment.driver}".`);}@@ -562,6 +569,7 @@ function createSandboxEnvironmentDriver(const parsed = metadataConfig? await resolveEnvironmentDriverConfigForRuntime(db, input.lease.companyId, {+ id: input.environment.id,driver: "sandbox",config: metadataConfig as unknown as Record<string, unknown>,})diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.tsindex dc719cb69f..9dbce604cd 100644--- a/server/src/services/heartbeat.ts+++ b/server/src/services/heartbeat.ts@@ -327,17 +327,44 @@ type RuntimeConfigSecretResolver = Pick<export async function resolveExecutionRunAdapterConfig(input: {companyId: string;+ agentId?: string | null;+ issueId?: string | null;+ heartbeatRunId?: string | null;+ projectId?: string | null;executionRunConfig: Record<string, unknown>;projectEnv: unknown;secretsSvc: RuntimeConfigSecretResolver;}) {- const { config: resolvedConfig, secretKeys } = await input.secretsSvc.resolveAdapterConfigForRuntime(+ const { config: resolvedConfig, secretKeys, manifest } = await input.secretsSvc.resolveAdapterConfigForRuntime(input.companyId,input.executionRunConfig,+ input.agentId+ ? {+ consumerType: "agent",+ consumerId: input.agentId,+ actorType: "agent",+ actorId: input.agentId,+ issueId: input.issueId ?? null,+ heartbeatRunId: input.heartbeatRunId ?? null,+ }+ : undefined,);const projectEnvResolution = input.projectEnv- ? await input.secretsSvc.resolveEnvBindings(input.companyId, input.projectEnv)- : { env: {}, secretKeys: new Set<string>() };+ ? await input.secretsSvc.resolveEnvBindings(+ input.companyId,+ input.projectEnv,+ input.projectId+ ? {+ consumerType: "project",+ consumerId: input.projectId,+ actorType: "agent",+ actorId: input.agentId ?? null,+ issueId: input.issueId ?? null,+ heartbeatRunId: input.heartbeatRunId ?? null,+ }+ : undefined,+ )+ : { env: {}, secretKeys: new Set<string>(), manifest: [] };if (Object.keys(projectEnvResolution.env).length > 0) {resolvedConfig.env = {...parseObject(resolvedConfig.env),@@ -347,7 +374,11 @@ export async function resolveExecutionRunAdapterConfig(input: {secretKeys.add(key);}}- return { resolvedConfig, secretKeys };+ return {+ resolvedConfig,+ secretKeys,+ secretManifest: [...(manifest ?? []), ...(projectEnvResolution.manifest ?? [])],+ };}export function extractMentionedSkillIdsFromSources(@@ -6790,6 +6821,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})const projectContext = executionProjectId? await db.select({+ id: projects.id,executionWorkspacePolicy: projects.executionWorkspacePolicy,env: projects.env,})@@ -6995,12 +7027,23 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})});const configSnapshot = buildExecutionWorkspaceConfigSnapshot(mergedConfig, selectedEnvironmentId);const executionRunConfig = stripWorkspaceRuntimeFromExecutionRunConfig(mergedConfig);- const { resolvedConfig, secretKeys } = await resolveExecutionRunAdapterConfig({+ const { resolvedConfig, secretKeys, secretManifest } = await resolveExecutionRunAdapterConfig({companyId: agent.companyId,+ agentId: agent.id,+ issueId,+ heartbeatRunId: run.id,+ projectId: projectContext?.id ?? null,executionRunConfig,projectEnv: projectContext?.env ?? null,secretsSvc,});+ if (secretManifest.length > 0) {+ context.paperclipSecrets = {+ manifest: secretManifest,+ };+ } else {+ delete context.paperclipSecrets;+ }const runScopedMentionedSkillKeys = await resolveRunScopedMentionedSkillKeys({db,companyId: agent.companyId,@@ -8320,8 +8363,15 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})return { kind: "released" as const };}+ if (issue.originKind === RECOVERY_ORIGIN_KINDS.strandedIssueRecovery) {+ return {+ kind: "blocked_recovery_in_place" as const,+ issue,+ previousStatus: issue.status,+ };+ }+const shouldBlockImmediately =- issue.originKind === RECOVERY_ORIGIN_KINDS.strandedIssueRecovery ||!recoveryAgentInvokable ||!recoveryAgent ||didAutomaticRecoveryFail(run, issue.status === "todo" ? "assignment_recovery" : "issue_continuation_needed");@@ -8421,6 +8471,15 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})return;}+ if (promotionResult?.kind === "blocked_recovery_in_place") {+ await recovery.escalateStrandedRecoveryIssueInPlace({+ issue: promotionResult.issue,+ previousStatus: promotionResult.previousStatus as "todo" | "in_progress",+ latestRun: run,+ });+ return;+ }+const promotedRun = promotionResult?.run ?? null;if (!promotedRun) return;diff --git a/server/src/services/plugin-secrets-handler.ts b/server/src/services/plugin-secrets-handler.tsindex b80ae187bd..ccc5878a00 100644--- a/server/src/services/plugin-secrets-handler.ts+++ b/server/src/services/plugin-secrets-handler.ts@@ -33,38 +33,20 @@* @see services/secrets.ts — secretService used by agent env bindings*/-import { eq, and, desc } from "drizzle-orm";import type { Db } from "@paperclipai/db";-import { companySecrets, companySecretVersions, pluginConfig } from "@paperclipai/db";-import type { SecretProvider } from "@paperclipai/shared";-import { getSecretProvider } from "../secrets/provider-registry.js";-import { pluginRegistryService } from "./plugin-registry.js";import {collectSecretRefPaths,isUuidSecretRef,readConfigValueAtPath,} from "./json-schema-secret-refs.js";+export const PLUGIN_SECRET_REFS_DISABLED_MESSAGE =+ "Plugin secret references are disabled until company-scoped plugin config lands";+// ---------------------------------------------------------------------------// Error helpers// ----------------------------------------------------------------------------/**- * Create a sanitised error that never leaks secret material.- * Only the ref identifier is included; never the resolved value.- */-function secretNotFound(secretRef: string): Error {- const err = new Error(`Secret not found: ${secretRef}`);- err.name = "SecretNotFoundError";- return err;-}--function secretVersionNotFound(secretRef: string): Error {- const err = new Error(`No version found for secret: ${secretRef}`);- err.name = "SecretVersionNotFoundError";- return err;-}-function invalidSecretRef(secretRef: string): Error {const err = new Error(`Invalid secret reference: ${secretRef}`);err.name = "InvalidSecretRefError";@@ -86,8 +68,20 @@ export function extractSecretRefsFromConfig(configJson: unknown,schema?: Record<string, unknown> | null,): Set<string> {- const refs = new Set<string>();- if (configJson == null || typeof configJson !== "object") return refs;+ return new Set(extractSecretRefPathsFromConfig(configJson, schema).keys());+}++export function extractSecretRefPathsFromConfig(+ configJson: unknown,+ schema?: Record<string, unknown> | null,+): Map<string, Set<string>> {+ const refs = new Map<string, Set<string>>();+ const addRef = (secretRef: string, path: string) => {+ const existing = refs.get(secretRef) ?? new Set<string>();+ existing.add(path);+ refs.set(secretRef, existing);+ };+ if (configJson == null || typeof configJson !== "object") return new Map();const secretPaths = collectSecretRefPaths(schema);@@ -96,7 +90,7 @@ export function extractSecretRefsFromConfig(for (const dotPath of secretPaths) {const current = readConfigValueAtPath(configJson as Record<string, unknown>, dotPath);if (typeof current === "string" && isUuidSecretRef(current)) {- refs.add(current);+ addRef(current, dotPath);}}return refs;@@ -107,7 +101,7 @@ export function extractSecretRefsFromConfig(// instanceConfigSchema.function walkAll(value: unknown): void {if (typeof value === "string") {- if (isUuidSecretRef(value)) refs.add(value);+ if (isUuidSecretRef(value)) addRef(value, "$");} else if (Array.isArray(value)) {for (const item of value) walkAll(item);} else if (value !== null && typeof value === "object") {@@ -205,16 +199,11 @@ function createRateLimiter(maxAttempts: number, windowMs: number) {export function createPluginSecretsHandler(options: PluginSecretsHandlerOptions,): PluginSecretsService {- const { db, pluginId } = options;- const registry = pluginRegistryService(db);+ const { pluginId } = options;// Rate limit: max 30 resolution attempts per plugin per minuteconst rateLimiter = createRateLimiter(30, 60_000);- let cachedAllowedRefs: Set<string> | null = null;- let cachedAllowedRefsExpiry = 0;- const CONFIG_CACHE_TTL_MS = 30_000; // 30 seconds, matches event bus TTL-return {async resolve(params: PluginSecretsResolveParams): Promise<string> {const { secretRef } = params;@@ -241,72 +230,9 @@ export function createPluginSecretsHandler(throw invalidSecretRef(trimmedRef);}- // ---------------------------------------------------------------- // 1b. Scope check — only allow secrets referenced in this plugin's config- // ---------------------------------------------------------------- const now = Date.now();- if (!cachedAllowedRefs || now > cachedAllowedRefsExpiry) {- const [configRow, plugin] = await Promise.all([- db- .select()- .from(pluginConfig)- .where(eq(pluginConfig.pluginId, pluginId))- .then((rows) => rows[0] ?? null),- registry.getById(pluginId),- ]);-- const schema = (plugin?.manifestJson as unknown as Record<string, unknown> | null)- ?.instanceConfigSchema as Record<string, unknown> | undefined;- cachedAllowedRefs = extractSecretRefsFromConfig(configRow?.configJson, schema);- cachedAllowedRefsExpiry = now + CONFIG_CACHE_TTL_MS;- }-- if (!cachedAllowedRefs.has(trimmedRef)) {- // Return "not found" to avoid leaking whether the secret exists- throw secretNotFound(trimmedRef);- }-- // ---------------------------------------------------------------- // 2. Look up the secret record by UUID- // ---------------------------------------------------------------- const secret = await db- .select()- .from(companySecrets)- .where(eq(companySecrets.id, trimmedRef))- .then((rows) => rows[0] ?? null);-- if (!secret) {- throw secretNotFound(trimmedRef);- }-- // ---------------------------------------------------------------- // 3. Fetch the latest version's material- // ---------------------------------------------------------------- const versionRow = await db- .select()- .from(companySecretVersions)- .where(- and(- eq(companySecretVersions.secretId, secret.id),- eq(companySecretVersions.version, secret.latestVersion),- ),- )- .then((rows) => rows[0] ?? null);-- if (!versionRow) {- throw secretVersionNotFound(trimmedRef);- }-- // ---------------------------------------------------------------- // 4. Resolve through the appropriate secret provider- // ---------------------------------------------------------------- const provider = getSecretProvider(secret.provider as SecretProvider);- const resolved = await provider.resolveVersion({- material: versionRow.material as Record<string, unknown>,- externalRef: secret.externalRef,- });-- return resolved;+ // Fail closed until plugin config and worker runtime both carry an+ // explicit company scope for secret bindings and resolution.+ throw new Error(PLUGIN_SECRET_REFS_DISABLED_MESSAGE);},};}diff --git a/server/src/services/recovery/service.ts b/server/src/services/recovery/service.tsindex f2e527989e..3aee7d2b3f 100644--- a/server/src/services/recovery/service.ts+++ b/server/src/services/recovery/service.ts@@ -1313,6 +1313,33 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup }).then((rows) => rows[0] ?? null);}+ function isStrandedIssueRecoveryIssue(issue: typeof issues.$inferSelect) {+ return issue.originKind === STRANDED_ISSUE_RECOVERY_ORIGIN_KIND;+ }++ async function buildNestedStrandedRecoveryLine(issue: typeof issues.$inferSelect, prefix: string) {+ const sourceIssueId = readNonEmptyString(issue.originId);+ const sourceIssue = sourceIssueId+ ? await db+ .select({ id: issues.id, identifier: issues.identifier })+ .from(issues)+ .where(and(eq(issues.companyId, issue.companyId), eq(issues.id, sourceIssueId)))+ .then((rows) => rows[0] ?? null)+ : null;+ const sourceLine = sourceIssue+ ? `- Original source issue: ${issueUiLink(sourceIssue, prefix)}`+ : sourceIssueId+ ? `- Original source issue: \`${sourceIssueId}\``+ : "- Original source issue: unknown";++ return [+ "",+ "- Nested recovery: suppressed because this issue is already a `stranded_issue_recovery` issue.",+ sourceLine,+ "- Next action: the assigned recovery owner or board operator should fix the runtime/adapter problem, resolve or reassign the original source issue, then mark this recovery issue done or cancelled.",+ ].join("\n");+ }+async function resolveStrandedIssueRecoveryOwnerAgentId(issue: typeof issues.$inferSelect) {const candidateIds: string[] = [];if (issue.assigneeAgentId) {@@ -1623,21 +1650,17 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })recoveryCause?: StrandedRecoveryCause;successfulRunHandoffEvidence?: SuccessfulRunHandoffRecoveryEvidence | null;}) {- if (isStrandedIssueRecoveryIssue(input.issue)) {- return escalateStrandedRecoveryIssueInPlace({+ const nestedRecoverySuppressed = isStrandedIssueRecoveryIssue(input.issue);+ let recoveryIssue: typeof issues.$inferSelect | null = null;+ if (!nestedRecoverySuppressed) {+ recoveryIssue = await ensureStrandedIssueRecoveryIssue({issue: input.issue,previousStatus: input.previousStatus,latestRun: input.latestRun,+ recoveryCause: input.recoveryCause,+ successfulRunHandoffEvidence: input.successfulRunHandoffEvidence,});}-- const recoveryIssue = await ensureStrandedIssueRecoveryIssue({- issue: input.issue,- previousStatus: input.previousStatus,- latestRun: input.latestRun,- recoveryCause: input.recoveryCause,- successfulRunHandoffEvidence: input.successfulRunHandoffEvidence,- });const blockerIds = await existingUnresolvedBlockerIssueIds(input.issue.companyId, input.issue.id);const nextBlockerIds = recoveryIssue? [...new Set([...blockerIds, recoveryIssue.id])]@@ -1667,18 +1690,23 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })missingDisposition: input.successfulRunHandoffEvidence.missingDisposition,});}- const recoveryLine = recoveryIssue- ? [+ let recoveryLine: string;+ if (nestedRecoverySuppressed) {+ recoveryLine = await buildNestedStrandedRecoveryLine(input.issue, prefix);+ } else if (recoveryIssue) {+ recoveryLine = ["",`- Recovery issue: ${issueUiLink({ identifier: recoveryIssue.identifier, id: recoveryIssue.id }, prefix)}`,`- Recovery owner: ${agentUiLink(recoveryOwner, prefix)}`,"- Next action: the recovery owner should either restore a live execution path or record the manual resolution, then mark the recovery issue done.",- ].join("\n")- : [+ ].join("\n");+ } else {+ recoveryLine = ["","- Recovery issue: none created because Paperclip could not find an invokable manager, creator, or executive owner with budget available.","- Next action: a board operator should assign an invokable recovery owner, fix the agent/runtime state, or record an intentional manual resolution.",].join("\n");+ }if (notice) {await issuesSvc.addComment(input.issue.id, notice.body, {}, {@@ -1713,6 +1741,7 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })latestRunStatus: input.latestRun?.status ?? null,latestRunErrorCode: input.latestRun?.errorCode ?? null,recoveryIssueId: recoveryIssue?.id ?? null,+ nestedRecoverySuppressed,blockerIssueIds: nextBlockerIds,},});@@ -2768,6 +2797,7 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })return {buildRunOutputSilence,+ escalateStrandedRecoveryIssueInPlace,escalateStrandedAssignedIssue,recordWatchdogDecision,scanSilentActiveRuns,diff --git a/server/src/services/routines.ts b/server/src/services/routines.tsindex 14f244155a..b280119ac6 100644--- a/server/src/services/routines.ts+++ b/server/src/services/routines.ts@@ -3,6 +3,7 @@ import { and, asc, desc, eq, inArray, isNotNull, isNull, lte, ne, not, or, sql }import type { Db } from "@paperclipai/db";import {agents,+ companySecretBindings,companySecretVersions,companySecrets,executionWorkspaces,@@ -49,6 +50,7 @@ import { trackRoutineRun } from "@paperclipai/shared/telemetry";import { conflict, forbidden, notFound, unauthorized, unprocessable } from "../errors.js";import { logger } from "../middleware/logger.js";import { getTelemetryClient } from "../telemetry.js";+import { getConfiguredSecretProvider } from "../secrets/configured-provider.js";import { issueService } from "./issues.js";import { secretService } from "./secrets.js";import { getSecretProvider } from "../secrets/provider-registry.js";@@ -81,6 +83,10 @@ interface RoutineTriggerSecretRestoreMaterial extends RoutineTriggerSecretMateritriggerId: string;}+function routineWebhookSecretConfigPath(secretId: string) {+ return `webhookSecret:${secretId}`;+}+function assertTimeZone(timeZone: string) {try {new Intl.DateTimeFormat("en-US", { timeZone }).format(new Date());@@ -950,16 +956,23 @@ export function routineService(executor?: Db,) {const secretValue = crypto.randomBytes(24).toString("hex");+ const providerId = getConfiguredSecretProvider();const input = {name: `routine-${routineId}-${crypto.randomBytes(6).toString("hex")}`,- provider: "local_encrypted" as const,+ provider: providerId,value: secretValue,description: `Webhook auth for routine ${routineId}`,};const provider = getSecretProvider(input.provider);- const prepared = await provider.createVersion({+ const prepared = await provider.createSecret({value: input.value,externalRef: null,+ context: {+ companyId,+ secretKey: input.name,+ secretName: input.name,+ version: 1,+ },});const insertSecret = async (secretDb: Db) => {@@ -967,11 +980,16 @@ export function routineService(.insert(companySecrets).values({companyId,+ key: input.name,name: input.name,provider: input.provider,+ status: "active",+ managedMode: "paperclip_managed",externalRef: prepared.externalRef,+ providerMetadata: null,latestVersion: 1,description: input.description,+ lastRotatedAt: new Date(),createdByAgentId: actor.agentId ?? null,createdByUserId: actor.userId ?? null,})@@ -983,10 +1001,21 @@ export function routineService(version: 1,material: prepared.material,valueSha256: prepared.valueSha256,+ fingerprintSha256: prepared.fingerprintSha256 ?? prepared.valueSha256,+ providerVersionRef: prepared.providerVersionRef ?? null,+ status: "current",createdByAgentId: actor.agentId ?? null,createdByUserId: actor.userId ?? null,});+ await secretDb.insert(companySecretBindings).values({+ companyId,+ secretId: secret.id,+ targetType: "routine",+ targetId: routineId,+ configPath: routineWebhookSecretConfigPath(secret.id),+ });+return secret;};@@ -1004,7 +1033,13 @@ export function routineService(.where(eq(companySecrets.id, trigger.secretId)).then((rows) => rows[0] ?? null);if (!secret || secret.companyId !== companyId) throw notFound("Routine trigger secret not found");- const value = await secretsSvc.resolveSecretValue(companyId, trigger.secretId, "latest");+ const value = await secretsSvc.resolveSecretValue(companyId, trigger.secretId, "latest", {+ consumerType: "routine",+ consumerId: trigger.routineId,+ actorType: "system",+ actorId: null,+ configPath: routineWebhookSecretConfigPath(trigger.secretId),+ });return value;}diff --git a/server/src/services/secrets.ts b/server/src/services/secrets.tsindex d288d4b3b4..17f13cef3d 100644--- a/server/src/services/secrets.ts+++ b/server/src/services/secrets.ts@@ -1,20 +1,200 @@-import { and, desc, eq } from "drizzle-orm";+import { and, desc, eq, inArray, like, ne, notInArray, sql } from "drizzle-orm";import type { Db } from "@paperclipai/db";-import { companySecrets, companySecretVersions } from "@paperclipai/db";-import type { AgentEnvConfig, EnvBinding, SecretProvider } from "@paperclipai/shared";-import { envBindingSchema } from "@paperclipai/shared";-import { conflict, notFound, unprocessable } from "../errors.js";-import { getSecretProvider, listSecretProviders } from "../secrets/provider-registry.js";+import {+ agents,+ companySecretBindings,+ companySecretProviderConfigs,+ companySecrets,+ companySecretVersions,+ environments,+ heartbeatRuns,+ issues,+ projects,+ routines,+ secretAccessEvents,+} from "@paperclipai/db";+import type {+ AgentEnvConfig,+ CompanySecretBindingTarget,+ EnvBinding,+ RemoteSecretImportCandidate,+ RemoteSecretImportConflict,+ RemoteSecretImportRowResult,+ SecretBindingTargetType,+ SecretProvider,+ SecretProviderConfigHealthResponse,+ SecretProviderConfigHealthStatus,+ SecretProviderConfigStatus,+ SecretVersionSelector,+} from "@paperclipai/shared";+import {+ createSecretProviderConfigSchema,+ deriveProjectUrlKey,+ envBindingSchema,+ isUuidLike,+ normalizeAgentUrlKey,+ secretProviderConfigPayloadSchema,+ updateSecretProviderConfigSchema,+} from "@paperclipai/shared";+import { conflict, HttpError, notFound, unprocessable } from "../errors.js";+import { logger } from "../middleware/logger.js";+import {+ checkSecretProviders,+ getSecretProvider,+ listSecretProviders,+} from "../secrets/provider-registry.js";+import type {+ PreparedSecretVersion,+ RemoteSecretListResult,+ SecretProviderHealthCheck,+ SecretProviderModule,+ SecretProviderVaultRuntimeConfig,+ SecretProviderWriteContext,+} from "../secrets/types.js";+import { isSecretProviderClientError } from "../secrets/types.js";const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;const SENSITIVE_ENV_KEY_RE =/(api[-_]?key|access[-_]?token|auth(?:_?token)?|authorization|bearer|secret|passwd|password|credential|jwt|private[-_]?key|cookie|connectionstring)/i;const REDACTED_SENTINEL = "***REDACTED***";+const COMING_SOON_SECRET_PROVIDERS: ReadonlySet<SecretProvider> = new Set([+ "gcp_secret_manager",+ "vault",+]);++function remoteProviderHttpError(error: unknown, context: {+ companyId: string;+ provider: SecretProvider;+ providerConfigId: string;+ operation: string;+}): HttpError {+ if (isSecretProviderClientError(error)) {+ logger.warn(+ {+ err: error,+ companyId: context.companyId,+ provider: context.provider,+ providerConfigId: context.providerConfigId,+ operation: context.operation,+ providerErrorCode: error.code,+ },+ "remote secret provider request failed",+ );+ return new HttpError(error.status, error.message, { code: error.code });+ }+ if (error instanceof HttpError) return error;+ logger.warn(+ {+ err: error,+ companyId: context.companyId,+ provider: context.provider,+ providerConfigId: context.providerConfigId,+ operation: context.operation,+ providerErrorCode: "provider_error",+ },+ "remote secret provider request failed",+ );+ return new HttpError(502, "Remote secret provider request failed.", { code: "provider_error" });+}++function remoteImportRowFailureReason(error: unknown, fallback: string, context: {+ companyId: string;+ provider: SecretProvider;+ providerConfigId: string;+ operation: string;+}): string {+ if (isSecretProviderClientError(error)) {+ logger.warn(+ {+ err: error,+ companyId: context.companyId,+ provider: context.provider,+ providerConfigId: context.providerConfigId,+ operation: context.operation,+ providerErrorCode: error.code,+ },+ "remote secret import row provider failure",+ );+ return error.message;+ }+ if (error instanceof HttpError && error.status < 500) return error.message;+ logger.warn(+ {+ err: error,+ companyId: context.companyId,+ provider: context.provider,+ providerConfigId: context.providerConfigId,+ operation: context.operation,+ providerErrorCode: "provider_error",+ },+ "remote secret import row failed",+ );+ return fallback;+}++async function cleanupPreparedProviderWrite(input: {+ provider: SecretProviderModule;+ prepared: PreparedSecretVersion;+ providerConfig: SecretProviderVaultRuntimeConfig | null;+ context: SecretProviderWriteContext;+ mode: "archive" | "delete";+ operation: string;+}): Promise<boolean> {+ try {+ await input.provider.deleteOrArchive({+ material: input.prepared.material,+ externalRef: input.prepared.externalRef,+ providerConfig: input.providerConfig,+ context: input.context,+ mode: input.mode,+ });+ return true;+ } catch (cleanupError) {+ logger.warn(+ {+ err: cleanupError,+ companyId: input.context.companyId,+ provider: input.provider.id,+ providerConfigId: input.providerConfig?.id ?? null,+ operation: input.operation,+ },+ "remote secret provider cleanup failed after db write failure",+ );+ return false;+ }+}type CanonicalEnvBinding =| { type: "plain"; value: string }| { type: "secret_ref"; secretId: string; version: number | "latest" };+type SecretConsumerContext = {+ consumerType: SecretBindingTargetType;+ consumerId: string;+ configPath?: string | null;+ actorType?: "agent" | "user" | "system" | "plugin";+ actorId?: string | null;+ issueId?: string | null;+ heartbeatRunId?: string | null;+ pluginId?: string | null;+};++export type RuntimeSecretManifestEntry = {+ configPath: string;+ envKey: string | null;+ secretId: string;+ secretKey: string;+ version: number;+ provider: SecretProvider;+ outcome: "success" | "failure";+ errorCode?: string | null;+};++type RuntimeSecretResolution = {+ value: string;+ manifestEntry: RuntimeSecretManifestEntry;+};+function asRecord(value: unknown): Record<string, unknown> | null {if (typeof value !== "object" || value === null || Array.isArray(value)) return null;return value as Record<string, unknown>;@@ -24,6 +204,22 @@ function isSensitiveEnvKey(key: string) {return SENSITIVE_ENV_KEY_RE.test(key);}+function normalizeSecretKey(input: string) {+ return input+ .trim()+ .toLowerCase()+ .replace(/[^a-z0-9_.-]+/g, "-")+ .replace(/^-+|-+$/g, "")+ .slice(0, 120);+}++function deriveSecretNameFromExternalRef(externalRef: string) {+ const trimmed = externalRef.trim();+ const arnMatch = /^arn:[^:]+:secretsmanager:[^:]*:[^:]*:secret:(.+)$/i.exec(trimmed);+ const name = arnMatch?.[1] ?? trimmed;+ return name.split("/").filter(Boolean).at(-1) ?? name;+}+function canonicalizeBinding(binding: EnvBinding): CanonicalEnvBinding {if (typeof binding === "string") {return { type: "plain", value: binding };@@ -38,6 +234,25 @@ function canonicalizeBinding(binding: EnvBinding): CanonicalEnvBinding {};}+function defaultProviderConfigStatus(provider: SecretProvider): SecretProviderConfigStatus {+ return COMING_SOON_SECRET_PROVIDERS.has(provider) ? "coming_soon" : "ready";+}++function assertSelectableProviderConfig(config: {+ provider: string;+ status: string;+ companyId: string;+}, companyId: string, provider: SecretProvider) {+ if (config.companyId !== companyId) throw unprocessable("Provider vault must belong to same company");+ if (config.provider !== provider) throw unprocessable("Provider vault must match the secret provider");+ if (config.status === "coming_soon") {+ throw unprocessable("Provider vault is locked while coming soon");+ }+ if (config.status === "disabled") {+ throw unprocessable("Provider vault is disabled");+ }+}+export function secretService(db: Db) {type NormalizeEnvOptions = {strictMode?: boolean;@@ -56,7 +271,11 @@ export function secretService(db: Db) {return db.select().from(companySecrets)- .where(and(eq(companySecrets.companyId, companyId), eq(companySecrets.name, name)))+ .where(and(+ eq(companySecrets.companyId, companyId),+ eq(companySecrets.name, name),+ ne(companySecrets.status, "deleted"),+ )).then((rows) => rows[0] ?? null);}@@ -73,27 +292,290 @@ export function secretService(db: Db) {.then((rows) => rows[0] ?? null);}+ async function getBinding(input: {+ companyId: string;+ secretId: string;+ consumerType: SecretBindingTargetType;+ consumerId: string;+ configPath: string;+ }) {+ return db+ .select()+ .from(companySecretBindings)+ .where(+ and(+ eq(companySecretBindings.companyId, input.companyId),+ eq(companySecretBindings.secretId, input.secretId),+ eq(companySecretBindings.targetType, input.consumerType),+ eq(companySecretBindings.targetId, input.consumerId),+ eq(companySecretBindings.configPath, input.configPath),+ ),+ )+ .then((rows) => rows[0] ?? null);+ }++ async function assertBindingContext(+ companyId: string,+ secretId: string,+ context: SecretConsumerContext | undefined,+ ) {+ if (!context) return;+ if (!context.configPath) {+ throw unprocessable("Secret resolution requires a binding config path");+ }+ const binding = await getBinding({+ companyId,+ secretId,+ consumerType: context.consumerType,+ consumerId: context.consumerId,+ configPath: context.configPath,+ });+ if (!binding) {+ throw unprocessable(+ `Secret is not bound to ${context.consumerType}:${context.consumerId} at ${context.configPath}`,+ );+ }+ }++ async function recordAccessEvent(input: {+ companyId: string;+ secretId: string;+ version: number | null;+ provider: SecretProvider;+ context: SecretConsumerContext | undefined;+ outcome: "success" | "failure";+ errorCode?: string | null;+ }) {+ if (!input.context) return;+ await db.insert(secretAccessEvents).values({+ companyId: input.companyId,+ secretId: input.secretId,+ version: input.version,+ provider: input.provider,+ actorType: input.context.actorType ?? "system",+ actorId: input.context.actorId ?? null,+ consumerType: input.context.consumerType,+ consumerId: input.context.consumerId,+ configPath: input.context.configPath ?? null,+ issueId: input.context.issueId ?? null,+ heartbeatRunId: input.context.heartbeatRunId ?? null,+ pluginId: input.context.pluginId ?? null,+ outcome: input.outcome,+ errorCode: input.errorCode ?? null,+ });+ }+async function assertSecretInCompany(companyId: string, secretId: string) {const secret = await getById(secretId);if (!secret) throw notFound("Secret not found");+ if (secret.status === "deleted") throw notFound("Secret not found");if (secret.companyId !== companyId) throw unprocessable("Secret must belong to same company");return secret;}- async function resolveSecretValue(+ async function getProviderConfigById(id: string) {+ return db+ .select()+ .from(companySecretProviderConfigs)+ .where(eq(companySecretProviderConfigs.id, id))+ .then((rows) => rows[0] ?? null);+ }++ async function assertProviderConfigForSecret(+ companyId: string,+ provider: SecretProvider,+ providerConfigId: string | null | undefined,+ ) {+ if (!providerConfigId) return null;+ const providerConfig = await getProviderConfigById(providerConfigId);+ if (!providerConfig) throw notFound("Provider vault not found");+ assertSelectableProviderConfig(providerConfig, companyId, provider);+ return providerConfig;+ }++ function toProviderVaultRuntimeConfig(+ providerConfig: Awaited<ReturnType<typeof getProviderConfigById>> | null,+ ): SecretProviderVaultRuntimeConfig | null {+ if (!providerConfig) return null;+ return {+ id: providerConfig.id,+ provider: providerConfig.provider as SecretProvider,+ status: providerConfig.status,+ config: providerConfig.config ?? {},+ };+ }++ async function getSelectableRuntimeProviderConfig(input: {+ companyId: string;+ provider: SecretProvider;+ providerConfigId: string | null | undefined;+ }) {+ const providerConfig = await assertProviderConfigForSecret(+ input.companyId,+ input.provider,+ input.providerConfigId,+ );+ return toProviderVaultRuntimeConfig(providerConfig);+ }++ function validateProviderConfigPayload(+ provider: SecretProvider,+ config: Record<string, unknown>,+ ): Record<string, unknown> {+ const parsed = secretProviderConfigPayloadSchema.safeParse({ provider, config });+ if (!parsed.success) {+ throw unprocessable("Invalid provider vault config", parsed.error.flatten());+ }+ return parsed.data.config;+ }++ function providerConfigHealth(input: {+ id: string;+ provider: SecretProvider;+ status: SecretProviderConfigStatus;+ config: Record<string, unknown>;+ }): Omit<SecretProviderConfigHealthResponse, "checkedAt"> | null {+ if (input.status === "disabled") {+ return {+ configId: input.id,+ provider: input.provider,+ status: "disabled",+ message: "Provider vault is disabled.",+ details: { code: "disabled", message: "Provider vault is disabled." },+ };+ }+ if (input.status === "coming_soon" || COMING_SOON_SECRET_PROVIDERS.has(input.provider)) {+ return {+ configId: input.id,+ provider: input.provider,+ status: "coming_soon",+ message: "Provider vault runtime is locked while coming soon.",+ details: {+ code: "runtime_locked",+ message: "Provider vault runtime is locked while coming soon.",+ guidance: ["Draft metadata may be saved, but create, rotate, and resolve stay unavailable."],+ },+ };+ }+ return null;+ }++ function mapProviderModuleHealth(input: {+ configId: string;+ provider: SecretProvider;+ providerStatus: SecretProviderConfigStatus;+ health: SecretProviderHealthCheck;+ }): Omit<SecretProviderConfigHealthResponse, "checkedAt"> {+ const status: SecretProviderConfigHealthStatus =+ input.health.status === "ok"+ ? input.providerStatus === "warning" ? "warning" : "ready"+ : input.health.status === "error"+ ? "error"+ : "warning";+ const guidance = [+ ...(input.health.warnings ?? []),+ ...(input.health.backupGuidance ?? []),+ ];+ return {+ configId: input.configId,+ provider: input.provider,+ status,+ message: input.health.message,+ details: {+ code: input.health.status === "ok" ? "provider_ready" : "provider_needs_attention",+ message: input.health.message,+ guidance: guidance.length > 0 ? guidance : undefined,+ },+ };+ }++ async function resolveSecretValueInternal(companyId: string,secretId: string,version: number | "latest",- ): Promise<string> {+ context?: SecretConsumerContext,+ ): Promise<RuntimeSecretResolution> {const secret = await assertSecretInCompany(companyId, secretId);const resolvedVersion = version === "latest" ? secret.latestVersion : version;- const versionRow = await getSecretVersion(secret.id, resolvedVersion);- if (!versionRow) throw notFound("Secret version not found");- const provider = getSecretProvider(secret.provider as SecretProvider);- return provider.resolveVersion({- material: versionRow.material as Record<string, unknown>,- externalRef: secret.externalRef,- });+ const providerId = secret.provider as SecretProvider;+ const configPath = context?.configPath ?? null;+ try {+ if (secret.status !== "active") {+ throw unprocessable("Secret is not active");+ }+ await assertBindingContext(companyId, secret.id, context);+ const versionRow = await getSecretVersion(secret.id, resolvedVersion);+ if (!versionRow) throw notFound("Secret version not found");+ if (versionRow.status === "disabled" || versionRow.status === "destroyed" || versionRow.revokedAt) {+ throw unprocessable("Secret version is not active");+ }+ const provider = getSecretProvider(providerId);+ const providerConfig = await getSelectableRuntimeProviderConfig({+ companyId,+ provider: providerId,+ providerConfigId: secret.providerConfigId,+ });+ const value = await provider.resolveVersion({+ material: versionRow.material as Record<string, unknown>,+ externalRef: secret.externalRef,+ providerVersionRef: versionRow.providerVersionRef,+ providerConfig,+ context: {+ companyId,+ secretId: secret.id,+ secretKey: secret.key,+ version: resolvedVersion,+ },+ });+ await Promise.all([+ db+ .update(companySecrets)+ .set({ lastResolvedAt: new Date(), updatedAt: new Date() })+ .where(eq(companySecrets.id, secret.id))+ .catch(() => undefined),+ recordAccessEvent({+ companyId,+ secretId: secret.id,+ version: resolvedVersion,+ provider: providerId,+ context,+ outcome: "success",+ }).catch(() => undefined),+ ]);+ return {+ value,+ manifestEntry: {+ configPath: configPath ?? "",+ envKey: configPath?.startsWith("env.") ? configPath.slice("env.".length) : null,+ secretId: secret.id,+ secretKey: secret.key,+ version: resolvedVersion,+ provider: providerId,+ outcome: "success",+ },+ };+ } catch (err) {+ const errorCode = err instanceof Error ? err.message.slice(0, 120) : "resolution_failed";+ await recordAccessEvent({+ companyId,+ secretId: secret.id,+ version: resolvedVersion,+ provider: providerId,+ context,+ outcome: "failure",+ errorCode,+ }).catch(() => undefined);+ throw err;+ }+ }++ async function resolveSecretValue(+ companyId: string,+ secretId: string,+ version: number | "latest",+ context?: SecretConsumerContext,+ ): Promise<string> {+ return (await resolveSecretValueInternal(companyId, secretId, version, context)).value;}async function normalizeEnvConfig(@@ -152,15 +634,817 @@ export function secretService(db: Db) {return normalized;}+ function collectTargetIds(+ bindings: Array<typeof companySecretBindings.$inferSelect>,+ targetType: SecretBindingTargetType,+ opts?: { uuidOnly?: boolean },+ ) {+ return [+ ...new Set(+ bindings+ .filter((binding) => binding.targetType === targetType)+ .map((binding) => binding.targetId)+ .filter((id) => !opts?.uuidOnly || isUuidLike(id)),+ ),+ ];+ }++ function fallbackBindingTarget(binding: typeof companySecretBindings.$inferSelect): CompanySecretBindingTarget {+ return {+ type: binding.targetType as SecretBindingTargetType,+ id: binding.targetId,+ label: binding.targetId,+ href: null,+ status: null,+ };+ }++ async function buildBindingTargetMap(+ companyId: string,+ bindings: Array<typeof companySecretBindings.$inferSelect>,+ ) {+ const targetMap = new Map<string, CompanySecretBindingTarget>();+ const setTarget = (target: CompanySecretBindingTarget) => {+ targetMap.set(`${target.type}:${target.id}`, target);+ };++ const agentIds = collectTargetIds(bindings, "agent", { uuidOnly: true });+ if (agentIds.length > 0) {+ const rows = await db+ .select({+ id: agents.id,+ name: agents.name,+ title: agents.title,+ status: agents.status,+ })+ .from(agents)+ .where(and(eq(agents.companyId, companyId), inArray(agents.id, agentIds)));+ for (const row of rows) {+ setTarget({+ type: "agent",+ id: row.id,+ label: row.title ? `${row.name} (${row.title})` : row.name,+ href: `/agents/${normalizeAgentUrlKey(row.name) ?? row.id}`,+ status: row.status,+ });+ }+ }++ const projectIds = collectTargetIds(bindings, "project", { uuidOnly: true });+ if (projectIds.length > 0) {+ const rows = await db+ .select({+ id: projects.id,+ name: projects.name,+ status: projects.status,+ })+ .from(projects)+ .where(and(eq(projects.companyId, companyId), inArray(projects.id, projectIds)));+ for (const row of rows) {+ setTarget({+ type: "project",+ id: row.id,+ label: row.name,+ href: `/projects/${deriveProjectUrlKey(row.name, row.id)}`,+ status: row.status,+ });+ }+ }++ const environmentIds = collectTargetIds(bindings, "environment", { uuidOnly: true });+ if (environmentIds.length > 0) {+ const rows = await db+ .select({+ id: environments.id,+ name: environments.name,+ status: environments.status,+ })+ .from(environments)+ .where(and(eq(environments.companyId, companyId), inArray(environments.id, environmentIds)));+ for (const row of rows) {+ setTarget({+ type: "environment",+ id: row.id,+ label: row.name,+ href: "/company/settings/environments",+ status: row.status,+ });+ }+ }++ const routineIds = collectTargetIds(bindings, "routine", { uuidOnly: true });+ if (routineIds.length > 0) {+ const rows = await db+ .select({+ id: routines.id,+ title: routines.title,+ status: routines.status,+ })+ .from(routines)+ .where(and(eq(routines.companyId, companyId), inArray(routines.id, routineIds)));+ for (const row of rows) {+ setTarget({+ type: "routine",+ id: row.id,+ label: row.title,+ href: `/routines/${row.id}`,+ status: row.status,+ });+ }+ }++ const issueIds = collectTargetIds(bindings, "issue", { uuidOnly: true });+ if (issueIds.length > 0) {+ const rows = await db+ .select({+ id: issues.id,+ identifier: issues.identifier,+ title: issues.title,+ status: issues.status,+ })+ .from(issues)+ .where(and(eq(issues.companyId, companyId), inArray(issues.id, issueIds)));+ for (const row of rows) {+ setTarget({+ type: "issue",+ id: row.id,+ label: row.identifier ? `${row.identifier} ${row.title}` : row.title,+ href: `/issues/${row.identifier ?? row.id}`,+ status: row.status,+ });+ }+ }++ const runIds = collectTargetIds(bindings, "run", { uuidOnly: true });+ if (runIds.length > 0) {+ const rows = await db+ .select({+ id: heartbeatRuns.id,+ agentId: heartbeatRuns.agentId,+ status: heartbeatRuns.status,+ })+ .from(heartbeatRuns)+ .where(and(eq(heartbeatRuns.companyId, companyId), inArray(heartbeatRuns.id, runIds)));+ for (const row of rows) {+ setTarget({+ type: "run",+ id: row.id,+ label: `Run ${row.id.slice(0, 8)}`,+ href: `/agents/${row.agentId}/runs/${row.id}`,+ status: row.status,+ });+ }+ }++ return targetMap;+ }++ async function buildRemoteImportConflictMaps(companyId: string, provider: SecretProvider) {+ const activeSecrets = await db+ .select({+ id: companySecrets.id,+ name: companySecrets.name,+ key: companySecrets.key,+ provider: companySecrets.provider,+ providerConfigId: companySecrets.providerConfigId,+ externalRef: companySecrets.externalRef,+ status: companySecrets.status,+ })+ .from(companySecrets)+ .where(and(eq(companySecrets.companyId, companyId), ne(companySecrets.status, "deleted")));+ return {+ byProviderConfigExternalRef: new Map(+ activeSecrets+ .filter((secret) =>+ secret.provider === provider &&+ typeof secret.externalRef === "string" &&+ secret.externalRef.trim()+ )+ .map((secret) => [+ remoteImportExternalRefKey(secret.providerConfigId, secret.externalRef!),+ secret,+ ]),+ ),+ byName: new Map(activeSecrets.map((secret) => [secret.name, secret])),+ byKey: new Map(activeSecrets.map((secret) => [secret.key, secret])),+ };+ }++ function remoteImportExternalRefKey(providerConfigId: string | null | undefined, externalRef: string) {+ return `${providerConfigId ?? "default"}\0${externalRef.trim()}`;+ }++ function sanitizeRemoteProviderMetadata(+ provider: SecretProvider,+ metadata: Record<string, unknown> | null | undefined,+ ): Record<string, unknown> | null {+ if (!metadata || provider !== "aws_secrets_manager") return null;+ const safe: Record<string, unknown> = {};+ for (const key of ["createdDate", "lastAccessedDate", "lastChangedDate", "deletedDate"]) {+ const value = metadata[key];+ if (typeof value === "string" || value === null) safe[key] = value;+ }+ for (const key of ["hasDescription", "hasKmsKey", "tagCount"]) {+ const value = metadata[key];+ if (typeof value === "boolean" || typeof value === "number") safe[key] = value;+ }+ return Object.keys(safe).length > 0 ? safe : null;+ }++ function remoteImportConflictsFor(input: {+ providerConfigId: string | null;+ externalRef: string;+ name: string;+ key: string;+ maps: Awaited<ReturnType<typeof buildRemoteImportConflictMaps>>;+ }): RemoteSecretImportConflict[] {+ const conflicts: RemoteSecretImportConflict[] = [];+ const duplicate = input.maps.byProviderConfigExternalRef.get(+ remoteImportExternalRefKey(input.providerConfigId, input.externalRef),+ );+ if (duplicate) {+ conflicts.push({+ type: "exact_reference",+ existingSecretId: duplicate.id,+ message: "An existing secret already links this exact provider reference.",+ });+ return conflicts;+ }+ const nameConflict = input.maps.byName.get(input.name);+ if (nameConflict) {+ conflicts.push({+ type: "name",+ existingSecretId: nameConflict.id,+ message: `Secret name already exists: ${input.name}`,+ });+ }+ const keyConflict = input.maps.byKey.get(input.key);+ if (keyConflict) {+ conflicts.push({+ type: "key",+ existingSecretId: keyConflict.id,+ message: `Secret key already exists: ${input.key}`,+ });+ }+ return conflicts;+ }++ async function getRemoteImportProviderConfig(companyId: string, providerConfigId: string) {+ const providerConfig = await getProviderConfigById(providerConfigId);+ if (!providerConfig) throw notFound("Provider vault not found");+ const provider = providerConfig.provider as SecretProvider;+ assertSelectableProviderConfig(providerConfig, companyId, provider);+ return { providerConfig, provider, runtimeConfig: toProviderVaultRuntimeConfig(providerConfig) };+ }+return {listProviders: () => listSecretProviders(),- list: (companyId: string) =>+ checkProviders: () => checkSecretProviders(),++ listProviderConfigs: (companyId: string) =>db.select()- .from(companySecrets)- .where(eq(companySecrets.companyId, companyId))- .orderBy(desc(companySecrets.createdAt)),+ .from(companySecretProviderConfigs)+ .where(eq(companySecretProviderConfigs.companyId, companyId))+ .orderBy(desc(companySecretProviderConfigs.createdAt)),++ getProviderConfigById,++ createProviderConfig: async (+ companyId: string,+ input: {+ provider: SecretProvider;+ displayName: string;+ status?: SecretProviderConfigStatus;+ isDefault?: boolean;+ config?: Record<string, unknown>;+ },+ actor?: { userId?: string | null; agentId?: string | null },+ ) => {+ const parsed = createSecretProviderConfigSchema.safeParse(input);+ if (!parsed.success) throw unprocessable("Invalid provider vault config", parsed.error.flatten());+ const status = input.status ?? defaultProviderConfigStatus(input.provider);+ if ((status === "coming_soon" || status === "disabled") && input.isDefault) {+ throw unprocessable("Only ready or warning provider vaults can be default");+ }+ const normalizedConfig = validateProviderConfigPayload(input.provider, input.config ?? {});+ return db.transaction(async (tx) => {+ if (input.isDefault) {+ await tx+ .update(companySecretProviderConfigs)+ .set({ isDefault: false, updatedAt: new Date() })+ .where(and(+ eq(companySecretProviderConfigs.companyId, companyId),+ eq(companySecretProviderConfigs.provider, input.provider),+ ));+ }+ return tx+ .insert(companySecretProviderConfigs)+ .values({+ companyId,+ provider: input.provider,+ displayName: input.displayName.trim(),+ status,+ isDefault: input.isDefault ?? false,+ config: normalizedConfig,+ disabledAt: status === "disabled" ? new Date() : null,+ createdByAgentId: actor?.agentId ?? null,+ createdByUserId: actor?.userId ?? null,+ })+ .returning()+ .then((rows) => rows[0]);+ });+ },++ updateProviderConfig: async (+ id: string,+ patch: {+ displayName?: string;+ status?: SecretProviderConfigStatus;+ isDefault?: boolean;+ config?: Record<string, unknown>;+ },+ ) => {+ const existing = await getProviderConfigById(id);+ if (!existing) return null;+ const parsed = updateSecretProviderConfigSchema.safeParse(patch);+ if (!parsed.success) throw unprocessable("Invalid provider vault config", parsed.error.flatten());+ const provider = existing.provider as SecretProvider;+ const status = patch.status ?? (existing.status as SecretProviderConfigStatus);+ if (COMING_SOON_SECRET_PROVIDERS.has(provider) && status !== "coming_soon" && status !== "disabled") {+ throw unprocessable(`${provider} provider vaults are locked while coming soon`);+ }+ if ((status === "coming_soon" || status === "disabled") && patch.isDefault) {+ throw unprocessable("Only ready or warning provider vaults can be default");+ }+ const normalizedConfig =+ patch.config === undefined+ ? existing.config+ : validateProviderConfigPayload(provider, patch.config);+ return db.transaction(async (tx) => {+ if (patch.isDefault) {+ await tx+ .update(companySecretProviderConfigs)+ .set({ isDefault: false, updatedAt: new Date() })+ .where(and(+ eq(companySecretProviderConfigs.companyId, existing.companyId),+ eq(companySecretProviderConfigs.provider, existing.provider),+ ));+ }+ return tx+ .update(companySecretProviderConfigs)+ .set({+ displayName: patch.displayName?.trim() ?? existing.displayName,+ status,+ isDefault: status === "disabled" || status === "coming_soon" ? false : patch.isDefault ?? existing.isDefault,+ config: normalizedConfig,+ disabledAt: status === "disabled" ? existing.disabledAt ?? new Date() : null,+ updatedAt: new Date(),+ })+ .where(eq(companySecretProviderConfigs.id, id))+ .returning()+ .then((rows) => rows[0] ?? null);+ });+ },++ disableProviderConfig: async (id: string) => {+ const existing = await getProviderConfigById(id);+ if (!existing) return null;+ return db+ .update(companySecretProviderConfigs)+ .set({+ status: "disabled",+ isDefault: false,+ disabledAt: existing.disabledAt ?? new Date(),+ updatedAt: new Date(),+ })+ .where(eq(companySecretProviderConfigs.id, id))+ .returning()+ .then((rows) => rows[0] ?? null);+ },++ setDefaultProviderConfig: async (id: string) => {+ const existing = await getProviderConfigById(id);+ if (!existing) return null;+ if (existing.status === "coming_soon" || existing.status === "disabled") {+ throw unprocessable("Only ready or warning provider vaults can be default");+ }+ return db.transaction(async (tx) => {+ const current = await tx+ .select()+ .from(companySecretProviderConfigs)+ .where(eq(companySecretProviderConfigs.id, id))+ .then((rows) => rows[0] ?? null);+ if (!current) return null;+ if (current.status === "coming_soon" || current.status === "disabled") {+ throw unprocessable("Only ready or warning provider vaults can be default");+ }+ await tx+ .update(companySecretProviderConfigs)+ .set({ isDefault: false, updatedAt: new Date() })+ .where(and(+ eq(companySecretProviderConfigs.companyId, current.companyId),+ eq(companySecretProviderConfigs.provider, current.provider),+ ));+ const updated = await tx+ .update(companySecretProviderConfigs)+ .set({ isDefault: true, updatedAt: new Date() })+ .where(and(+ eq(companySecretProviderConfigs.id, id),+ notInArray(companySecretProviderConfigs.status, ["coming_soon", "disabled"]),+ ))+ .returning()+ .then((rows) => rows[0] ?? null);+ if (!updated) throw unprocessable("Only ready or warning provider vaults can be default");+ return updated;+ });+ },++ checkProviderConfigHealth: async (id: string) => {+ const existing = await getProviderConfigById(id);+ if (!existing) return null;+ const checkedAt = new Date();+ const staticHealth = providerConfigHealth({+ id: existing.id,+ provider: existing.provider as SecretProvider,+ status: existing.status as SecretProviderConfigStatus,+ config: existing.config ?? {},+ });+ const provider = getSecretProvider(existing.provider as SecretProvider);+ const health = staticHealth ?? mapProviderModuleHealth({+ configId: existing.id,+ provider: existing.provider as SecretProvider,+ providerStatus: existing.status as SecretProviderConfigStatus,+ health: await provider.healthCheck({+ providerConfig: toProviderVaultRuntimeConfig(existing),+ }),+ });+ await db+ .update(companySecretProviderConfigs)+ .set({+ healthStatus: health.status,+ healthCheckedAt: checkedAt,+ healthMessage: health.message,+ healthDetails: health.details as unknown as Record<string, unknown>,+ updatedAt: new Date(),+ })+ .where(eq(companySecretProviderConfigs.id, id));+ return { ...health, checkedAt };+ },++ list: async (companyId: string) => {+ const [secrets, referenceCounts] = await Promise.all([+ db+ .select()+ .from(companySecrets)+ .where(and(eq(companySecrets.companyId, companyId), ne(companySecrets.status, "deleted")))+ .orderBy(desc(companySecrets.createdAt)),+ db+ .select({+ secretId: companySecretBindings.secretId,+ count: sql<number>`count(*)::int`,+ })+ .from(companySecretBindings)+ .where(eq(companySecretBindings.companyId, companyId))+ .groupBy(companySecretBindings.secretId),+ ]);+ const countsBySecretId = new Map(referenceCounts.map((row) => [row.secretId, row.count]));+ return secrets.map((secret) => ({+ ...secret,+ referenceCount: countsBySecretId.get(secret.id) ?? 0,+ }));+ },++ listBindings: (companyId: string, secretId?: string) =>+ db+ .select()+ .from(companySecretBindings)+ .where(+ secretId+ ? and(eq(companySecretBindings.companyId, companyId), eq(companySecretBindings.secretId, secretId))+ : eq(companySecretBindings.companyId, companyId),+ )+ .orderBy(desc(companySecretBindings.createdAt)),++ listBindingReferences: async (companyId: string, secretId: string) => {+ const bindings = await db+ .select()+ .from(companySecretBindings)+ .where(and(eq(companySecretBindings.companyId, companyId), eq(companySecretBindings.secretId, secretId)))+ .orderBy(desc(companySecretBindings.createdAt));+ const targetMap = await buildBindingTargetMap(companyId, bindings);+ return bindings.map((binding) => ({+ ...binding,+ target:+ targetMap.get(`${binding.targetType}:${binding.targetId}`) ??+ fallbackBindingTarget(binding),+ }));+ },++ listAccessEvents: (companyId: string, secretId: string) =>+ db+ .select()+ .from(secretAccessEvents)+ .where(and(eq(secretAccessEvents.companyId, companyId), eq(secretAccessEvents.secretId, secretId)))+ .orderBy(desc(secretAccessEvents.createdAt)),++ previewRemoteImport: async (+ companyId: string,+ input: {+ providerConfigId: string;+ query?: string | null;+ nextToken?: string | null;+ pageSize?: number;+ },+ ) => {+ const { providerConfig, provider: providerId, runtimeConfig } = await getRemoteImportProviderConfig(+ companyId,+ input.providerConfigId,+ );+ const provider = getSecretProvider(providerId);+ if (!provider.listRemoteSecrets) {+ throw unprocessable(`${providerId} provider does not support remote import listing`);+ }+ let listed: RemoteSecretListResult;+ try {+ listed = await provider.listRemoteSecrets({+ providerConfig: runtimeConfig,+ query: input.query,+ nextToken: input.nextToken,+ pageSize: input.pageSize,+ });+ } catch (error) {+ throw remoteProviderHttpError(error, {+ companyId,+ provider: providerId,+ providerConfigId: providerConfig.id,+ operation: "remote_import.preview",+ });+ }+ const maps = await buildRemoteImportConflictMaps(companyId, providerId);+ const candidates: RemoteSecretImportCandidate[] = [];+ for (const remote of listed.secrets) {+ const externalRef = remote.externalRef.trim();+ const remoteName = remote.name.trim() || deriveSecretNameFromExternalRef(externalRef);+ const name = remoteName || deriveSecretNameFromExternalRef(externalRef);+ const key = normalizeSecretKey(name);+ let canonicalExternalRef = externalRef;+ const conflicts: RemoteSecretImportConflict[] = [];+ try {+ const prepared = await provider.linkExternalSecret({+ externalRef,+ providerVersionRef: remote.providerVersionRef ?? null,+ providerConfig: runtimeConfig,+ context: {+ companyId,+ secretKey: key || "remote-import-preview",+ secretName: name,+ version: 1,+ },+ });+ canonicalExternalRef = prepared.externalRef ?? externalRef;+ } catch (error) {+ conflicts.push({+ type: "provider_guardrail",+ message: remoteImportRowFailureReason(error, "Provider rejected this external reference", {+ companyId,+ provider: providerId,+ providerConfigId: providerConfig.id,+ operation: "remote_import.preview.link_external_reference",+ }),+ });+ }+ conflicts.push(...remoteImportConflictsFor({+ providerConfigId: providerConfig.id,+ externalRef: canonicalExternalRef,+ name,+ key,+ maps,+ }));+ const hasDuplicate = conflicts.some((conflict) => conflict.type === "exact_reference");+ const hasConflict = conflicts.length > 0;+ candidates.push({+ externalRef,+ remoteName,+ name,+ key,+ providerVersionRef: remote.providerVersionRef ?? null,+ providerMetadata: sanitizeRemoteProviderMetadata(providerId, remote.metadata),+ status: hasDuplicate ? "duplicate" : hasConflict ? "conflict" : "ready",+ importable: !hasConflict,+ conflicts,+ });+ }+ return {+ providerConfigId: providerConfig.id,+ provider: providerId,+ nextToken: listed.nextToken ?? null,+ candidates,+ };+ },++ importRemoteSecrets: async (+ companyId: string,+ input: {+ providerConfigId: string;+ secrets: Array<{+ externalRef: string;+ name?: string | null;+ key?: string | null;+ description?: string | null;+ providerVersionRef?: string | null;+ providerMetadata?: Record<string, unknown> | null;+ }>;+ },+ actor?: { userId?: string | null; agentId?: string | null },+ ) => {+ const { providerConfig, provider: providerId, runtimeConfig } = await getRemoteImportProviderConfig(+ companyId,+ input.providerConfigId,+ );+ const provider = getSecretProvider(providerId);+ if (provider.descriptor().supportsExternalReferences === false) {+ throw unprocessable(`${providerId} provider does not support linked external references`);+ }+ const maps = await buildRemoteImportConflictMaps(companyId, providerId);+ const results: RemoteSecretImportRowResult[] = [];++ for (const selection of input.secrets) {+ const externalRef = selection.externalRef.trim();+ const name = selection.name?.trim() || deriveSecretNameFromExternalRef(externalRef);+ const key = normalizeSecretKey(selection.key?.trim() || name);+ const description = selection.description?.trim() || null;+ let prepared: PreparedSecretVersion | undefined;+ const conflicts = remoteImportConflictsFor({+ providerConfigId: providerConfig.id,+ externalRef,+ name,+ key,+ maps,+ });+ if (!key) {+ results.push({+ externalRef,+ name,+ key,+ status: "error",+ reason: "Secret key is required",+ secretId: null,+ conflicts,+ });+ continue;+ }+ if (conflicts.length === 0) {+ try {+ prepared = await provider.linkExternalSecret({+ externalRef,+ providerVersionRef: selection.providerVersionRef ?? null,+ providerConfig: runtimeConfig,+ context: {+ companyId,+ secretKey: key,+ secretName: name,+ version: 1,+ },+ });+ const canonicalDuplicate = maps.byProviderConfigExternalRef.get(+ remoteImportExternalRefKey(providerConfig.id, prepared.externalRef ?? externalRef),+ );+ if (canonicalDuplicate) {+ conflicts.push({+ type: "exact_reference",+ existingSecretId: canonicalDuplicate.id,+ message: "An existing secret already links this exact provider reference.",+ });+ }+ } catch (error) {+ results.push({+ externalRef,+ name,+ key,+ status: "error",+ reason: remoteImportRowFailureReason(error, "Provider rejected this external reference", {+ companyId,+ provider: providerId,+ providerConfigId: providerConfig.id,+ operation: "remote_import.prepare_external_reference",+ }),+ secretId: null,+ conflicts: [],+ });+ continue;+ }+ }+ if (conflicts.length > 0) {+ results.push({+ externalRef,+ name,+ key,+ status: "skipped",+ reason: conflicts.some((conflict) => conflict.type === "exact_reference")+ ? "exact_reference_duplicate"+ : "name_or_key_conflict",+ secretId: null,+ conflicts,+ });+ continue;+ }++ try {+ if (!prepared) {+ prepared = await provider.linkExternalSecret({+ externalRef,+ providerVersionRef: selection.providerVersionRef ?? null,+ providerConfig: runtimeConfig,+ context: {+ companyId,+ secretKey: key,+ secretName: name,+ version: 1,+ },+ });+ }+ if (!prepared) {+ throw unprocessable("Provider rejected this external reference");+ }+ const preparedSecret = prepared;+ const secret = await db.transaction(async (tx) => {+ const inserted = await tx+ .insert(companySecrets)+ .values({+ companyId,+ key,+ name,+ provider: providerId,+ providerConfigId: providerConfig.id,+ status: "active",+ managedMode: "external_reference",+ externalRef: preparedSecret.externalRef,+ providerMetadata: null,+ latestVersion: 1,+ description,+ lastRotatedAt: new Date(),+ createdByAgentId: actor?.agentId ?? null,+ createdByUserId: actor?.userId ?? null,+ })+ .returning()+ .then((rows) => rows[0]);+ await tx.insert(companySecretVersions).values({+ secretId: inserted.id,+ version: 1,+ material: preparedSecret.material,+ valueSha256: preparedSecret.valueSha256,+ fingerprintSha256: preparedSecret.fingerprintSha256 ?? preparedSecret.valueSha256,+ providerVersionRef: preparedSecret.providerVersionRef ?? null,+ status: "current",+ createdByAgentId: actor?.agentId ?? null,+ createdByUserId: actor?.userId ?? null,+ });+ return inserted;+ });+ maps.byProviderConfigExternalRef.set(+ remoteImportExternalRefKey(providerConfig.id, preparedSecret.externalRef ?? externalRef),+ secret,+ );+ maps.byName.set(name, secret);+ maps.byKey.set(key, secret);+ results.push({+ externalRef,+ name,+ key,+ status: "imported",+ reason: null,+ secretId: secret.id,+ conflicts: [],+ });+ } catch (error) {+ results.push({+ externalRef,+ name,+ key,+ status: "error",+ reason: remoteImportRowFailureReason(error, "Import failed", {+ companyId,+ provider: providerId,+ providerConfigId: providerConfig.id,+ operation: "remote_import.commit",+ }),+ secretId: null,+ conflicts: [],+ });+ }+ }++ return {+ providerConfigId: providerConfig.id,+ provider: providerId,+ importedCount: results.filter((result) => result.status === "imported").length,+ skippedCount: results.filter((result) => result.status === "skipped").length,+ errorCount: results.filter((result) => result.status === "error").length,+ results,+ };+ },getById,getByName,@@ -171,96 +1455,331 @@ export function secretService(db: Db) {input: {name: string;provider: SecretProvider;- value: string;+ providerConfigId?: string | null;+ value?: string | null;+ key?: string | null;+ managedMode?: "paperclip_managed" | "external_reference";description?: string | null;externalRef?: string | null;+ providerVersionRef?: string | null;+ providerMetadata?: Record<string, unknown> | null;},actor?: { userId?: string | null; agentId?: string | null },) => {const existing = await getByName(companyId, input.name);if (existing) throw conflict(`Secret already exists: ${input.name}`);+ const key = normalizeSecretKey(input.key ?? input.name);+ if (!key) throw unprocessable("Secret key is required");+ const duplicateKey = await db+ .select()+ .from(companySecrets)+ .where(and(+ eq(companySecrets.companyId, companyId),+ eq(companySecrets.key, key),+ ne(companySecrets.status, "deleted"),+ ))+ .then((rows) => rows[0] ?? null);+ if (duplicateKey) throw conflict(`Secret key already exists: ${key}`);+ const managedMode = input.managedMode ?? "paperclip_managed";const provider = getSecretProvider(input.provider);- const prepared = await provider.createVersion({- value: input.value,- externalRef: input.externalRef ?? null,+ const providerConfig = await getSelectableRuntimeProviderConfig({+ companyId,+ provider: input.provider,+ providerConfigId: input.providerConfigId,});+ if (managedMode === "external_reference" && !input.externalRef?.trim()) {+ throw unprocessable("External reference secrets require externalRef");+ }+ if (managedMode === "paperclip_managed" && input.externalRef?.trim()) {+ throw unprocessable("Managed secrets cannot override externalRef");+ }+ if (managedMode === "paperclip_managed" && !input.value?.trim()) {+ throw unprocessable("Managed secrets require value");+ }+ const providerWriteContext = {+ companyId,+ secretKey: key,+ secretName: input.name,+ version: 1,+ };+ const reservedSecret = await db+ .insert(companySecrets)+ .values({+ companyId,+ key,+ name: input.name,+ provider: input.provider,+ providerConfigId: input.providerConfigId ?? null,+ status: "archived",+ managedMode,+ externalRef: null,+ providerMetadata: input.providerMetadata ?? null,+ latestVersion: 0,+ description: input.description ?? null,+ createdByAgentId: actor?.agentId ?? null,+ createdByUserId: actor?.userId ?? null,+ })+ .returning()+ .then((rows) => rows[0]);- return db.transaction(async (tx) => {- const secret = await tx- .insert(companySecrets)- .values({- companyId,- name: input.name,- provider: input.provider,+ let prepared: PreparedSecretVersion;+ try {+ prepared =+ managedMode === "external_reference"+ ? await provider.linkExternalSecret({+ externalRef: input.externalRef ?? "",+ providerVersionRef: input.providerVersionRef ?? null,+ providerConfig,+ context: providerWriteContext,+ })+ : await provider.createSecret({+ value: input.value ?? "",+ externalRef: null,+ providerConfig,+ context: providerWriteContext,+ });+ } catch (error) {+ await db.delete(companySecrets).where(eq(companySecrets.id, reservedSecret.id)).catch(() => undefined);+ throw error;+ }++ try {+ await db+ .update(companySecrets)+ .set({externalRef: prepared.externalRef,latestVersion: 1,- description: input.description ?? null,- createdByAgentId: actor?.agentId ?? null,- createdByUserId: actor?.userId ?? null,+ updatedAt: new Date(),})- .returning()- .then((rows) => rows[0]);-- await tx.insert(companySecretVersions).values({- secretId: secret.id,+ .where(eq(companySecrets.id, reservedSecret.id));+ await db.insert(companySecretVersions).values({+ secretId: reservedSecret.id,version: 1,material: prepared.material,valueSha256: prepared.valueSha256,+ fingerprintSha256: prepared.fingerprintSha256 ?? prepared.valueSha256,+ providerVersionRef: prepared.providerVersionRef ?? null,+ status: "disabled",createdByAgentId: actor?.agentId ?? null,createdByUserId: actor?.userId ?? null,});+ } catch (error) {+ if (managedMode === "paperclip_managed") {+ const cleaned = await cleanupPreparedProviderWrite({+ provider,+ prepared,+ providerConfig,+ context: providerWriteContext,+ mode: "delete",+ operation: "create.prepare_rollback",+ });+ if (cleaned) {+ await db.delete(companySecrets).where(eq(companySecrets.id, reservedSecret.id)).catch(() => undefined);+ }+ } else {+ await db.delete(companySecrets).where(eq(companySecrets.id, reservedSecret.id)).catch(() => undefined);+ }+ throw error;+ }- return secret;- });+ try {+ return await db.transaction(async (tx) => {+ await tx+ .update(companySecretVersions)+ .set({ status: "current" })+ .where(and(+ eq(companySecretVersions.secretId, reservedSecret.id),+ eq(companySecretVersions.version, 1),+ ));++ const secret = await tx+ .update(companySecrets)+ .set({+ status: "active",+ externalRef: prepared.externalRef,+ latestVersion: 1,+ lastRotatedAt: new Date(),+ updatedAt: new Date(),+ })+ .where(eq(companySecrets.id, reservedSecret.id))+ .returning()+ .then((rows) => rows[0]);++ if (!secret) throw notFound("Secret not found");+ return secret;+ });+ } catch (error) {+ if (managedMode === "paperclip_managed") {+ const cleaned = await cleanupPreparedProviderWrite({+ provider,+ prepared,+ providerConfig,+ context: providerWriteContext,+ mode: "delete",+ operation: "create.rollback",+ });+ if (cleaned) {+ await db.delete(companySecrets).where(eq(companySecrets.id, reservedSecret.id)).catch(() => undefined);+ }+ } else {+ await db.delete(companySecrets).where(eq(companySecrets.id, reservedSecret.id)).catch(() => undefined);+ }+ throw error;+ }},rotate: async (secretId: string,- input: { value: string; externalRef?: string | null },+ input: {+ value?: string | null;+ externalRef?: string | null;+ providerVersionRef?: string | null;+ providerConfigId?: string | null;+ },actor?: { userId?: string | null; agentId?: string | null },) => {const secret = await getById(secretId);if (!secret) throw notFound("Secret not found");- const provider = getSecretProvider(secret.provider as SecretProvider);- const nextVersion = secret.latestVersion + 1;- const prepared = await provider.createVersion({- value: input.value,- externalRef: input.externalRef ?? secret.externalRef ?? null,+ if (secret.status !== "active") throw unprocessable("Cannot rotate a non-active secret");+ const providerId = secret.provider as SecretProvider;+ const provider = getSecretProvider(providerId);+ const providerConfigId =+ input.providerConfigId === undefined ? secret.providerConfigId : input.providerConfigId;+ const providerConfig = await getSelectableRuntimeProviderConfig({+ companyId: secret.companyId,+ provider: providerId,+ providerConfigId,});+ const nextVersion = secret.latestVersion + 1;+ if (secret.managedMode === "external_reference" && !(input.externalRef ?? secret.externalRef)?.trim()) {+ throw unprocessable("External reference secrets require externalRef");+ }+ if (secret.managedMode !== "external_reference" && input.externalRef?.trim()) {+ throw unprocessable("Managed secrets cannot override externalRef");+ }+ if (secret.managedMode !== "external_reference" && !input.value?.trim()) {+ throw unprocessable("Managed secrets require value");+ }+ const providerWriteContext = {+ companyId: secret.companyId,+ secretKey: secret.key,+ secretName: secret.name,+ version: nextVersion,+ };+ const prepared =+ secret.managedMode === "external_reference"+ ? await provider.linkExternalSecret({+ externalRef: input.externalRef ?? secret.externalRef ?? "",+ providerVersionRef: input.providerVersionRef ?? null,+ providerConfig,+ context: providerWriteContext,+ })+ : await provider.createVersion({+ value: input.value ?? "",+ externalRef: secret.externalRef ?? null,+ providerConfig,+ context: providerWriteContext,+ });- return db.transaction(async (tx) => {- await tx.insert(companySecretVersions).values({+ try {+ await db.insert(companySecretVersions).values({secretId: secret.id,version: nextVersion,material: prepared.material,valueSha256: prepared.valueSha256,+ fingerprintSha256: prepared.fingerprintSha256 ?? prepared.valueSha256,+ providerVersionRef: prepared.providerVersionRef ?? null,+ status: "disabled",createdByAgentId: actor?.agentId ?? null,createdByUserId: actor?.userId ?? null,});+ } catch (error) {+ if (secret.managedMode !== "external_reference") {+ await cleanupPreparedProviderWrite({+ provider,+ prepared,+ providerConfig,+ context: providerWriteContext,+ mode: "archive",+ operation: "rotate.prepare_rollback",+ });+ }+ throw error;+ }- const updated = await tx- .update(companySecrets)- .set({- latestVersion: nextVersion,- externalRef: prepared.externalRef,- updatedAt: new Date(),- })- .where(eq(companySecrets.id, secret.id))- .returning()- .then((rows) => rows[0] ?? null);+ try {+ return await db.transaction(async (tx) => {+ await tx+ .update(companySecretVersions)+ .set({ status: "previous" })+ .where(and(+ eq(companySecretVersions.secretId, secret.id),+ ne(companySecretVersions.version, nextVersion),+ ));+ await tx+ .update(companySecretVersions)+ .set({ status: "current" })+ .where(and(+ eq(companySecretVersions.secretId, secret.id),+ eq(companySecretVersions.version, nextVersion),+ ));- if (!updated) throw notFound("Secret not found");- return updated;- });+ const updated = await tx+ .update(companySecrets)+ .set({+ latestVersion: nextVersion,+ externalRef: prepared.externalRef,+ providerConfigId,+ lastRotatedAt: new Date(),+ updatedAt: new Date(),+ })+ .where(eq(companySecrets.id, secret.id))+ .returning()+ .then((rows) => rows[0] ?? null);++ if (!updated) throw notFound("Secret not found");+ return updated;+ });+ } catch (error) {+ if (secret.managedMode !== "external_reference") {+ const cleaned = await cleanupPreparedProviderWrite({+ provider,+ prepared,+ providerConfig,+ context: providerWriteContext,+ mode: "archive",+ operation: "rotate.rollback",+ });+ if (cleaned) {+ await db+ .delete(companySecretVersions)+ .where(and(+ eq(companySecretVersions.secretId, secret.id),+ eq(companySecretVersions.version, nextVersion),+ ))+ .catch(() => undefined);+ }+ }+ throw error;+ }},update: async (secretId: string,- patch: { name?: string; description?: string | null; externalRef?: string | null },+ patch: {+ name?: string;+ key?: string;+ status?: "active" | "disabled" | "archived" | "deleted";+ providerConfigId?: string | null;+ description?: string | null;+ externalRef?: string | null;+ providerMetadata?: Record<string, unknown> | null;+ },) => {const secret = await getById(secretId);if (!secret) throw notFound("Secret not found");+ if (secret.status === "deleted") throw notFound("Secret not found");if (patch.name && patch.name !== secret.name) {const duplicate = await getByName(secret.companyId, patch.name);@@ -268,15 +1787,79 @@ export function secretService(db: Db) {throw conflict(`Secret already exists: ${patch.name}`);}}+ const nextKey = patch.key ? normalizeSecretKey(patch.key) : secret.key;+ if (!nextKey) throw unprocessable("Secret key is required");+ if (nextKey !== secret.key) {+ const duplicateKey = await db+ .select()+ .from(companySecrets)+ .where(and(+ eq(companySecrets.companyId, secret.companyId),+ eq(companySecrets.key, nextKey),+ ne(companySecrets.status, "deleted"),+ ))+ .then((rows) => rows[0] ?? null);+ if (duplicateKey && duplicateKey.id !== secret.id) {+ throw conflict(`Secret key already exists: ${nextKey}`);+ }+ }+ const deleting = patch.status === "deleted";+ if (deleting && secret.managedMode === "paperclip_managed") {+ throw unprocessable("Managed secrets must be deleted through DELETE /secrets/:id");+ }+ if (secret.managedMode !== "external_reference" && patch.externalRef !== undefined) {+ throw unprocessable("Managed secrets cannot override externalRef");+ }+ if (+ secret.managedMode === "external_reference" &&+ patch.externalRef !== undefined &&+ patch.externalRef !== secret.externalRef+ ) {+ throw unprocessable(+ "External reference secrets cannot be retargeted through generic update",+ );+ }+ if (+ secret.managedMode === "external_reference" &&+ patch.providerConfigId !== undefined &&+ patch.providerConfigId !== secret.providerConfigId+ ) {+ throw unprocessable(+ "External reference secrets cannot change provider vault through generic update",+ );+ }+ if (+ secret.managedMode === "paperclip_managed" &&+ patch.providerConfigId !== undefined &&+ patch.providerConfigId !== secret.providerConfigId+ ) {+ throw unprocessable(+ "Managed secrets cannot change provider vault through PATCH; use rotate() to migrate to a new vault",+ );+ }+ if (patch.providerConfigId !== undefined) {+ await assertProviderConfigForSecret(+ secret.companyId,+ secret.provider as SecretProvider,+ patch.providerConfigId,+ );+ }return db.update(companySecrets).set({- name: patch.name ?? secret.name,+ key: deleting ? `${secret.key}__deleted__${secret.id}` : nextKey,+ name: deleting ? `${secret.name}__deleted__${secret.id}` : patch.name ?? secret.name,+ status: patch.status ?? secret.status,+ providerConfigId:+ patch.providerConfigId === undefined ? secret.providerConfigId : patch.providerConfigId,description:patch.description === undefined ? secret.description : patch.description,externalRef:patch.externalRef === undefined ? secret.externalRef : patch.externalRef,+ providerMetadata:+ patch.providerMetadata === undefined ? secret.providerMetadata : patch.providerMetadata,+ deletedAt: deleting ? new Date() : secret.deletedAt,updatedAt: new Date(),}).where(eq(companySecrets.id, secret.id))@@ -284,9 +1867,216 @@ export function secretService(db: Db) {.then((rows) => rows[0] ?? null);},+ createBinding: async (input: {+ companyId: string;+ secretId: string;+ targetType: SecretBindingTargetType;+ targetId: string;+ configPath: string;+ versionSelector?: SecretVersionSelector;+ required?: boolean;+ label?: string | null;+ }) => {+ await assertSecretInCompany(input.companyId, input.secretId);+ const existing = await db+ .select()+ .from(companySecretBindings)+ .where(+ and(+ eq(companySecretBindings.companyId, input.companyId),+ eq(companySecretBindings.targetType, input.targetType),+ eq(companySecretBindings.targetId, input.targetId),+ eq(companySecretBindings.configPath, input.configPath),+ ),+ )+ .then((rows) => rows[0] ?? null);+ if (existing) throw conflict(`Secret binding already exists at ${input.configPath}`);+ return db+ .insert(companySecretBindings)+ .values({+ companyId: input.companyId,+ secretId: input.secretId,+ targetType: input.targetType,+ targetId: input.targetId,+ configPath: input.configPath,+ versionSelector: String(input.versionSelector ?? "latest"),+ required: input.required ?? true,+ label: input.label ?? null,+ })+ .returning()+ .then((rows) => rows[0]);+ },++ syncSecretRefsForTarget: async (+ companyId: string,+ target: { targetType: SecretBindingTargetType; targetId: string },+ refs: Array<{+ secretId: string;+ configPath: string;+ versionSelector?: SecretVersionSelector;+ required?: boolean;+ label?: string | null;+ }>,+ ) => {+ const normalizedRefs: Array<{+ secretId: string;+ configPath: string;+ versionSelector: SecretVersionSelector;+ required: boolean;+ label: string | null;+ }> = [];+ for (const ref of refs) {+ await assertSecretInCompany(companyId, ref.secretId);+ normalizedRefs.push({+ secretId: ref.secretId,+ configPath: ref.configPath,+ versionSelector: ref.versionSelector ?? "latest",+ required: ref.required ?? true,+ label: ref.label ?? null,+ });+ }++ const pathPrefixes = [...new Set(normalizedRefs.map((ref) => ref.configPath.split(".")[0]))];++ await db.transaction(async (tx) => {+ if (pathPrefixes.length > 0) {+ for (const pathPrefix of pathPrefixes) {+ await tx+ .delete(companySecretBindings)+ .where(+ and(+ eq(companySecretBindings.companyId, companyId),+ eq(companySecretBindings.targetType, target.targetType),+ eq(companySecretBindings.targetId, target.targetId),+ like(companySecretBindings.configPath, `${pathPrefix}.%`),+ ),+ );+ }+ } else {+ await tx+ .delete(companySecretBindings)+ .where(+ and(+ eq(companySecretBindings.companyId, companyId),+ eq(companySecretBindings.targetType, target.targetType),+ eq(companySecretBindings.targetId, target.targetId),+ ),+ );+ }+ if (normalizedRefs.length === 0) return;+ await tx.insert(companySecretBindings).values(+ normalizedRefs.map((ref) => ({+ companyId,+ secretId: ref.secretId,+ targetType: target.targetType,+ targetId: target.targetId,+ configPath: ref.configPath,+ versionSelector: String(ref.versionSelector),+ required: ref.required,+ label: ref.label,+ })),+ );+ });+ return normalizedRefs;+ },++ syncEnvBindingsForTarget: async (+ companyId: string,+ target: { targetType: SecretBindingTargetType; targetId: string; pathPrefix?: string },+ envValue: unknown,+ ) => {+ const record = asRecord(envValue) ?? {};+ const refs: Array<{+ secretId: string;+ configPath: string;+ versionSelector: SecretVersionSelector;+ }> = [];+ const pathPrefix = target.pathPrefix ?? "env";+ for (const [key, rawBinding] of Object.entries(record)) {+ const parsed = envBindingSchema.safeParse(rawBinding);+ if (!parsed.success) continue;+ const binding = canonicalizeBinding(parsed.data as EnvBinding);+ if (binding.type !== "secret_ref") continue;+ await assertSecretInCompany(companyId, binding.secretId);+ refs.push({+ secretId: binding.secretId,+ configPath: `${pathPrefix}.${key}`,+ versionSelector: binding.version,+ });+ }++ await db.transaction(async (tx) => {+ await tx+ .delete(companySecretBindings)+ .where(+ and(+ eq(companySecretBindings.companyId, companyId),+ eq(companySecretBindings.targetType, target.targetType),+ eq(companySecretBindings.targetId, target.targetId),+ like(companySecretBindings.configPath, `${pathPrefix}.%`),+ ),+ );+ if (refs.length === 0) return;+ await tx.insert(companySecretBindings).values(+ refs.map((ref) => ({+ companyId,+ secretId: ref.secretId,+ targetType: target.targetType,+ targetId: target.targetId,+ configPath: ref.configPath,+ versionSelector: String(ref.versionSelector),+ required: true,+ })),+ );+ });+ return refs;+ },+remove: async (secretId: string) => {const secret = await getById(secretId);if (!secret) return null;+ const versionRow = await getSecretVersion(secret.id, secret.latestVersion);+ const providerId = secret.provider as SecretProvider;+ const provider = getSecretProvider(providerId);+ if (secret.status !== "deleted") {+ await db+ .update(companySecrets)+ .set({+ key: `${secret.key}__deleted__${secret.id}`,+ name: `${secret.name}__deleted__${secret.id}`,+ status: "deleted",+ deletedAt: secret.deletedAt ?? new Date(),+ updatedAt: new Date(),+ })+ .where(eq(companySecrets.id, secretId));+ }+ const providerConfig = secret.providerConfigId+ ? await getProviderConfigById(secret.providerConfigId)+ : null;+ const providerRuntimeConfig =+ providerConfig && providerConfig.status !== "disabled" && providerConfig.status !== "coming_soon"+ ? toProviderVaultRuntimeConfig(providerConfig)+ : null;+ if (!secret.providerConfigId || providerRuntimeConfig) {+ try {+ await provider.deleteOrArchive({+ material: versionRow?.material as Record<string, unknown> | undefined,+ externalRef: secret.externalRef,+ providerConfig: providerRuntimeConfig,+ context: {+ companyId: secret.companyId,+ secretKey: secret.key,+ secretName: secret.name,+ version: secret.latestVersion,+ },+ mode: "delete",+ });+ } catch (error) {+ if (!isSecretProviderClientError(error) || error.code !== "not_found") {+ throw error;+ }+ }+ }await db.delete(companySecrets).where(eq(companySecrets.id, secretId));return secret;},@@ -320,11 +2110,16 @@ export function secretService(db: Db) {return normalized;},- resolveEnvBindings: async (companyId: string, envValue: unknown): Promise<{ env: Record<string, string>; secretKeys: Set<string> }> => {+ resolveEnvBindings: async (+ companyId: string,+ envValue: unknown,+ context?: Omit<SecretConsumerContext, "configPath">,+ ): Promise<{ env: Record<string, string>; secretKeys: Set<string>; manifest: RuntimeSecretManifestEntry[] }> => {const record = asRecord(envValue);- if (!record) return { env: {} as Record<string, string>, secretKeys: new Set<string>() };+ if (!record) return { env: {} as Record<string, string>, secretKeys: new Set<string>(), manifest: [] };const resolved: Record<string, string> = {};const secretKeys = new Set<string>();+ const manifest: RuntimeSecretManifestEntry[] = [];for (const [key, rawBinding] of Object.entries(record)) {if (!ENV_KEY_RE.test(key)) {@@ -338,23 +2133,35 @@ export function secretService(db: Db) {if (binding.type === "plain") {resolved[key] = binding.value;} else {- resolved[key] = await resolveSecretValue(companyId, binding.secretId, binding.version);+ const secretResolution = await resolveSecretValueInternal(+ companyId,+ binding.secretId,+ binding.version,+ context ? { ...context, configPath: `env.${key}` } : undefined,+ );+ resolved[key] = secretResolution.value;+ manifest.push(secretResolution.manifestEntry);secretKeys.add(key);}}- return { env: resolved, secretKeys };+ return { env: resolved, secretKeys, manifest };},- resolveAdapterConfigForRuntime: async (companyId: string, adapterConfig: Record<string, unknown>): Promise<{ config: Record<string, unknown>; secretKeys: Set<string> }> => {+ resolveAdapterConfigForRuntime: async (+ companyId: string,+ adapterConfig: Record<string, unknown>,+ context?: Omit<SecretConsumerContext, "configPath">,+ ): Promise<{ config: Record<string, unknown>; secretKeys: Set<string>; manifest: RuntimeSecretManifestEntry[] }> => {const resolved = { ...adapterConfig };const secretKeys = new Set<string>();+ const manifest: RuntimeSecretManifestEntry[] = [];if (!Object.prototype.hasOwnProperty.call(adapterConfig, "env")) {- return { config: resolved, secretKeys };+ return { config: resolved, secretKeys, manifest };}const record = asRecord(adapterConfig.env);if (!record) {resolved.env = {};- return { config: resolved, secretKeys };+ return { config: resolved, secretKeys, manifest };}const env: Record<string, string> = {};for (const [key, rawBinding] of Object.entries(record)) {@@ -369,12 +2176,19 @@ export function secretService(db: Db) {if (binding.type === "plain") {env[key] = binding.value;} else {- env[key] = await resolveSecretValue(companyId, binding.secretId, binding.version);+ const secretResolution = await resolveSecretValueInternal(+ companyId,+ binding.secretId,+ binding.version,+ context ? { ...context, configPath: `env.${key}` } : undefined,+ );+ env[key] = secretResolution.value;+ manifest.push(secretResolution.manifestEntry);secretKeys.add(key);}}resolved.env = env;- return { config: resolved, secretKeys };+ return { config: resolved, secretKeys, manifest };},};}diff --git a/ui/src/App.tsx b/ui/src/App.tsxindex 2a19c81667..6e86c76dc1 100644--- a/ui/src/App.tsx+++ b/ui/src/App.tsx@@ -32,6 +32,7 @@ import { CompanyEnvironments } from "./pages/CompanyEnvironments";import { CompanyAccess } from "./pages/CompanyAccess";import { CompanyInvites } from "./pages/CompanyInvites";import { CompanySkills } from "./pages/CompanySkills";+import { Secrets } from "./pages/Secrets";import { CompanyExport } from "./pages/CompanyExport";import { CompanyImport } from "./pages/CompanyImport";import { DesignGuide } from "./pages/DesignGuide";@@ -71,6 +72,7 @@ function boardRoutes() {<Route path="company/settings/invites" element={<CompanyInvites />} /><Route path="company/export/*" element={<CompanyExport />} /><Route path="company/import" element={<CompanyImport />} />+ <Route path="company/settings/secrets" element={<Secrets />} /><Route path="skills/*" element={<CompanySkills />} /><Route path="settings" element={<LegacySettingsRedirect />} /><Route path="settings/*" element={<LegacySettingsRedirect />} />diff --git a/ui/src/api/secrets.ts b/ui/src/api/secrets.tsindex b39aa5605d..aedfa85dc0 100644--- a/ui/src/api/secrets.ts+++ b/ui/src/api/secrets.ts@@ -1,25 +1,138 @@-import type { CompanySecret, SecretProviderDescriptor, SecretProvider } from "@paperclipai/shared";+import type {+ CompanySecret,+ CompanySecretUsageBinding,+ CompanySecretProviderConfig,+ RemoteSecretImportPreviewResult,+ RemoteSecretImportResult,+ SecretAccessEvent,+ SecretManagedMode,+ SecretProvider,+ SecretProviderConfigStatus,+ SecretProviderConfigHealthResponse,+ SecretProviderDescriptor,+ SecretStatus,+} from "@paperclipai/shared";import { api } from "./client";+export interface SecretUsageResponse {+ secretId: string;+ bindings: CompanySecretUsageBinding[];+}++export interface CreateSecretInput {+ name: string;+ key?: string;+ provider?: SecretProvider;+ managedMode?: SecretManagedMode;+ value?: string | null;+ description?: string | null;+ externalRef?: string | null;+ providerVersionRef?: string | null;+ providerConfigId?: string | null;+ providerMetadata?: Record<string, unknown> | null;+}++export interface SecretProviderHealthResponse {+ providers: Array<{+ provider: SecretProvider;+ status: "ok" | "warn" | "error";+ message: string;+ warnings?: string[];+ backupGuidance?: string[];+ details?: Record<string, unknown>;+ }>;+}++export interface UpdateSecretInput {+ name?: string;+ key?: string;+ status?: SecretStatus;+ description?: string | null;+ externalRef?: string | null;+ providerMetadata?: Record<string, unknown> | null;+}++export interface RotateSecretInput {+ value?: string | null;+ externalRef?: string | null;+ providerVersionRef?: string | null;+ providerConfigId?: string | null;+}++export interface CreateSecretProviderConfigInput {+ provider: SecretProvider;+ displayName: string;+ status?: SecretProviderConfigStatus;+ isDefault?: boolean;+ config?: Record<string, unknown>;+}++export interface UpdateSecretProviderConfigInput {+ displayName?: string;+ status?: SecretProviderConfigStatus;+ isDefault?: boolean;+ config?: Record<string, unknown>;+}++export interface RemoteImportPreviewInput {+ providerConfigId: string;+ query?: string | null;+ nextToken?: string | null;+ pageSize?: number;+}++export interface RemoteImportSelectionInput {+ externalRef: string;+ name?: string | null;+ key?: string | null;+ description?: string | null;+ providerVersionRef?: string | null;+ providerMetadata?: Record<string, unknown> | null;+}++export interface RemoteImportInput {+ providerConfigId: string;+ secrets: RemoteImportSelectionInput[];+}+export const secretsApi = {list: (companyId: string) => api.get<CompanySecret[]>(`/companies/${companyId}/secrets`),providers: (companyId: string) =>api.get<SecretProviderDescriptor[]>(`/companies/${companyId}/secret-providers`),- create: (- companyId: string,- data: {- name: string;- value: string;- provider?: SecretProvider;- description?: string | null;- externalRef?: string | null;- },- ) => api.post<CompanySecret>(`/companies/${companyId}/secrets`, data),- rotate: (id: string, data: { value: string; externalRef?: string | null }) =>+ providerHealth: (companyId: string) =>+ api.get<SecretProviderHealthResponse>(`/companies/${companyId}/secret-providers/health`),+ providerConfigs: (companyId: string) =>+ api.get<CompanySecretProviderConfig[]>(`/companies/${companyId}/secret-provider-configs`),+ createProviderConfig: (companyId: string, data: CreateSecretProviderConfigInput) =>+ api.post<CompanySecretProviderConfig>(`/companies/${companyId}/secret-provider-configs`, data),+ updateProviderConfig: (id: string, data: UpdateSecretProviderConfigInput) =>+ api.patch<CompanySecretProviderConfig>(`/secret-provider-configs/${id}`, data),+ disableProviderConfig: (id: string) =>+ api.delete<CompanySecretProviderConfig>(`/secret-provider-configs/${id}`),+ setDefaultProviderConfig: (id: string) =>+ api.post<CompanySecretProviderConfig>(`/secret-provider-configs/${id}/default`, {}),+ checkProviderConfigHealth: (id: string) =>+ api.post<SecretProviderConfigHealthResponse>(`/secret-provider-configs/${id}/health`, {}),+ create: (companyId: string, data: CreateSecretInput) =>+ api.post<CompanySecret>(`/companies/${companyId}/secrets`, data),+ update: (id: string, data: UpdateSecretInput) =>+ api.patch<CompanySecret>(`/secrets/${id}`, data),+ rotate: (id: string, data: RotateSecretInput) =>api.post<CompanySecret>(`/secrets/${id}/rotate`, data),- update: (- id: string,- data: { name?: string; description?: string | null; externalRef?: string | null },- ) => api.patch<CompanySecret>(`/secrets/${id}`, data),+ disable: (id: string) =>+ api.patch<CompanySecret>(`/secrets/${id}`, { status: "disabled" satisfies SecretStatus }),+ enable: (id: string) =>+ api.patch<CompanySecret>(`/secrets/${id}`, { status: "active" satisfies SecretStatus }),+ archive: (id: string) =>+ api.patch<CompanySecret>(`/secrets/${id}`, { status: "archived" satisfies SecretStatus }),remove: (id: string) => api.delete<{ ok: true }>(`/secrets/${id}`),+ usage: (id: string) => api.get<SecretUsageResponse>(`/secrets/${id}/usage`),+ accessEvents: (id: string) => api.get<SecretAccessEvent[]>(`/secrets/${id}/access-events`),+ remoteImportPreview: (companyId: string, data: RemoteImportPreviewInput) =>+ api.post<RemoteSecretImportPreviewResult>(+ `/companies/${companyId}/secrets/remote-import/preview`,+ data,+ ),+ remoteImport: (companyId: string, data: RemoteImportInput) =>+ api.post<RemoteSecretImportResult>(`/companies/${companyId}/secrets/remote-import`, data),};diff --git a/ui/src/components/CompanySettingsSidebar.test.tsx b/ui/src/components/CompanySettingsSidebar.test.tsxindex f2f6174be8..429d081223 100644--- a/ui/src/components/CompanySettingsSidebar.test.tsx+++ b/ui/src/components/CompanySettingsSidebar.test.tsx@@ -112,6 +112,7 @@ describe("CompanySettingsSidebar", () => {expect(container.textContent).toContain("Environments");expect(container.textContent).toContain("Access");expect(container.textContent).toContain("Invites");+ expect(container.textContent).toContain("Secrets");expect(sidebarNavItemMock).toHaveBeenCalledWith(expect.objectContaining({to: "/company/settings",@@ -141,6 +142,13 @@ describe("CompanySettingsSidebar", () => {end: true,}),);+ expect(sidebarNavItemMock).toHaveBeenCalledWith(+ expect.objectContaining({+ to: "/company/settings/secrets",+ label: "Secrets",+ end: true,+ }),+ );await act(async () => {root.unmount();diff --git a/ui/src/components/CompanySettingsSidebar.tsx b/ui/src/components/CompanySettingsSidebar.tsxindex 9515820113..fb8870c999 100644--- a/ui/src/components/CompanySettingsSidebar.tsx+++ b/ui/src/components/CompanySettingsSidebar.tsx@@ -1,5 +1,5 @@import { useQuery } from "@tanstack/react-query";-import { ChevronLeft, MailPlus, MonitorCog, Settings, Shield, SlidersHorizontal } from "lucide-react";+import { ChevronLeft, KeyRound, MailPlus, MonitorCog, Settings, Shield, SlidersHorizontal } from "lucide-react";import { sidebarBadgesApi } from "@/api/sidebarBadges";import { ApiError } from "@/api/client";import { Link } from "@/lib/router";@@ -68,6 +68,7 @@ export function CompanySettingsSidebar() {end/><SidebarNavItem to="/company/settings/invites" label="Invites" icon={MailPlus} end />+ <SidebarNavItem to="/company/settings/secrets" label="Secrets" icon={KeyRound} end /></div></nav></aside>diff --git a/ui/src/components/EnvVarEditor.tsx b/ui/src/components/EnvVarEditor.tsxindex 01df6d557b..08c7f58b29 100644--- a/ui/src/components/EnvVarEditor.tsx+++ b/ui/src/components/EnvVarEditor.tsx@@ -1,6 +1,6 @@import { useEffect, useRef, useState } from "react";-import type { CompanySecret, EnvBinding } from "@paperclipai/shared";-import { X } from "lucide-react";+import type { CompanySecret, EnvBinding, SecretVersionSelector } from "@paperclipai/shared";+import { AlertCircle, X } from "lucide-react";import { cn } from "../lib/utils";const inputClass =@@ -11,15 +11,20 @@ type Row = {source: "plain" | "secret";plainValue: string;secretId: string;+ version: SecretVersionSelector;};+function emptyRow(): Row {+ return { key: "", source: "plain", plainValue: "", secretId: "", version: "latest" };+}+function toRows(rec: Record<string, EnvBinding> | null | undefined): Row[] {if (!rec || typeof rec !== "object") {- return [{ key: "", source: "plain", plainValue: "", secretId: "" }];+ return [emptyRow()];}const entries = Object.entries(rec).map(([key, binding]) => {if (typeof binding === "string") {- return { key, source: "plain" as const, plainValue: binding, secretId: "" };+ return { key, source: "plain" as const, plainValue: binding, secretId: "", version: "latest" as const };}if (typeof binding === "object" &&@@ -27,12 +32,16 @@ function toRows(rec: Record<string, EnvBinding> | null | undefined): Row[] {"type" in binding &&(binding as { type?: unknown }).type === "secret_ref") {- const record = binding as { secretId?: unknown };+ const record = binding as { secretId?: unknown; version?: unknown };+ const version: SecretVersionSelector = typeof record.version === "number"+ ? record.version+ : "latest";return {key,source: "secret" as const,plainValue: "",secretId: typeof record.secretId === "string" ? record.secretId : "",+ version,};}if (@@ -47,11 +56,12 @@ function toRows(rec: Record<string, EnvBinding> | null | undefined): Row[] {source: "plain" as const,plainValue: typeof record.value === "string" ? record.value : "",secretId: "",+ version: "latest" as const,};}- return { key, source: "plain" as const, plainValue: "", secretId: "" };+ return { key, source: "plain" as const, plainValue: "", secretId: "", version: "latest" as const };});- return [...entries, { key: "", source: "plain", plainValue: "", secretId: "" }];+ return [...entries, emptyRow()];}export function EnvVarEditor({@@ -89,7 +99,7 @@ export function EnvVarEditor({if (!key) continue;if (row.source === "secret") {if (row.secretId) {- rec[key] = { type: "secret_ref", secretId: row.secretId, version: "latest" };+ rec[key] = { type: "secret_ref", secretId: row.secretId, version: row.version };} else {rec[key] = { type: "plain", value: row.plainValue };}@@ -102,13 +112,15 @@ export function EnvVarEditor({}function updateRow(index: number, patch: Partial<Row>) {- const withPatch = rows.map((row, rowIndex) => (rowIndex === index ? { ...row, ...patch } : row));+ const withPatch: Row[] = rows.map((row, rowIndex) =>+ rowIndex === index ? { ...row, ...patch, version: patch.version ?? row.version } : row,+ );if (withPatch[withPatch.length - 1].key ||withPatch[withPatch.length - 1].plainValue ||withPatch[withPatch.length - 1].secretId) {- withPatch.push({ key: "", source: "plain", plainValue: "", secretId: "" });+ withPatch.push(emptyRow());}setRows(withPatch);emit(withPatch);@@ -122,7 +134,7 @@ export function EnvVarEditor({next[next.length - 1].plainValue ||next[next.length - 1].secretId) {- next.push({ key: "", source: "plain", plainValue: "", secretId: "" });+ next.push(emptyRow());}setRows(next);emit(next);@@ -189,17 +201,46 @@ export function EnvVarEditor({{row.source === "secret" ? (<><select- className={cn(inputClass, "flex-[3] bg-background")}+ className={cn(inputClass, "flex-[3] bg-background", row.secretId && !secrets.some((s) => s.id === row.secretId) && "border-destructive text-destructive")}value={row.secretId}onChange={(event) => updateRow(index, { secretId: event.target.value })}><option value="">Select secret...</option>+ {row.secretId && !secrets.some((s) => s.id === row.secretId) ? (+ <option value={row.secretId}>Missing ({row.secretId.slice(0, 8)}…)</option>+ ) : null}{secrets.map((secret) => (<option key={secret.id} value={secret.id}>{secret.name}+ {secret.status !== "active" ? ` (${secret.status})` : ""}</option>))}</select>+ <select+ className={cn(inputClass, "flex-[1] bg-background")}+ value={row.version === "latest" ? "latest" : String(row.version)}+ onChange={(event) => {+ const raw = event.target.value;+ updateRow(index, { version: raw === "latest" ? "latest" : Number.parseInt(raw, 10) });+ }}+ disabled={!row.secretId}+ aria-label="Version"+ >+ <option value="latest">latest</option>+ {(() => {+ const selected = secrets.find((s) => s.id === row.secretId);+ if (!selected) return null;+ return Array.from({ length: Math.max(0, selected.latestVersion) }, (_, idx) => {+ const version = selected.latestVersion - idx;+ if (version <= 0) return null;+ return (+ <option key={version} value={version}>+ v{version}+ </option>+ );+ });+ })()}+ </select><buttontype="button"className="inline-flex items-center rounded-md border border-border px-2 py-0.5 text-xs text-muted-foreground hover:bg-accent/50 transition-colors shrink-0"@@ -244,8 +285,38 @@ export function EnvVarEditor({);})}{sealError && <p className="text-[11px] text-destructive">{sealError}</p>}+ {(() => {+ const issues: { key: string; reason: string }[] = [];+ for (const row of rows) {+ if (row.source !== "secret" || !row.secretId) continue;+ const secret = secrets.find((s) => s.id === row.secretId);+ if (!secret) {+ issues.push({ key: row.key.trim() || row.secretId, reason: "missing" });+ } else if (secret.status !== "active") {+ issues.push({ key: row.key.trim() || secret.name, reason: secret.status });+ }+ }+ if (!issues.length) return null;+ return (+ <p className="text-[11px] text-amber-700 dark:text-amber-400 inline-flex items-start gap-1">+ <AlertCircle className="h-3 w-3 mt-0.5 shrink-0" />+ <span>+ {issues.length} secret binding{issues.length === 1 ? "" : "s"} need attention:{" "}+ {issues.map((issue, idx) => (+ <span key={idx} className="font-mono">+ {issue.key}+ <span className="text-muted-foreground"> ({issue.reason})</span>+ {idx < issues.length - 1 ? ", " : ""}+ </span>+ ))}+ . Runs will fail until you remap or re-enable.+ </span>+ </p>+ );+ })()}<p className="text-[11px] text-muted-foreground/60">- PAPERCLIP_* variables are injected automatically at runtime.+ Set KEY to the env var name the process expects, for example GH_TOKEN. Choose Secret to resolve a stored+ value at run start. PAPERCLIP_* variables are injected automatically.</p></div>);diff --git a/ui/src/components/IssueScheduledRetryCard.test.tsx b/ui/src/components/IssueScheduledRetryCard.test.tsxindex d3f6e22cc5..9ef3cb86ae 100644--- a/ui/src/components/IssueScheduledRetryCard.test.tsx+++ b/ui/src/components/IssueScheduledRetryCard.test.tsx@@ -72,6 +72,17 @@ async function waitForUi(assertion: () => void) {});}+async function waitForRetryButtonText(expected: string) {+ for (let i = 0; i < 20; i += 1) {+ if ((getRetryNowButton()?.textContent ?? "").includes(expected)) return;+ // eslint-disable-next-line no-await-in-loop+ await act(async () => {+ await new Promise((resolve) => setTimeout(resolve, 0));+ });+ }+ expect(getRetryNowButton()!.textContent ?? "").toContain(expected);+}+function renderWithProviders(ui: ReactNode) {const queryClient = new QueryClient({defaultOptions: { queries: { retry: false }, mutations: { retry: false } },@@ -174,12 +185,11 @@ describe("IssueScheduledRetryCard", () => {act(() => {button!.click();});- await waitForUi(() => {- expect(retryNowMock).toHaveBeenCalledWith("issue-1");- const finalButton = getRetryNowButton();- expect(finalButton!.textContent ?? "").toContain("Promoted");- expect(finalButton!.disabled).toBe(true);- });+ await waitForRetryButtonText("Promoted");+ expect(retryNowMock).toHaveBeenCalledWith("issue-1");+ const finalButton = getRetryNowButton();+ expect(finalButton!.textContent ?? "").toContain("Promoted");+ expect(finalButton!.disabled).toBe(true);});it("shows already promoted state when backend reports duplicate click", async () => {@@ -190,10 +200,9 @@ describe("IssueScheduledRetryCard", () => {act(() => {getRetryNowButton()!.click();});- await waitForUi(() => {- expect(getRetryNowButton()!.textContent ?? "").toContain("Already promoted");- expect(container.querySelector('[data-testid="issue-scheduled-retry-error-band"]')).toBeNull();- });+ await waitForRetryButtonText("Already promoted");+ expect(getRetryNowButton()!.textContent ?? "").toContain("Already promoted");+ expect(container.querySelector('[data-testid="issue-scheduled-retry-error-band"]')).toBeNull();});it("renders an inline error band on backend failure", async () => {diff --git a/ui/src/components/SecretBindingPicker.tsx b/ui/src/components/SecretBindingPicker.tsxnew file mode 100644index 0000000000..f3b7863c0b--- /dev/null+++ b/ui/src/components/SecretBindingPicker.tsx@@ -0,0 +1,282 @@+import { useMemo, useState } from "react";+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";+import { AlertCircle, KeyRound, Loader2, Plus, X } from "lucide-react";+import type { CompanySecret, SecretVersionSelector } from "@paperclipai/shared";+import { secretsApi } from "../api/secrets";+import { queryKeys } from "../lib/queryKeys";+import { useCompany } from "../context/CompanyContext";+import { Button } from "@/components/ui/button";+import { Input } from "@/components/ui/input";+import { Textarea } from "@/components/ui/textarea";+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";+import { cn } from "../lib/utils";++export interface SecretBindingValue {+ secretId: string;+ version?: SecretVersionSelector;+}++interface SecretBindingPickerProps {+ value: SecretBindingValue | null;+ onChange: (next: SecretBindingValue | null) => void;+ label?: string;+ placeholder?: string;+ allowVersionSelector?: boolean;+ emptyHint?: string;+ className?: string;+ disabled?: boolean;+ /**+ * Optional whitelist of secret statuses to show. Defaults to "active".+ * Pass null to disable the filter and show every secret in the company.+ */+ statusFilter?: Array<CompanySecret["status"]> | null;+}++const VERSION_LATEST: SecretVersionSelector = "latest";++function describeSecret(secret: CompanySecret): string {+ const provider = secret.provider.replaceAll("_", " ");+ if (secret.managedMode === "external_reference") {+ return `External · ${provider}`;+ }+ return provider;+}++function statusTone(status: CompanySecret["status"]): string {+ switch (status) {+ case "active":+ return "text-emerald-600 dark:text-emerald-400";+ case "disabled":+ return "text-amber-600 dark:text-amber-400";+ case "archived":+ return "text-muted-foreground";+ case "deleted":+ return "text-destructive";+ default:+ return "text-muted-foreground";+ }+}++export function SecretBindingPicker({+ value,+ onChange,+ label = "Secret",+ placeholder = "Select secret",+ allowVersionSelector = true,+ emptyHint = "No matching secrets. Create one to bind it here.",+ className,+ disabled,+ statusFilter = ["active"],+}: SecretBindingPickerProps) {+ const queryClient = useQueryClient();+ const { selectedCompanyId } = useCompany();+ const [createOpen, setCreateOpen] = useState(false);+ const [createName, setCreateName] = useState("");+ const [createValue, setCreateValue] = useState("");+ const [createDescription, setCreateDescription] = useState("");+ const [createError, setCreateError] = useState<string | null>(null);++ const secretsQuery = useQuery({+ queryKey: selectedCompanyId+ ? queryKeys.secrets.list(selectedCompanyId)+ : ["secrets", "__disabled__"],+ queryFn: () => secretsApi.list(selectedCompanyId!),+ enabled: Boolean(selectedCompanyId),+ });++ const filteredSecrets = useMemo(() => {+ const all = secretsQuery.data ?? [];+ if (statusFilter === null) return all;+ return all.filter((secret) => statusFilter.includes(secret.status));+ }, [secretsQuery.data, statusFilter]);++ const selectedSecret = useMemo(() => {+ if (!value) return null;+ return (secretsQuery.data ?? []).find((secret) => secret.id === value.secretId) ?? null;+ }, [secretsQuery.data, value]);++ const selectedMissing = Boolean(value && !selectedSecret);++ const createMutation = useMutation({+ mutationFn: () =>+ secretsApi.create(selectedCompanyId!, {+ name: createName.trim(),+ value: createValue,+ description: createDescription.trim() || null,+ }),+ onSuccess: (created) => {+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.list(selectedCompanyId!) });+ onChange({ secretId: created.id, version: VERSION_LATEST });+ setCreateOpen(false);+ setCreateName("");+ setCreateValue("");+ setCreateDescription("");+ setCreateError(null);+ },+ onError: (error) => {+ setCreateError(error instanceof Error ? error.message : "Failed to create secret");+ },+ });++ const versionDisplay = (selector: SecretVersionSelector | undefined) => {+ if (selector === undefined || selector === VERSION_LATEST) return "latest";+ return `v${selector}`;+ };++ return (+ <div className={cn("space-y-1.5", className)}>+ {label ? (+ <div className="flex items-center justify-between text-xs font-medium text-foreground/80">+ <span>{label}</span>+ {value ? (+ <button+ type="button"+ className="text-[11px] text-muted-foreground hover:text-foreground inline-flex items-center gap-1"+ onClick={() => onChange(null)}+ disabled={disabled}+ >+ <X className="h-3 w-3" /> Clear+ </button>+ ) : null}+ </div>+ ) : null}+ <div className="flex items-center gap-1.5">+ <div className="relative flex-1">+ <KeyRound className="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />+ <select+ className={cn(+ "h-9 w-full rounded-md border border-border bg-background pl-7 pr-2 text-sm outline-none disabled:cursor-not-allowed disabled:opacity-60",+ selectedMissing && "border-destructive text-destructive",+ )}+ value={value?.secretId ?? ""}+ onChange={(event) => {+ const next = event.target.value;+ if (!next) {+ onChange(null);+ return;+ }+ onChange({ secretId: next, version: value?.version ?? VERSION_LATEST });+ }}+ disabled={disabled || secretsQuery.isPending}+ >+ <option value="">{secretsQuery.isPending ? "Loading…" : placeholder}</option>+ {selectedMissing && value ? (+ <option value={value.secretId}>Missing secret ({value.secretId.slice(0, 8)}…)</option>+ ) : null}+ {filteredSecrets.map((secret) => (+ <option key={secret.id} value={secret.id}>+ {secret.name} — {describeSecret(secret)}+ </option>+ ))}+ </select>+ </div>+ {allowVersionSelector ? (+ <select+ className="h-9 rounded-md border border-border bg-background px-2 text-xs outline-none disabled:cursor-not-allowed disabled:opacity-60"+ value={value?.version === undefined ? VERSION_LATEST : String(value.version)}+ onChange={(event) => {+ if (!value) return;+ const raw = event.target.value;+ const next: SecretVersionSelector = raw === VERSION_LATEST ? VERSION_LATEST : Number.parseInt(raw, 10);+ onChange({ ...value, version: next });+ }}+ disabled={disabled || !value || !selectedSecret}+ aria-label="Version"+ >+ <option value={VERSION_LATEST}>latest</option>+ {selectedSecret+ ? Array.from({ length: Math.max(0, selectedSecret.latestVersion) }, (_, index) => {+ const version = selectedSecret.latestVersion - index;+ if (version <= 0) return null;+ return (+ <option key={version} value={version}>+ v{version}+ </option>+ );+ })+ : null}+ </select>+ ) : null}+ <Button+ type="button"+ variant="outline"+ size="sm"+ onClick={() => setCreateOpen(true)}+ disabled={disabled || !selectedCompanyId}+ aria-label="Create secret"+ >+ <Plus className="h-3.5 w-3.5" />+ </Button>+ </div>++ {selectedSecret ? (+ <p className={cn("text-[11px] text-muted-foreground", statusTone(selectedSecret.status))}>+ {selectedSecret.status !== "active" ? `Status: ${selectedSecret.status}. ` : null}+ Bound to {versionDisplay(value?.version)} · {selectedSecret.key}+ </p>+ ) : selectedMissing ? (+ <p className="text-[11px] text-destructive flex items-center gap-1">+ <AlertCircle className="h-3 w-3" />+ The previously selected secret is no longer available. Pick another or remove the binding.+ </p>+ ) : (filteredSecrets.length === 0 && !secretsQuery.isPending) ? (+ <p className="text-[11px] text-muted-foreground">{emptyHint}</p>+ ) : null}++ <Dialog open={createOpen} onOpenChange={setCreateOpen}>+ <DialogContent className="sm:max-w-md">+ <DialogHeader>+ <DialogTitle>Create new secret</DialogTitle>+ </DialogHeader>+ <div className="space-y-3">+ <div>+ <label className="text-xs font-medium text-foreground/80" htmlFor="secret-name">Name</label>+ <Input+ id="secret-name"+ value={createName}+ onChange={(event) => setCreateName(event.target.value)}+ placeholder="OPENAI_API_KEY"+ autoFocus+ />+ </div>+ <div>+ <label className="text-xs font-medium text-foreground/80" htmlFor="secret-value">Value</label>+ <Textarea+ id="secret-value"+ value={createValue}+ onChange={(event) => setCreateValue(event.target.value)}+ rows={3}+ placeholder="Paste the secret value"+ className="font-mono text-xs"+ />+ <p className="text-[11px] text-muted-foreground mt-1">+ The value is stored once and never re-displayed. Rotate to replace.+ </p>+ </div>+ <div>+ <label className="text-xs font-medium text-foreground/80" htmlFor="secret-description">Description</label>+ <Input+ id="secret-description"+ value={createDescription}+ onChange={(event) => setCreateDescription(event.target.value)}+ placeholder="Optional notes (no values)"+ />+ </div>+ {createError ? <p className="text-xs text-destructive">{createError}</p> : null}+ </div>+ <DialogFooter>+ <Button type="button" variant="outline" onClick={() => setCreateOpen(false)}>Cancel</Button>+ <Button+ type="button"+ onClick={() => createMutation.mutate()}+ disabled={!createName.trim() || !createValue || createMutation.isPending}+ >+ {createMutation.isPending ? <Loader2 className="h-3.5 w-3.5 animate-spin" /> : null}+ Create & bind+ </Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>+ </div>+ );+}diff --git a/ui/src/lib/queryKeys.ts b/ui/src/lib/queryKeys.tsindex d9b8f4da23..24aa097f5f 100644--- a/ui/src/lib/queryKeys.ts+++ b/ui/src/lib/queryKeys.ts@@ -135,6 +135,9 @@ export const queryKeys = {secrets: {list: (companyId: string) => ["secrets", companyId] as const,providers: (companyId: string) => ["secret-providers", companyId] as const,+ providerConfigs: (companyId: string) => ["secret-provider-configs", companyId] as const,+ usage: (secretId: string) => ["secrets", "usage", secretId] as const,+ accessEvents: (secretId: string) => ["secrets", "access-events", secretId] as const,},companySearch: {search: (companyId: string, q: string, scope: string, limit: number, offset: number) =>diff --git a/ui/src/pages/Secrets.render.test.tsx b/ui/src/pages/Secrets.render.test.tsxnew file mode 100644index 0000000000..954b240940--- /dev/null+++ b/ui/src/pages/Secrets.render.test.tsx@@ -0,0 +1,308 @@+// @vitest-environment jsdom++import { act } from "react";+import { createRoot } from "react-dom/client";+import { MemoryRouter } from "react-router-dom";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import type { CompanySecretProviderConfig, SecretProviderDescriptor } from "@paperclipai/shared";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { ProviderVaultsTab, Secrets } from "./Secrets";++const mockSecretsApi = vi.hoisted(() => ({+ list: vi.fn(),+ providers: vi.fn(),+ providerHealth: vi.fn(),+ providerConfigs: vi.fn(),+ createProviderConfig: vi.fn(),+ updateProviderConfig: vi.fn(),+ disableProviderConfig: vi.fn(),+ setDefaultProviderConfig: vi.fn(),+ checkProviderConfigHealth: vi.fn(),+ create: vi.fn(),+ update: vi.fn(),+ rotate: vi.fn(),+ disable: vi.fn(),+ enable: vi.fn(),+ archive: vi.fn(),+ remove: vi.fn(),+ usage: vi.fn(),+ accessEvents: vi.fn(),+}));++const mockSetBreadcrumbs = vi.hoisted(() => vi.fn());+const mockPushToast = vi.hoisted(() => vi.fn());++vi.mock("../api/secrets", () => ({+ secretsApi: mockSecretsApi,+}));++vi.mock("../context/CompanyContext", () => ({+ useCompany: () => ({+ selectedCompanyId: "company-1",+ }),+}));++vi.mock("../context/BreadcrumbContext", () => ({+ useBreadcrumbs: () => ({+ setBreadcrumbs: mockSetBreadcrumbs,+ }),+}));++vi.mock("../context/ToastContext", () => ({+ useToast: () => ({+ pushToast: mockPushToast,+ }),+ useToastActions: () => ({+ pushToast: mockPushToast,+ }),+}));++vi.mock("../context/SidebarContext", () => ({+ useSidebar: () => ({+ isMobile: false,+ }),+}));++// eslint-disable-next-line @typescript-eslint/no-explicit-any+(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;++const providers: SecretProviderDescriptor[] = [+ {+ id: "local_encrypted",+ label: "Local encrypted",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: false,+ configured: true,+ },+ {+ id: "aws_secrets_manager",+ label: "AWS Secrets Manager",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: true,+ configured: true,+ },+ {+ id: "gcp_secret_manager",+ label: "GCP Secret Manager",+ requiresExternalRef: false,+ supportsManagedValues: false,+ supportsExternalReferences: true,+ configured: false,+ },+ {+ id: "vault",+ label: "Vault",+ requiresExternalRef: false,+ supportsManagedValues: false,+ supportsExternalReferences: true,+ configured: false,+ },+];++const providerConfigs = [+ {+ id: "vault-local",+ provider: "local_encrypted",+ displayName: "Local default",+ status: "ready",+ isDefault: true,+ healthStatus: "ready",+ healthCheckedAt: null,+ healthMessage: null,+ healthDetails: null,+ },+ {+ id: "vault-aws",+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ status: "ready",+ isDefault: false,+ healthStatus: null,+ healthCheckedAt: null,+ healthMessage: null,+ healthDetails: null,+ },+] satisfies Partial<CompanySecretProviderConfig>[];++async function flushReact() {+ await act(async () => {+ await Promise.resolve();+ await new Promise((resolve) => window.setTimeout(resolve, 0));+ });+}++describe("Secrets page layout", () => {+ let container: HTMLDivElement;++ beforeEach(() => {+ container = document.createElement("div");+ document.body.appendChild(container);++ mockSecretsApi.list.mockResolvedValue([]);+ mockSecretsApi.providers.mockResolvedValue(providers);+ mockSecretsApi.providerHealth.mockResolvedValue({+ providers: [+ {+ provider: "local_encrypted",+ status: "warn",+ message: "Local encrypted provider has a warning.",+ warnings: ["Backup reminder"],+ },+ ],+ });+ mockSecretsApi.providerConfigs.mockResolvedValue(providerConfigs);+ });++ afterEach(() => {+ container.remove();+ document.body.innerHTML = "";+ vi.clearAllMocks();+ });++ it("uses the shared search/filter/tab affordances and keeps vault sections quiet", async () => {+ const root = createRoot(container);+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });++ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <Secrets />+ </QueryClientProvider>,+ );+ });+ await flushReact();+ await flushReact();++ expect(container.querySelector('input[data-page-search-target="true"][aria-label="Search secrets"]')).not.toBeNull();+ expect(container.textContent).toContain("Use secrets by binding them to runtime environment variables.");+ expect(container.textContent).toContain("GH_TOKEN");+ expect(container.querySelectorAll("select")).toHaveLength(0);+ expect(container.textContent).not.toContain("Provider warnings detected");+ expect(container.textContent).not.toContain("2/2 active");++ await act(async () => {+ root.unmount();+ });++ const vaultRoot = createRoot(container);+ await act(async () => {+ vaultRoot.render(+ <ProviderVaultsTab+ providers={providers}+ providerConfigs={providerConfigs as CompanySecretProviderConfig[]}+ loading={false}+ error={null}+ onRetry={vi.fn()}+ onCreate={vi.fn()}+ onEdit={vi.fn()}+ onDisable={vi.fn()}+ onSetDefault={vi.fn()}+ onHealthCheck={vi.fn()}+ pendingActionId={null}+ />,+ );+ });+ await flushReact();++ expect(container.querySelector('a[href="#provider-vaults-local_encrypted"]')).not.toBeNull();+ expect(container.textContent).toContain("AWS production");+ expect(container.textContent).not.toContain("Managed writes");+ expect(container.textContent).not.toContain("External refs");++ await act(async () => {+ vaultRoot.unmount();+ });+ });++ it("opens reference details from the secrets table count", async () => {+ mockSecretsApi.list.mockResolvedValue([+ {+ id: "secret-openai",+ companyId: "company-1",+ key: "openai_api_key",+ name: "OPENAI_API_KEY",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 1,+ description: null,+ lastResolvedAt: null,+ lastRotatedAt: null,+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-1",+ referenceCount: 2,+ createdAt: new Date("2026-05-06T00:00:00.000Z"),+ updatedAt: new Date("2026-05-06T00:00:00.000Z"),+ },+ ]);+ mockSecretsApi.usage.mockResolvedValue({+ secretId: "secret-openai",+ bindings: [+ {+ id: "binding-agent",+ companyId: "company-1",+ secretId: "secret-openai",+ targetType: "agent",+ targetId: "agent-1",+ configPath: "env.OPENAI_API_KEY",+ versionSelector: "latest",+ required: true,+ label: null,+ target: {+ type: "agent",+ id: "agent-1",+ label: "CodexCoder",+ href: "/agents/codexcoder",+ status: "idle",+ },+ createdAt: new Date("2026-05-06T00:00:00.000Z"),+ updatedAt: new Date("2026-05-06T00:00:00.000Z"),+ },+ ],+ });++ const root = createRoot(container);+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });++ await act(async () => {+ root.render(+ <MemoryRouter>+ <QueryClientProvider client={queryClient}>+ <Secrets />+ </QueryClientProvider>+ </MemoryRouter>,+ );+ });+ await flushReact();+ await flushReact();++ const referencesButton = container.querySelector(+ 'button[aria-label="View references for OPENAI_API_KEY"]',+ ) as HTMLButtonElement | null;+ expect(referencesButton?.textContent).toBe("2");++ await act(async () => {+ referencesButton?.click();+ });+ await flushReact();++ expect(mockSecretsApi.usage).toHaveBeenCalledWith("secret-openai");+ expect(document.body.textContent).toContain("Secret references");+ expect(document.body.textContent).toContain("CodexCoder");+ expect(document.body.textContent).toContain("env.OPENAI_API_KEY");++ await act(async () => {+ root.unmount();+ });+ });+});diff --git a/ui/src/pages/Secrets.test.ts b/ui/src/pages/Secrets.test.tsnew file mode 100644index 0000000000..e650ab7a59--- /dev/null+++ b/ui/src/pages/Secrets.test.ts@@ -0,0 +1,129 @@+// @vitest-environment jsdom++import { describe, expect, it } from "vitest";+import type { SecretProviderDescriptor } from "@paperclipai/shared";+import {+ getAwsManagedPathPreview,+ getCreateProviderBlockReason,+ getDefaultProviderConfigId,+ getProviderConfigBlockReason,+} from "./Secrets";+import type { SecretProviderHealthResponse } from "../api/secrets";++const awsProvider: SecretProviderDescriptor = {+ id: "aws_secrets_manager",+ label: "AWS Secrets Manager",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: true,+ configured: true,+};++describe("Secrets page provider helpers", () => {+ it("previews the derived AWS managed path from provider health details", () => {+ const health: SecretProviderHealthResponse = {+ providers: [+ {+ provider: "aws_secrets_manager",+ status: "ok",+ message: "AWS Secrets Manager provider is configured",+ details: {+ prefix: "paperclip",+ deploymentId: "prod-us-1",+ },+ },+ ],+ };++ expect(+ getAwsManagedPathPreview({+ provider: awsProvider,+ health,+ companyId: "company-123",+ secretKeySource: "Anthropic API Key",+ }),+ ).toBe("paperclip/prod-us-1/company-123/anthropic-api-key");+ });++ it("blocks unconfigured providers before create submission", () => {+ expect(+ getCreateProviderBlockReason(+ { ...awsProvider, configured: false },+ "managed",+ null,+ ),+ ).toBe("AWS Secrets Manager is not configured in this deployment.");+ });++ it("uses provider health copy when an unconfigured provider reports missing bootstrap inputs", () => {+ const health: SecretProviderHealthResponse = {+ providers: [+ {+ provider: "aws_secrets_manager",+ status: "warn",+ message:+ "AWS Secrets Manager provider is not ready: missing PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID.",+ },+ ],+ };++ expect(+ getCreateProviderBlockReason(+ { ...awsProvider, configured: false },+ "managed",+ health,+ ),+ ).toBe(+ "AWS Secrets Manager is not configured in this deployment. AWS Secrets Manager provider is not ready: missing PAPERCLIP_SECRETS_AWS_DEPLOYMENT_ID.",+ );+ });++ it("blocks provider modes the backend does not support", () => {+ expect(+ getCreateProviderBlockReason(+ {+ id: "local_encrypted",+ label: "Local encrypted (default)",+ requiresExternalRef: false,+ supportsManagedValues: true,+ supportsExternalReferences: false,+ configured: true,+ },+ "external",+ null,+ ),+ ).toBe("Local encrypted (default) does not support linked external references.");+ });++ it("chooses the ready default provider vault for a provider", () => {+ expect(+ getDefaultProviderConfigId(+ [+ {+ id: "draft",+ provider: "aws_secrets_manager",+ status: "disabled",+ isDefault: true,+ },+ {+ id: "prod",+ provider: "aws_secrets_manager",+ status: "ready",+ isDefault: true,+ },+ ] as never,+ "aws_secrets_manager",+ ),+ ).toBe("prod");+ });++ it("explains why coming-soon provider vaults cannot be selected", () => {+ expect(+ getProviderConfigBlockReason({+ id: "vault-draft",+ provider: "vault",+ status: "coming_soon",+ } as never),+ ).toBe("This provider vault is saved as draft metadata only.");+ });+});diff --git a/ui/src/pages/Secrets.tsx b/ui/src/pages/Secrets.tsxnew file mode 100644index 0000000000..ec290a4567--- /dev/null+++ b/ui/src/pages/Secrets.tsx@@ -0,0 +1,2155 @@+import { useEffect, useMemo, useState } from "react";+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";+import {+ AlertCircle,+ AlertTriangle,+ ArchiveRestore,+ Archive,+ Ban,+ CheckCircle2,+ Cloud,+ Database,+ Edit3,+ ExternalLink,+ KeyRound,+ Link2,+ Loader2,+ Plus,+ RefreshCw,+ Search,+ ShieldCheck,+ Star,+ Trash2,+ X,+ Filter,+ Info,+} from "lucide-react";+import { Link } from "react-router-dom";+import type {+ CompanySecret,+ CompanySecretUsageBinding,+ CompanySecretProviderConfig,+ SecretAccessEvent,+ SecretManagedMode,+ SecretProvider,+ SecretProviderConfigStatus,+ SecretProviderDescriptor,+ SecretStatus,+} from "@paperclipai/shared";+import { useCompany } from "../context/CompanyContext";+import { useBreadcrumbs } from "../context/BreadcrumbContext";+import { useToastActions } from "../context/ToastContext";+import {+ secretsApi,+ type CreateSecretInput,+ type CreateSecretProviderConfigInput,+ type SecretProviderHealthResponse,+ type UpdateSecretProviderConfigInput,+} from "../api/secrets";+import { ApiError } from "../api/client";+import { queryKeys } from "../lib/queryKeys";+import { EmptyState } from "../components/EmptyState";+import { Button } from "@/components/ui/button";+import { Input } from "@/components/ui/input";+import { Textarea } from "@/components/ui/textarea";+import { Checkbox } from "@/components/ui/checkbox";+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";+import {+ Sheet,+ SheetContent,+ SheetHeader,+ SheetTitle,+ SheetDescription,+} from "@/components/ui/sheet";+import {+ Dialog,+ DialogContent,+ DialogDescription,+ DialogFooter,+ DialogHeader,+ DialogTitle,+} from "@/components/ui/dialog";+import { Tabs, TabsList, TabsTrigger, TabsContent } from "@/components/ui/tabs";+import { Badge } from "@/components/ui/badge";+import { cn } from "../lib/utils";+import { PageTabBar } from "../components/PageTabBar";+import { ImportFromVaultDialog } from "./secrets/ImportFromVaultDialog";++type CreateMode = "managed" | "external";+type SecretsTab = "secrets" | "vaults";++type ProviderVaultForm = {+ provider: SecretProvider;+ displayName: string;+ status: SecretProviderConfigStatus;+ isDefault: boolean;+ backupReminderAcknowledged: boolean;+ region: string;+ namespace: string;+ secretNamePrefix: string;+ kmsKeyId: string;+ ownerTag: string;+ environmentTag: string;+ projectId: string;+ location: string;+ address: string;+ mountPath: string;+ secretPathPrefix: string;+};++const PROVIDER_ORDER: SecretProvider[] = [+ "local_encrypted",+ "aws_secrets_manager",+ "gcp_secret_manager",+ "vault",+];++function defaultProviderVaultStatus(provider: SecretProvider): SecretProviderConfigStatus {+ return provider === "gcp_secret_manager" || provider === "vault" ? "coming_soon" : "ready";+}++function emptyProviderVaultForm(provider: SecretProvider = "local_encrypted"): ProviderVaultForm {+ return {+ provider,+ displayName: "",+ status: defaultProviderVaultStatus(provider),+ isDefault: false,+ backupReminderAcknowledged: false,+ region: "",+ namespace: "",+ secretNamePrefix: "",+ kmsKeyId: "",+ ownerTag: "",+ environmentTag: "",+ projectId: "",+ location: "",+ address: "",+ mountPath: "",+ secretPathPrefix: "",+ };+}++function providerConfigValue(config: CompanySecretProviderConfig["config"], key: string) {+ if (!config || typeof config !== "object" || Array.isArray(config)) return "";+ const value = (config as Record<string, unknown>)[key];+ return typeof value === "string" ? value : "";+}++function providerVaultFormFromConfig(config: CompanySecretProviderConfig): ProviderVaultForm {+ return {+ ...emptyProviderVaultForm(config.provider),+ displayName: config.displayName,+ status: config.status,+ isDefault: config.isDefault,+ backupReminderAcknowledged:+ Boolean((config.config as Record<string, unknown> | undefined)?.backupReminderAcknowledged),+ region: providerConfigValue(config.config, "region"),+ namespace: providerConfigValue(config.config, "namespace"),+ secretNamePrefix: providerConfigValue(config.config, "secretNamePrefix"),+ kmsKeyId: providerConfigValue(config.config, "kmsKeyId"),+ ownerTag: providerConfigValue(config.config, "ownerTag"),+ environmentTag: providerConfigValue(config.config, "environmentTag"),+ projectId: providerConfigValue(config.config, "projectId"),+ location: providerConfigValue(config.config, "location"),+ address: providerConfigValue(config.config, "address"),+ mountPath: providerConfigValue(config.config, "mountPath"),+ secretPathPrefix: providerConfigValue(config.config, "secretPathPrefix"),+ };+}++function formatRelative(value: Date | string | null | undefined): string {+ if (!value) return "—";+ const date = typeof value === "string" ? new Date(value) : value;+ if (Number.isNaN(date.getTime())) return "—";+ const diff = Date.now() - date.getTime();+ if (diff < 0) return date.toLocaleString();+ const seconds = Math.floor(diff / 1000);+ if (seconds < 60) return `${seconds}s ago`;+ const minutes = Math.floor(seconds / 60);+ if (minutes < 60) return `${minutes}m ago`;+ const hours = Math.floor(minutes / 60);+ if (hours < 48) return `${hours}h ago`;+ const days = Math.floor(hours / 24);+ if (days < 30) return `${days}d ago`;+ return date.toLocaleDateString();+}++function statusTextTone(status: SecretStatus) {+ switch (status) {+ case "active":+ return "text-emerald-700 dark:text-emerald-300";+ case "disabled":+ return "text-amber-700 dark:text-amber-300";+ case "archived":+ return "text-muted-foreground";+ case "deleted":+ return "text-destructive";+ default:+ return "text-muted-foreground";+ }+}++function providerLabel(providers: SecretProviderDescriptor[] | undefined, id: SecretProvider) {+ return providers?.find((p) => p.id === id)?.label ?? id.replaceAll("_", " ");+}++function normalizeSecretKeyForPreview(input: string) {+ return input+ .trim()+ .toLowerCase()+ .replace(/[^a-z0-9_.-]+/g, "-")+ .replace(/^-+|-+$/g, "")+ .slice(0, 120);+}+++function modeLabel(managedMode: SecretManagedMode) {+ return managedMode === "paperclip_managed" ? "Paperclip-managed" : "Linked external";+}++function modeDescription(managedMode: SecretManagedMode) {+ return managedMode === "paperclip_managed"+ ? "Paperclip owns create and rotation writes for this provider secret."+ : "Paperclip resolves this provider reference but does not rotate the provider value.";+}++function healthEntryForProvider(+ health: SecretProviderHealthResponse | null,+ providerId: SecretProvider,+) {+ return health?.providers.find((entry) => entry.provider === providerId) ?? null;+}++export function getCreateProviderBlockReason(+ provider: SecretProviderDescriptor | null | undefined,+ mode: CreateMode,+ health: SecretProviderHealthResponse | null,+) {+ if (!provider) return "Select a provider.";+ if (mode === "managed" && provider.supportsManagedValues === false) {+ return `${provider.label} does not support Paperclip-managed secret values.`;+ }+ if (mode === "external" && provider.supportsExternalReferences === false) {+ return `${provider.label} does not support linked external references.`;+ }+ if (provider.configured === false) {+ const healthEntry = healthEntryForProvider(health, provider.id);+ return healthEntry?.message+ ? `${provider.label} is not configured in this deployment. ${healthEntry.message}`+ : `${provider.label} is not configured in this deployment.`;+ }+ const healthEntry = healthEntryForProvider(health, provider.id);+ if (healthEntry?.status === "error") {+ return `${provider.label} health check failed: ${healthEntry.message}`;+ }+ return null;+}++function providerHealthText(+ provider: SecretProviderDescriptor | null | undefined,+ health: SecretProviderHealthResponse | null,+) {+ if (!provider) return null;+ const entry = healthEntryForProvider(health, provider.id);+ if (!entry) return null;+ const warnings = entry.warnings?.join(" ");+ return [entry.message, warnings].filter(Boolean).join(" ");+}++function detailString(details: Record<string, unknown> | undefined, key: string) {+ const value = details?.[key];+ return typeof value === "string" && value.trim() ? value.trim() : null;+}++export function getProviderConfigBlockReason(+ config: CompanySecretProviderConfig | null | undefined,+) {+ if (!config) return null;+ if (config.status === "disabled") return "This provider vault is disabled.";+ if (config.status === "coming_soon") return "This provider vault is saved as draft metadata only.";+ if (config.healthStatus === "error") {+ return config.healthMessage ?? "This provider vault health check failed.";+ }+ return null;+}++export function getDefaultProviderConfigId(+ configs: CompanySecretProviderConfig[],+ provider: SecretProvider,+) {+ const providerConfigs = configs.filter((config) => config.provider === provider);+ const selectable = providerConfigs.filter((config) => !getProviderConfigBlockReason(config));+ return (+ selectable.find((config) => config.isDefault)?.id ??+ selectable[0]?.id ??+ providerConfigs.find((config) => config.isDefault)?.id ??+ ""+ );+}++function providerVaultLabel(configs: CompanySecretProviderConfig[], id: string | null | undefined) {+ if (!id) return "Deployment default";+ return configs.find((config) => config.id === id)?.displayName ?? "Unknown vault";+}++function buildProviderVaultConfig(form: ProviderVaultForm): Record<string, unknown> {+ const compact = (value: string) => value.trim() || null;+ switch (form.provider) {+ case "local_encrypted":+ return { backupReminderAcknowledged: form.backupReminderAcknowledged };+ case "aws_secrets_manager":+ return {+ region: form.region.trim(),+ namespace: compact(form.namespace),+ secretNamePrefix: compact(form.secretNamePrefix),+ kmsKeyId: compact(form.kmsKeyId),+ ownerTag: compact(form.ownerTag),+ environmentTag: compact(form.environmentTag),+ };+ case "gcp_secret_manager":+ return {+ projectId: compact(form.projectId),+ location: compact(form.location),+ namespace: compact(form.namespace),+ secretNamePrefix: compact(form.secretNamePrefix),+ };+ case "vault":+ return {+ address: compact(form.address),+ namespace: compact(form.namespace),+ mountPath: compact(form.mountPath),+ secretPathPrefix: compact(form.secretPathPrefix),+ };+ default:+ return {};+ }+}++export function getAwsManagedPathPreview(input: {+ provider: SecretProviderDescriptor | null | undefined;+ health: SecretProviderHealthResponse | null;+ companyId: string;+ secretKeySource: string;+}) {+ if (input.provider?.id !== "aws_secrets_manager") return null;+ const healthEntry = healthEntryForProvider(input.health, "aws_secrets_manager");+ const prefix = detailString(healthEntry?.details, "prefix") ?? "paperclip";+ const deploymentId = detailString(healthEntry?.details, "deploymentId") ?? "{deploymentId}";+ const secretKey = normalizeSecretKeyForPreview(input.secretKeySource) || "{secretKey}";+ return `${prefix}/${deploymentId}/${input.companyId}/${secretKey}`;+}++export function Secrets() {+ const queryClient = useQueryClient();+ const { selectedCompanyId } = useCompany();+ const { setBreadcrumbs } = useBreadcrumbs();+ const { pushToast } = useToastActions();+ const [activeTab, setActiveTab] = useState<SecretsTab>("secrets");+ const [secretDetailTab, setSecretDetailTab] = useState("details");+ const [search, setSearch] = useState("");+ const [statusFilter, setStatusFilter] = useState<SecretStatus | "all">("active");+ const [providerFilter, setProviderFilter] = useState<SecretProvider | "all">("all");+ const [selectedSecretId, setSelectedSecretId] = useState<string | null>(null);+ const [usageDialogSecretId, setUsageDialogSecretId] = useState<string | null>(null);+ const [createOpen, setCreateOpen] = useState(false);+ const [importOpen, setImportOpen] = useState(false);+ const [createMode, setCreateMode] = useState<CreateMode>("managed");+ const [createForm, setCreateForm] = useState({+ name: "",+ key: "",+ value: "",+ description: "",+ externalRef: "",+ provider: "local_encrypted" as SecretProvider,+ providerConfigId: "",+ });+ const [createError, setCreateError] = useState<string | null>(null);+ const [rotateOpen, setRotateOpen] = useState(false);+ const [rotateValue, setRotateValue] = useState("");+ const [rotateExternalRef, setRotateExternalRef] = useState("");+ const [rotateProviderConfigId, setRotateProviderConfigId] = useState("");+ const [rotateError, setRotateError] = useState<string | null>(null);+ const [deleteConfirm, setDeleteConfirm] = useState<CompanySecret | null>(null);+ const [vaultDialogOpen, setVaultDialogOpen] = useState(false);+ const [editingVault, setEditingVault] = useState<CompanySecretProviderConfig | null>(null);+ const [vaultForm, setVaultForm] = useState<ProviderVaultForm>(() => emptyProviderVaultForm());+ const [vaultError, setVaultError] = useState<string | null>(null);++ useEffect(() => {+ setBreadcrumbs([{ label: "Secrets" }]);+ }, [setBreadcrumbs]);++ const secretsQuery = useQuery({+ queryKey: selectedCompanyId+ ? queryKeys.secrets.list(selectedCompanyId)+ : ["secrets", "__disabled__"],+ queryFn: () => secretsApi.list(selectedCompanyId!),+ enabled: Boolean(selectedCompanyId),+ });++ const providersQuery = useQuery({+ queryKey: selectedCompanyId+ ? queryKeys.secrets.providers(selectedCompanyId)+ : ["secret-providers", "__disabled__"],+ queryFn: () => secretsApi.providers(selectedCompanyId!),+ enabled: Boolean(selectedCompanyId),+ staleTime: 5 * 60_000,+ });++ const providerHealthQuery = useQuery({+ queryKey: selectedCompanyId+ ? ["secret-provider-health", selectedCompanyId]+ : ["secret-provider-health", "__disabled__"],+ queryFn: () => secretsApi.providerHealth(selectedCompanyId!),+ enabled: Boolean(selectedCompanyId),+ refetchInterval: 60_000,+ retry: false,+ });++ const providerConfigsQuery = useQuery({+ queryKey: selectedCompanyId+ ? queryKeys.secrets.providerConfigs(selectedCompanyId)+ : ["secret-provider-configs", "__disabled__"],+ queryFn: () => secretsApi.providerConfigs(selectedCompanyId!),+ enabled: Boolean(selectedCompanyId),+ retry: false,+ });++ const secrets = secretsQuery.data ?? [];+ const providers = providersQuery.data ?? [];+ const providerConfigs = providerConfigsQuery.data ?? [];+ const selectedSecret = useMemo(+ () => secrets.find((secret) => secret.id === selectedSecretId) ?? null,+ [secrets, selectedSecretId],+ );+ const usageDialogSecret = useMemo(+ () => secrets.find((secret) => secret.id === usageDialogSecretId) ?? null,+ [secrets, usageDialogSecretId],+ );+ const selectedCreateProvider = useMemo(+ () => providers.find((provider) => provider.id === createForm.provider) ?? null,+ [providers, createForm.provider],+ );+ const createProviderConfigs = useMemo(+ () => providerConfigs.filter((config) => config.provider === createForm.provider),+ [createForm.provider, providerConfigs],+ );+ const selectedCreateProviderConfig = useMemo(+ () => providerConfigs.find((config) => config.id === createForm.providerConfigId) ?? null,+ [createForm.providerConfigId, providerConfigs],+ );+ const selectedRotateProviderConfigs = useMemo(+ () => providerConfigs.filter((config) => config.provider === selectedSecret?.provider),+ [providerConfigs, selectedSecret?.provider],+ );+ const selectedRotateProviderConfig = useMemo(+ () => providerConfigs.find((config) => config.id === rotateProviderConfigId) ?? null,+ [providerConfigs, rotateProviderConfigId],+ );+ const createProviderBlockReason = getCreateProviderBlockReason(+ selectedCreateProvider,+ createMode,+ providerHealthQuery.data ?? null,+ ) ?? getProviderConfigBlockReason(selectedCreateProviderConfig);+ const rotateProviderBlockReason = getProviderConfigBlockReason(selectedRotateProviderConfig);+ const createProviderHealthText = providerHealthText(+ selectedCreateProvider,+ providerHealthQuery.data ?? null,+ );+ const awsManagedPathPreview = getAwsManagedPathPreview({+ provider: selectedCreateProvider,+ health: providerHealthQuery.data ?? null,+ companyId: selectedCompanyId ?? "{companyId}",+ secretKeySource: createForm.key.trim() || createForm.name,+ });++ const filtered = useMemo(() => {+ const needle = search.trim().toLowerCase();+ return secrets.filter((secret) => {+ if (statusFilter !== "all" && secret.status !== statusFilter) return false;+ if (providerFilter !== "all" && secret.provider !== providerFilter) return false;+ if (!needle) return true;+ return (+ secret.name.toLowerCase().includes(needle) ||+ secret.key.toLowerCase().includes(needle) ||+ (secret.description?.toLowerCase().includes(needle) ?? false) ||+ (secret.externalRef?.toLowerCase().includes(needle) ?? false)+ );+ });+ }, [secrets, search, statusFilter, providerFilter]);+ const activeSecretFilterCount = (statusFilter === "active" ? 0 : 1) + (providerFilter === "all" ? 0 : 1);++ const usageQuery = useQuery({+ queryKey: selectedSecret ? queryKeys.secrets.usage(selectedSecret.id) : ["secrets", "usage", "__disabled__"],+ queryFn: () => secretsApi.usage(selectedSecret!.id),+ enabled: Boolean(selectedSecret),+ });+ const eventsQuery = useQuery({+ queryKey: selectedSecret+ ? queryKeys.secrets.accessEvents(selectedSecret.id)+ : ["secrets", "access-events", "__disabled__"],+ queryFn: () => secretsApi.accessEvents(selectedSecret!.id),+ enabled: Boolean(selectedSecret),+ });++ const usageDialogQuery = useQuery({+ queryKey: usageDialogSecret+ ? queryKeys.secrets.usage(usageDialogSecret.id)+ : ["secrets", "usage-dialog", "__disabled__"],+ queryFn: () => secretsApi.usage(usageDialogSecret!.id),+ enabled: Boolean(usageDialogSecret),+ });++ function invalidateAll(extraIds: string[] = []) {+ if (!selectedCompanyId) return;+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.list(selectedCompanyId) });+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.providerConfigs(selectedCompanyId) });+ for (const id of extraIds) {+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.usage(id) });+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.accessEvents(id) });+ }+ }++ const createMutation = useMutation({+ mutationFn: () => {+ const input: CreateSecretInput = {+ name: createForm.name.trim(),+ provider: createForm.provider,+ providerConfigId: createForm.providerConfigId || null,+ managedMode: createMode === "external" ? "external_reference" : "paperclip_managed",+ description: createForm.description.trim() || null,+ };+ if (createForm.key.trim()) input.key = createForm.key.trim();+ if (createMode === "managed") {+ input.value = createForm.value;+ } else {+ input.externalRef = createForm.externalRef.trim();+ }+ return secretsApi.create(selectedCompanyId!, input);+ },+ onSuccess: (created) => {+ pushToast({ title: "Secret created", body: created.name, tone: "success" });+ setCreateOpen(false);+ setCreateForm({+ name: "",+ key: "",+ value: "",+ description: "",+ externalRef: "",+ provider: createForm.provider,+ providerConfigId: getDefaultProviderConfigId(providerConfigs, createForm.provider),+ });+ setCreateError(null);+ setSelectedSecretId(created.id);+ invalidateAll([created.id]);+ },+ onError: (error) => {+ setCreateError(error instanceof ApiError ? error.message : (error as Error).message);+ },+ });++ const rotateMutation = useMutation({+ mutationFn: () => {+ if (!selectedSecret) throw new Error("Select a secret first");+ if (selectedSecret.managedMode === "external_reference") {+ return secretsApi.rotate(selectedSecret.id, {+ externalRef: rotateExternalRef.trim() || selectedSecret.externalRef || undefined,+ providerConfigId: rotateProviderConfigId || null,+ });+ }+ return secretsApi.rotate(selectedSecret.id, {+ value: rotateValue,+ providerConfigId: rotateProviderConfigId || null,+ });+ },+ onSuccess: (updated) => {+ pushToast({ title: "Rotated", body: `${updated.name} → v${updated.latestVersion}`, tone: "success" });+ setRotateOpen(false);+ setRotateValue("");+ setRotateExternalRef("");+ setRotateProviderConfigId("");+ setRotateError(null);+ invalidateAll([updated.id]);+ },+ onError: (error) => {+ setRotateError(error instanceof Error ? error.message : "Rotate failed");+ },+ });++ const statusMutation = useMutation({+ mutationFn: ({ id, status }: { id: string; status: SecretStatus }) => {+ switch (status) {+ case "active":+ return secretsApi.enable(id);+ case "disabled":+ return secretsApi.disable(id);+ case "archived":+ return secretsApi.archive(id);+ default:+ return secretsApi.update(id, { status });+ }+ },+ onSuccess: (updated) => {+ pushToast({ title: `Secret ${updated.status}`, body: updated.name, tone: "info" });+ invalidateAll([updated.id]);+ },+ onError: (error) => {+ pushToast({+ title: "Status update failed",+ body: error instanceof Error ? error.message : "Try again",+ tone: "error",+ });+ },+ });++ const deleteMutation = useMutation({+ mutationFn: (id: string) => secretsApi.remove(id),+ onSuccess: (_response, id) => {+ pushToast({ title: "Secret deleted", tone: "info" });+ setDeleteConfirm(null);+ if (selectedSecretId === id) setSelectedSecretId(null);+ invalidateAll([id]);+ },+ onError: (error) => {+ pushToast({+ title: "Delete failed",+ body: error instanceof Error ? error.message : "Try again",+ tone: "error",+ });+ },+ });++ const saveVaultMutation = useMutation({+ mutationFn: () => {+ const data: CreateSecretProviderConfigInput | UpdateSecretProviderConfigInput = {+ displayName: vaultForm.displayName.trim(),+ status: vaultForm.status,+ isDefault: vaultForm.isDefault,+ config: buildProviderVaultConfig(vaultForm),+ };+ if (editingVault) {+ return secretsApi.updateProviderConfig(editingVault.id, data);+ }+ return secretsApi.createProviderConfig(selectedCompanyId!, {+ ...(data as UpdateSecretProviderConfigInput),+ provider: vaultForm.provider,+ } as CreateSecretProviderConfigInput);+ },+ onSuccess: (saved) => {+ pushToast({ title: editingVault ? "Provider vault updated" : "Provider vault created", body: saved.displayName, tone: "success" });+ setVaultDialogOpen(false);+ setEditingVault(null);+ setVaultForm(emptyProviderVaultForm());+ setVaultError(null);+ invalidateAll();+ },+ onError: (error) => {+ setVaultError(error instanceof ApiError ? error.message : (error as Error).message);+ },+ });++ const disableVaultMutation = useMutation({+ mutationFn: (id: string) => secretsApi.disableProviderConfig(id),+ onSuccess: (updated) => {+ pushToast({ title: "Provider vault disabled", body: updated.displayName, tone: "info" });+ invalidateAll();+ },+ onError: (error) => {+ pushToast({+ title: "Disable failed",+ body: error instanceof Error ? error.message : "Try again",+ tone: "error",+ });+ },+ });++ const defaultVaultMutation = useMutation({+ mutationFn: (id: string) => secretsApi.setDefaultProviderConfig(id),+ onSuccess: (updated) => {+ pushToast({ title: "Default vault set", body: updated.displayName, tone: "success" });+ invalidateAll();+ },+ onError: (error) => {+ pushToast({+ title: "Default update failed",+ body: error instanceof Error ? error.message : "Try again",+ tone: "error",+ });+ },+ });++ const healthVaultMutation = useMutation({+ mutationFn: (id: string) => secretsApi.checkProviderConfigHealth(id),+ onSuccess: (health) => {+ pushToast({ title: "Health checked", body: health.message, tone: health.status === "error" ? "error" : "info" });+ invalidateAll();+ },+ onError: (error) => {+ pushToast({+ title: "Health check failed",+ body: error instanceof Error ? error.message : "Try again",+ tone: "error",+ });+ },+ });++ useEffect(() => {+ if (!createOpen || providers.length === 0) return;+ const currentBlockReason = getCreateProviderBlockReason(+ providers.find((provider) => provider.id === createForm.provider) ?? null,+ createMode,+ providerHealthQuery.data ?? null,+ );+ if (!currentBlockReason) return;+ const replacement = providers.find(+ (provider) =>+ !getCreateProviderBlockReason(provider, createMode, providerHealthQuery.data ?? null),+ );+ if (replacement && replacement.id !== createForm.provider) {+ setCreateForm((current) => ({+ ...current,+ provider: replacement.id,+ providerConfigId: getDefaultProviderConfigId(providerConfigs, replacement.id),+ }));+ }+ }, [createForm.provider, createMode, createOpen, providerConfigs, providerHealthQuery.data, providers]);++ useEffect(() => {+ if (!createOpen) return;+ const current = providerConfigs.find((config) => config.id === createForm.providerConfigId);+ if (current?.provider === createForm.provider) return;+ setCreateForm((form) => ({+ ...form,+ providerConfigId: getDefaultProviderConfigId(providerConfigs, form.provider),+ }));+ }, [createForm.provider, createForm.providerConfigId, createOpen, providerConfigs]);++ useEffect(() => {+ if (!rotateOpen || !selectedSecret) return;+ setRotateProviderConfigId(+ selectedSecret.providerConfigId ?? getDefaultProviderConfigId(providerConfigs, selectedSecret.provider),+ );+ }, [providerConfigs, rotateOpen, selectedSecret]);++ function openCreateVault(provider: SecretProvider = "local_encrypted") {+ setEditingVault(null);+ setVaultForm(emptyProviderVaultForm(provider));+ setVaultError(null);+ setVaultDialogOpen(true);+ }++ function openEditVault(config: CompanySecretProviderConfig) {+ setEditingVault(config);+ setVaultForm(providerVaultFormFromConfig(config));+ setVaultError(null);+ setVaultDialogOpen(true);+ }++ if (!selectedCompanyId) {+ return (+ <div className="p-6 text-sm text-muted-foreground">Select a company to manage secrets.</div>+ );+ }++ return (+ <div className="flex h-full min-h-0 flex-col gap-4">+ <div className="flex items-center gap-2">+ <KeyRound className="h-5 w-5 text-muted-foreground" />+ <h1 className="text-lg font-semibold">Secrets</h1>+ </div>++ <Tabs+ value={activeTab}+ onValueChange={(value) => setActiveTab(value as SecretsTab)}+ className="flex min-h-0 flex-1 flex-col gap-4"+ >+ <PageTabBar+ items={[+ { value: "secrets", label: "Secrets" },+ { value: "vaults", label: "Provider vaults" },+ ]}+ align="start"+ value={activeTab}+ onValueChange={(value) => setActiveTab(value as SecretsTab)}+ />++ <TabsContent value="secrets" className="flex min-h-0 flex-1 flex-col gap-3 overflow-hidden">+ <SecretsHowToUse />+ <div className="flex flex-wrap items-center gap-2">+ <div className="relative w-48 sm:w-64 md:w-80">+ <Search className="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />+ <Input+ value={search}+ onChange={(event) => setSearch(event.target.value)}+ placeholder="Search by name, key, ref"+ className="pl-7 text-xs sm:text-sm"+ aria-label="Search secrets"+ data-page-search-target="true"+ />+ </div>+ <SecretsFiltersPopover+ statusFilter={statusFilter}+ providerFilter={providerFilter}+ providers={providers}+ activeFilterCount={activeSecretFilterCount}+ onStatusChange={setStatusFilter}+ onProviderChange={setProviderFilter}+ />+ <ImportFromVaultButton+ providerConfigs={providerConfigs}+ onClick={() => setImportOpen(true)}+ onManageVaults={() => setActiveTab("vaults")}+ className="ml-auto"+ />+ <Button onClick={() => setCreateOpen(true)} size="sm">+ <Plus className="h-3.5 w-3.5 mr-1" /> New secret+ </Button>+ </div>+ <div className="min-h-0 flex-1 overflow-y-auto">+ {secretsQuery.isError ? (+ <div className="text-sm text-destructive flex items-center gap-2 py-4">+ <AlertCircle className="h-4 w-4" /> Failed to load secrets:{" "}+ {(secretsQuery.error as Error).message}+ <Button variant="ghost" size="sm" onClick={() => secretsQuery.refetch()}>+ Retry+ </Button>+ </div>+ ) : secrets.length === 0 && !secretsQuery.isPending ? (+ <EmptyState+ icon={KeyRound}+ message="No secrets yet. Create your first managed secret or link an external reference."+ action="New secret"+ onAction={() => setCreateOpen(true)}+ />+ ) : filtered.length === 0 ? (+ <EmptyState icon={Search} message="No secrets match your filters." />+ ) : (+ <table className="w-full text-sm">+ <thead className="bg-muted/40 text-xs uppercase tracking-wide text-muted-foreground">+ <tr>+ <th className="px-3 py-2 text-left font-medium">Name</th>+ <th className="px-2 py-2 text-left font-medium">Mode</th>+ <th className="px-2 py-2 text-left font-medium">Provider</th>+ <th className="px-2 py-2 text-left font-medium">Status</th>+ <th className="px-2 py-2 text-left font-medium">Version</th>+ <th className="px-2 py-2 text-left font-medium">Last rotated</th>+ <th className="px-2 py-2 text-left font-medium">Last resolved</th>+ <th className="px-2 py-2 text-left font-medium">References</th>+ <th className="px-2 py-2 text-left font-medium">Reference</th>+ <th className="px-3 py-2"></th>+ </tr>+ </thead>+ <tbody>+ {filtered.map((secret) => (+ <tr+ key={secret.id}+ className={cn(+ "border-b border-border/60 hover:bg-accent/40 cursor-pointer",+ selectedSecretId === secret.id && "bg-accent/60",+ )}+ onClick={() => setSelectedSecretId(secret.id)}+ >+ <td className="px-3 py-2.5">+ <div className="font-medium text-foreground">{secret.name}</div>+ </td>+ <td className="px-2 py-2.5 text-xs text-muted-foreground">+ {modeLabel(secret.managedMode)}+ </td>+ <td className="px-2 py-2.5 text-xs">+ <div>{providerLabel(providers, secret.provider)}</div>+ </td>+ <td className="px-2 py-2.5">+ <span className={cn("text-xs font-medium", statusTextTone(secret.status))}>+ {secret.status}+ </span>+ </td>+ <td className="px-2 py-2.5 text-xs font-mono">v{secret.latestVersion}</td>+ <td className="px-2 py-2.5 text-xs text-muted-foreground">+ {formatRelative(secret.lastRotatedAt)}+ </td>+ <td className="px-2 py-2.5 text-xs text-muted-foreground">+ {formatRelative(secret.lastResolvedAt)}+ </td>+ <td className="px-2 py-2.5 text-xs">+ <Button+ variant="ghost"+ size="sm"+ className="h-7 px-2 text-xs"+ aria-label={`View references for ${secret.name}`}+ onClick={(event) => {+ event.stopPropagation();+ setUsageDialogSecretId(secret.id);+ }}+ >+ {secret.referenceCount ?? 0}+ </Button>+ </td>+ <td className="px-2 py-2.5 text-xs">+ {secret.managedMode === "external_reference" ? (+ <span className="inline-flex items-center gap-1 font-mono text-muted-foreground">+ <Link2 className="h-3 w-3" />+ {secret.externalRef ?? "—"}+ </span>+ ) : (+ <span className="text-muted-foreground">Owned</span>+ )}+ </td>+ <td className="px-3 py-2.5 text-right">+ <Button+ variant="ghost"+ size="sm"+ onClick={(event) => {+ event.stopPropagation();+ setSelectedSecretId(secret.id);+ }}+ >+ Open+ </Button>+ </td>+ </tr>+ ))}+ </tbody>+ </table>+ )}+ </div>+ </TabsContent>+ <TabsContent value="vaults" className="min-h-0 flex-1 overflow-y-auto">+ <ProviderVaultsTab+ providers={providers}+ providerConfigs={providerConfigs}+ loading={providerConfigsQuery.isPending}+ error={providerConfigsQuery.error}+ onRetry={() => providerConfigsQuery.refetch()}+ onCreate={openCreateVault}+ onEdit={openEditVault}+ onDisable={(config) => disableVaultMutation.mutate(config.id)}+ onSetDefault={(config) => defaultVaultMutation.mutate(config.id)}+ onHealthCheck={(config) => healthVaultMutation.mutate(config.id)}+ pendingActionId={+ disableVaultMutation.variables ??+ defaultVaultMutation.variables ??+ healthVaultMutation.variables ??+ null+ }+ />+ </TabsContent>+ </Tabs>++ <Sheet open={Boolean(selectedSecret)} onOpenChange={(open) => !open && setSelectedSecretId(null)}>+ <SheetContent className="w-full sm:max-w-xl flex flex-col gap-0">+ {selectedSecret ? (+ <>+ <SheetHeader>+ <SheetTitle className="flex items-center gap-2 text-base">+ <KeyRound className="h-4 w-4" />+ {selectedSecret.name}+ <span className={cn("ml-2 text-sm font-normal", statusTextTone(selectedSecret.status))}>+ {selectedSecret.status}+ </span>+ </SheetTitle>+ <SheetDescription>+ {providerLabel(providers, selectedSecret.provider)} · v{selectedSecret.latestVersion} · {modeLabel(selectedSecret.managedMode)}+ </SheetDescription>+ </SheetHeader>+ <div className="flex flex-wrap gap-2 px-4 pb-2">+ <Button+ size="sm"+ variant="outline"+ onClick={() => {+ setRotateOpen(true);+ setRotateValue("");+ setRotateExternalRef("");+ setRotateProviderConfigId(+ selectedSecret.providerConfigId ??+ getDefaultProviderConfigId(providerConfigs, selectedSecret.provider),+ );+ setRotateError(null);+ }}+ >+ <RefreshCw className="h-3.5 w-3.5 mr-1" />+ {selectedSecret.managedMode === "external_reference" ? "Update reference" : "Update value"}+ </Button>+ {selectedSecret.status === "active" ? (+ <Button+ size="sm"+ variant="outline"+ onClick={() => statusMutation.mutate({ id: selectedSecret.id, status: "disabled" })}+ disabled={statusMutation.isPending}+ >+ <Ban className="h-3.5 w-3.5 mr-1" /> Disable+ </Button>+ ) : (+ <Button+ size="sm"+ variant="outline"+ onClick={() => statusMutation.mutate({ id: selectedSecret.id, status: "active" })}+ disabled={statusMutation.isPending}+ >+ <CheckCircle2 className="h-3.5 w-3.5 mr-1" /> Activate+ </Button>+ )}+ {selectedSecret.status === "archived" ? (+ <Button+ size="sm"+ variant="outline"+ onClick={() => statusMutation.mutate({ id: selectedSecret.id, status: "active" })}+ disabled={statusMutation.isPending}+ >+ <ArchiveRestore className="h-3.5 w-3.5 mr-1" /> Unarchive+ </Button>+ ) : (+ <Button+ size="sm"+ variant="outline"+ onClick={() => statusMutation.mutate({ id: selectedSecret.id, status: "archived" })}+ disabled={statusMutation.isPending}+ >+ <Archive className="h-3.5 w-3.5 mr-1" /> Archive+ </Button>+ )}+ <Button+ size="sm"+ variant="outline"+ className="text-destructive hover:text-destructive"+ onClick={() => setDeleteConfirm(selectedSecret)}+ >+ <Trash2 className="h-3.5 w-3.5 mr-1" /> Delete+ </Button>+ </div>+ <Tabs value={secretDetailTab} onValueChange={setSecretDetailTab} className="flex-1 min-h-0 flex flex-col">+ <div className="border-b border-border px-4">+ <PageTabBar+ items={[+ { value: "details", label: "Details" },+ { value: "usage", label: usageQuery.data ? `Usage (${usageQuery.data.bindings.length})` : "Usage" },+ { value: "events", label: "Access events" },+ ]}+ align="start"+ value={secretDetailTab}+ onValueChange={setSecretDetailTab}+ />+ </div>+ <div className="flex-1 min-h-0 overflow-y-auto px-4 py-3">+ <TabsContent value="details">+ <SecretDetailsTab secret={selectedSecret} providerConfigs={providerConfigs} />+ </TabsContent>+ <TabsContent value="usage">+ <SecretUsageTab loading={usageQuery.isPending} bindings={usageQuery.data?.bindings ?? []} />+ </TabsContent>+ <TabsContent value="events">+ <SecretEventsTab loading={eventsQuery.isPending} events={eventsQuery.data ?? []} />+ </TabsContent>+ </div>+ </Tabs>+ </>+ ) : null}+ </SheetContent>+ </Sheet>++ <Dialog+ open={Boolean(usageDialogSecret)}+ onOpenChange={(open) => !open && setUsageDialogSecretId(null)}+ >+ <DialogContent className="sm:max-w-lg">+ <DialogHeader>+ <DialogTitle>Secret references</DialogTitle>+ <DialogDescription>+ {usageDialogSecret+ ? `${usageDialogSecret.name} is referenced by ${usageDialogSecret.referenceCount ?? 0} ${+ (usageDialogSecret.referenceCount ?? 0) === 1 ? "place" : "places"+ }.`+ : null}+ </DialogDescription>+ </DialogHeader>+ <SecretUsageTab+ loading={usageDialogQuery.isPending}+ bindings={usageDialogQuery.data?.bindings ?? []}+ />+ </DialogContent>+ </Dialog>++ {selectedCompanyId && (+ <ImportFromVaultDialog+ open={importOpen}+ onOpenChange={setImportOpen}+ companyId={selectedCompanyId}+ providerConfigs={providerConfigs}+ existingSecrets={secrets}+ onManageVaults={() => {+ setImportOpen(false);+ setActiveTab("vaults");+ }}+ onImportComplete={() => {+ void secretsQuery.refetch();+ }}+ />+ )}++ <Dialog open={createOpen} onOpenChange={setCreateOpen}>+ <DialogContent className="sm:max-w-lg">+ <DialogHeader>+ <DialogTitle>Create secret</DialogTitle>+ <DialogDescription>+ Choose whether Paperclip should own future provider writes, or only resolve an existing+ provider reference at runtime.+ </DialogDescription>+ </DialogHeader>+ <Tabs value={createMode} onValueChange={(value) => setCreateMode(value as CreateMode)}>+ <TabsList className="w-full grid grid-cols-2">+ <TabsTrigger value="managed">Managed value</TabsTrigger>+ <TabsTrigger value="external">External reference</TabsTrigger>+ </TabsList>+ </Tabs>+ <div className="space-y-3">+ <div className="grid grid-cols-2 gap-3">+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-name">Name</label>+ <Input+ id="new-secret-name"+ value={createForm.name}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, name: event.target.value }))+ }+ placeholder="OPENAI_API_KEY"+ autoFocus+ />+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-key">+ Key <span className="text-muted-foreground/70">(optional)</span>+ </label>+ <Input+ id="new-secret-key"+ value={createForm.key}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, key: event.target.value }))+ }+ placeholder="auto from name"+ />+ </div>+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-provider">Provider</label>+ <select+ id="new-secret-provider"+ className="h-9 w-full rounded-md border border-border bg-background px-2 text-sm outline-none"+ value={createForm.provider}+ onChange={(event) =>+ setCreateForm((current) => {+ const provider = event.target.value as SecretProvider;+ return {+ ...current,+ provider,+ providerConfigId: getDefaultProviderConfigId(providerConfigs, provider),+ };+ })+ }+ >+ {providers.map((provider) => (+ <option+ key={provider.id}+ value={provider.id}+ disabled={Boolean(+ getCreateProviderBlockReason(provider, createMode, providerHealthQuery.data ?? null),+ )}+ >+ {provider.label}+ {provider.configured === false+ ? " (not configured)"+ : provider.requiresExternalRef+ ? " (external only)"+ : ""}+ </option>+ ))}+ </select>+ {createProviderBlockReason ? (+ <p className="mt-1 flex items-center gap-1 text-[11px] text-destructive">+ <AlertCircle className="h-3 w-3" />+ {createProviderBlockReason}+ </p>+ ) : createProviderHealthText ? (+ <p className="mt-1 text-[11px] text-muted-foreground">{createProviderHealthText}</p>+ ) : null}+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-vault">Provider vault</label>+ <select+ id="new-secret-vault"+ className="h-9 w-full rounded-md border border-border bg-background px-2 text-sm outline-none"+ value={createForm.providerConfigId}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, providerConfigId: event.target.value }))+ }+ >+ <option value="">Deployment default</option>+ {createProviderConfigs.map((config) => {+ const blockReason = getProviderConfigBlockReason(config);+ return (+ <option key={config.id} value={config.id} disabled={Boolean(blockReason)}>+ {config.displayName}+ {config.isDefault ? " (default)" : ""}+ {blockReason ? ` (${blockReason})` : ""}+ </option>+ );+ })}+ </select>+ {selectedCreateProviderConfig ? (+ <ProviderVaultInlineWarning config={selectedCreateProviderConfig} />+ ) : (+ <p className="mt-1 text-[11px] text-muted-foreground">+ Existing deployment-level provider settings stay available for backwards compatibility.+ </p>+ )}+ </div>+ {createMode === "managed" ? (+ <>+ <div className="rounded-md border border-emerald-500/30 bg-emerald-500/5 p-2 text-[11px] text-emerald-700 dark:text-emerald-300">+ Paperclip-managed secrets are created in the selected provider and future rotations+ write a new provider version through Paperclip.+ {awsManagedPathPreview ? (+ <div className="mt-1">+ AWS managed path:{" "}+ <code className="break-all rounded bg-background/70 px-1 py-0.5">+ {awsManagedPathPreview}+ </code>+ </div>+ ) : null}+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-value">Value</label>+ <Textarea+ id="new-secret-value"+ value={createForm.value}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, value: event.target.value }))+ }+ rows={3}+ className="font-mono text-xs"+ placeholder="Stored once, never re-displayed"+ />+ </div>+ </>+ ) : (+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-ref">External reference</label>+ <Input+ id="new-secret-ref"+ value={createForm.externalRef}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, externalRef: event.target.value }))+ }+ placeholder="arn:aws:secretsmanager:..."+ className="font-mono text-xs"+ />+ <p className="text-[11px] text-muted-foreground mt-1">+ Existing provider secrets are resolve-only in Paperclip. Rotate the value in the provider,+ then update this reference only if the path, ARN, or version changes.+ </p>+ </div>+ )}+ <div>+ <label className="text-xs font-medium" htmlFor="new-secret-description">+ Description <span className="text-muted-foreground/70">(optional)</span>+ </label>+ <Input+ id="new-secret-description"+ value={createForm.description}+ onChange={(event) =>+ setCreateForm((current) => ({ ...current, description: event.target.value }))+ }+ placeholder="What is this secret used for? (no values)"+ />+ </div>+ {createError ? <p className="text-xs text-destructive">{createError}</p> : null}+ </div>+ <DialogFooter>+ <Button variant="outline" onClick={() => setCreateOpen(false)}>+ Cancel+ </Button>+ <Button+ onClick={() => {+ setCreateError(null);+ createMutation.mutate();+ }}+ disabled={+ createMutation.isPending ||+ Boolean(createProviderBlockReason) ||+ !createForm.name.trim() ||+ (createMode === "managed" ? !createForm.value : !createForm.externalRef.trim())+ }+ >+ {createMutation.isPending ? <Loader2 className="h-3.5 w-3.5 animate-spin mr-1" /> : null}+ {createMode === "managed" ? "Create secret" : "Link reference"}+ </Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>++ <Dialog open={vaultDialogOpen} onOpenChange={setVaultDialogOpen}>+ <DialogContent className="max-h-[85vh] overflow-y-auto sm:max-w-2xl">+ <DialogHeader>+ <DialogTitle>{editingVault ? "Edit provider vault" : "Create provider vault"}</DialogTitle>+ <DialogDescription>+ Save only non-sensitive routing metadata. Credentials stay in the runtime environment or provider identity.+ </DialogDescription>+ </DialogHeader>+ <div className="space-y-4">+ <div className="grid gap-3 sm:grid-cols-2">+ <div>+ <label className="text-xs font-medium" htmlFor="vault-provider">Provider</label>+ <select+ id="vault-provider"+ className="h-9 w-full rounded-md border border-border bg-background px-2 text-sm outline-none disabled:opacity-60"+ value={vaultForm.provider}+ disabled={Boolean(editingVault)}+ onChange={(event) => {+ const provider = event.target.value as SecretProvider;+ setVaultForm(emptyProviderVaultForm(provider));+ }}+ >+ {PROVIDER_ORDER.map((provider) => (+ <option key={provider} value={provider}>+ {providerLabel(providers, provider)}+ </option>+ ))}+ </select>+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="vault-name">Display name</label>+ <Input+ id="vault-name"+ value={vaultForm.displayName}+ onChange={(event) =>+ setVaultForm((current) => ({ ...current, displayName: event.target.value }))+ }+ placeholder="Production local vault"+ />+ </div>+ <div>+ <label className="text-xs font-medium" htmlFor="vault-status">Status</label>+ <select+ id="vault-status"+ className="h-9 w-full rounded-md border border-border bg-background px-2 text-sm outline-none"+ value={vaultForm.status}+ onChange={(event) => {+ const status = event.target.value as SecretProviderConfigStatus;+ setVaultForm((current) => ({+ ...current,+ status,+ isDefault:+ status === "coming_soon" || status === "disabled" ? false : current.isDefault,+ }));+ }}+ >+ <option value="ready" disabled={vaultForm.provider === "gcp_secret_manager" || vaultForm.provider === "vault"}>+ Ready+ </option>+ <option value="warning" disabled={vaultForm.provider === "gcp_secret_manager" || vaultForm.provider === "vault"}>+ Warning+ </option>+ <option value="coming_soon">Coming soon</option>+ <option value="disabled">Disabled</option>+ </select>+ </div>+ <label className="flex items-center gap-2 pt-6 text-sm">+ <input+ type="checkbox"+ className="h-4 w-4 rounded border-border"+ checked={vaultForm.isDefault}+ disabled={vaultForm.status === "coming_soon" || vaultForm.status === "disabled"}+ onChange={(event) =>+ setVaultForm((current) => ({ ...current, isDefault: event.target.checked }))+ }+ />+ Default for {providerLabel(providers, vaultForm.provider)}+ </label>+ </div>++ <ProviderVaultFields form={vaultForm} onChange={setVaultForm} />++ {vaultForm.provider === "gcp_secret_manager" || vaultForm.provider === "vault" ? (+ <div className="rounded-md border border-sky-500/30 bg-sky-500/5 p-3 text-xs text-sky-700 dark:text-sky-300">+ This provider can save draft routing metadata, but runtime writes and resolution stay disabled until+ the provider module is implemented and reviewed.+ </div>+ ) : null}+ {vaultError ? <p className="text-xs text-destructive">{vaultError}</p> : null}+ </div>+ <DialogFooter>+ <Button variant="outline" onClick={() => setVaultDialogOpen(false)}>+ Cancel+ </Button>+ <Button+ onClick={() => {+ setVaultError(null);+ saveVaultMutation.mutate();+ }}+ disabled={+ saveVaultMutation.isPending ||+ !vaultForm.displayName.trim() ||+ (vaultForm.provider === "aws_secrets_manager" && !vaultForm.region.trim())+ }+ >+ {saveVaultMutation.isPending ? <Loader2 className="h-3.5 w-3.5 animate-spin mr-1" /> : null}+ {editingVault ? "Save vault" : "Create vault"}+ </Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>++ <Dialog open={rotateOpen} onOpenChange={setRotateOpen}>+ <DialogContent className="sm:max-w-md">+ <DialogHeader>+ <DialogTitle>+ {selectedSecret?.managedMode === "external_reference" ? "Update external reference" : "Update secret value"}+ </DialogTitle>+ <DialogDescription>+ {selectedSecret?.managedMode === "external_reference"+ ? "Creates a new Paperclip metadata version that points at an existing provider secret. Paperclip does not write a new provider value."+ : "Creates a new provider-backed version. Consumers pinned to latest pick up the new value on the next run."}+ </DialogDescription>+ </DialogHeader>+ <div>+ <label className="text-xs font-medium" htmlFor="rotate-secret-vault">Provider vault</label>+ <select+ id="rotate-secret-vault"+ className="h-9 w-full rounded-md border border-border bg-background px-2 text-sm outline-none"+ value={rotateProviderConfigId}+ onChange={(event) => setRotateProviderConfigId(event.target.value)}+ >+ <option value="">Deployment default</option>+ {selectedRotateProviderConfigs.map((config) => {+ const blockReason = getProviderConfigBlockReason(config);+ return (+ <option key={config.id} value={config.id} disabled={Boolean(blockReason)}>+ {config.displayName}+ {config.isDefault ? " (default)" : ""}+ {blockReason ? ` (${blockReason})` : ""}+ </option>+ );+ })}+ </select>+ {selectedRotateProviderConfig ? (+ <ProviderVaultInlineWarning config={selectedRotateProviderConfig} />+ ) : (+ <p className="mt-1 text-[11px] text-muted-foreground">+ Rotating with the deployment default preserves current fallback behavior.+ </p>+ )}+ </div>+ {selectedSecret?.managedMode === "external_reference" ? (+ <div>+ <label className="text-xs font-medium" htmlFor="rotate-ref">External reference</label>+ <Input+ id="rotate-ref"+ value={rotateExternalRef}+ onChange={(event) => setRotateExternalRef(event.target.value)}+ placeholder={selectedSecret.externalRef ?? "Updated reference"}+ className="font-mono text-xs"+ />+ <p className="mt-1 text-[11px] text-muted-foreground">+ Rotate the actual value in the provider before changing this Paperclip reference.+ </p>+ </div>+ ) : (+ <div>+ <label className="text-xs font-medium" htmlFor="rotate-value">New value</label>+ <Textarea+ id="rotate-value"+ value={rotateValue}+ onChange={(event) => setRotateValue(event.target.value)}+ rows={3}+ className="font-mono text-xs"+ placeholder="Paste the new value"+ />+ </div>+ )}+ {rotateError ? <p className="text-xs text-destructive">{rotateError}</p> : null}+ <DialogFooter>+ <Button variant="outline" onClick={() => setRotateOpen(false)}>+ Cancel+ </Button>+ <Button+ onClick={() => {+ setRotateError(null);+ rotateMutation.mutate();+ }}+ disabled={+ rotateMutation.isPending ||+ Boolean(rotateProviderBlockReason) ||+ (selectedSecret?.managedMode === "external_reference"+ ? !rotateExternalRef.trim() && !selectedSecret?.externalRef+ : !rotateValue)+ }+ >+ {rotateMutation.isPending ? <Loader2 className="h-3.5 w-3.5 animate-spin mr-1" /> : null}+ {selectedSecret?.managedMode === "external_reference" ? "Update reference" : "Update value"}+ </Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>++ <Dialog open={Boolean(deleteConfirm)} onOpenChange={(open) => !open && setDeleteConfirm(null)}>+ <DialogContent className="sm:max-w-md">+ <DialogHeader>+ <DialogTitle>Delete secret</DialogTitle>+ <DialogDescription>+ Permanently removes <strong>{deleteConfirm?.name}</strong>. Active bindings will fail until you remap them.+ </DialogDescription>+ </DialogHeader>+ <DialogFooter>+ <Button variant="outline" onClick={() => setDeleteConfirm(null)}>Cancel</Button>+ <Button+ variant="destructive"+ onClick={() => deleteConfirm && deleteMutation.mutate(deleteConfirm.id)}+ disabled={deleteMutation.isPending}+ >+ {deleteMutation.isPending ? <Loader2 className="h-3.5 w-3.5 animate-spin mr-1" /> : null}+ Delete+ </Button>+ </DialogFooter>+ </DialogContent>+ </Dialog>+ </div>+ );+}++function SecretsHowToUse() {+ return (+ <div className="flex items-start gap-2 rounded-md border border-border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">+ <Info className="mt-0.5 h-3.5 w-3.5 shrink-0" />+ <div className="space-y-1">+ <p className="font-medium text-foreground">Use secrets by binding them to runtime environment variables.</p>+ <p>+ Create or link a secret here, then open an agent's Environment variables or a project's Env field.+ Add the env key the process expects, for example <code className="font-mono">GH_TOKEN</code>, choose{" "}+ <span className="font-medium text-foreground">Secret</span>, and select the stored secret version.+ </p>+ <p>+ Paperclip resolves the value server-side when the run starts and injects it as that env var. Project env+ applies to every issue in the project and overrides agent env on matching keys.+ </p>+ </div>+ </div>+ );+}++function SecretsFiltersPopover({+ statusFilter,+ providerFilter,+ providers,+ activeFilterCount,+ onStatusChange,+ onProviderChange,+}: {+ statusFilter: SecretStatus | "all";+ providerFilter: SecretProvider | "all";+ providers: SecretProviderDescriptor[];+ activeFilterCount: number;+ onStatusChange: (value: SecretStatus | "all") => void;+ onProviderChange: (value: SecretProvider | "all") => void;+}) {+ const resetFilters = () => {+ onStatusChange("active");+ onProviderChange("all");+ };++ const statusOptions: Array<{ value: SecretStatus | "all"; label: string }> = [+ { value: "active", label: "Active" },+ { value: "all", label: "All statuses" },+ { value: "disabled", label: "Disabled" },+ { value: "archived", label: "Archived" },+ ];++ return (+ <Popover>+ <PopoverTrigger asChild>+ <Button+ variant="outline"+ size="icon"+ className={cn("relative h-8 w-8 shrink-0", activeFilterCount > 0 && "text-blue-600 dark:text-blue-400")}+ title={activeFilterCount > 0 ? `Filters: ${activeFilterCount}` : "Filter"}+ >+ <Filter className="h-3.5 w-3.5" />+ {activeFilterCount > 0 ? (+ <span className="absolute -right-1 -top-1 flex h-3.5 w-3.5 items-center justify-center rounded-full bg-blue-600 text-[9px] font-bold text-white">+ {activeFilterCount}+ </span>+ ) : null}+ </Button>+ </PopoverTrigger>+ <PopoverContent+ align="end"+ className="w-[min(520px,calc(100vw-2rem))] max-h-[min(80vh,34rem)] overflow-y-auto overscroll-contain p-0"+ >+ <div className="space-y-3 p-3">+ <div className="flex items-center justify-between">+ <span className="text-sm font-medium">Filters</span>+ {activeFilterCount > 0 ? (+ <button+ type="button"+ className="inline-flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground"+ onClick={resetFilters}+ >+ <X className="h-3 w-3" />+ Clear+ </button>+ ) : null}+ </div>++ <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">+ <div className="space-y-1">+ <span className="text-xs text-muted-foreground">Status</span>+ <div className="space-y-0.5">+ {statusOptions.map((option) => (+ <label key={option.value} className="flex cursor-pointer items-center gap-2 rounded-sm px-2 py-1 hover:bg-accent/50">+ <Checkbox+ checked={statusFilter === option.value}+ onCheckedChange={() => onStatusChange(option.value)}+ />+ <span className="text-sm">{option.label}</span>+ </label>+ ))}+ </div>+ </div>++ <div className="space-y-1">+ <span className="text-xs text-muted-foreground">Provider</span>+ <div className="max-h-48 space-y-0.5 overflow-y-auto pr-1">+ <label className="flex cursor-pointer items-center gap-2 rounded-sm px-2 py-1 hover:bg-accent/50">+ <Checkbox+ checked={providerFilter === "all"}+ onCheckedChange={() => onProviderChange("all")}+ />+ <span className="text-sm">All providers</span>+ </label>+ {providers.map((provider) => (+ <label key={provider.id} className="flex cursor-pointer items-center gap-2 rounded-sm px-2 py-1 hover:bg-accent/50">+ <Checkbox+ checked={providerFilter === provider.id}+ onCheckedChange={() => onProviderChange(provider.id)}+ />+ <span className="text-sm">{provider.label}</span>+ </label>+ ))}+ </div>+ </div>+ </div>+ </div>+ </PopoverContent>+ </Popover>+ );+}++function providerConfigStatusTone(status: SecretProviderConfigStatus) {+ switch (status) {+ case "ready":+ return "border-emerald-500/30 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300";+ case "warning":+ return "border-amber-500/30 bg-amber-500/10 text-amber-700 dark:text-amber-300";+ case "coming_soon":+ return "border-sky-500/30 bg-sky-500/10 text-sky-700 dark:text-sky-300";+ case "disabled":+ return "border-muted bg-muted text-muted-foreground";+ default:+ return "border-border bg-muted text-muted-foreground";+ }+}++function providerFamilyIcon(provider: SecretProvider) {+ switch (provider) {+ case "local_encrypted":+ return Database;+ case "aws_secrets_manager":+ return Cloud;+ case "gcp_secret_manager":+ return ShieldCheck;+ case "vault":+ return KeyRound;+ default:+ return KeyRound;+ }+}++function ProviderVaultInlineWarning({ config }: { config: CompanySecretProviderConfig }) {+ const blockReason = getProviderConfigBlockReason(config);+ const message = blockReason ?? config.healthMessage;+ if (!message) {+ return (+ <p className="mt-1 text-[11px] text-muted-foreground">+ {config.isDefault ? "Default vault" : "Vault"} · {config.status.replace("_", " ")}+ </p>+ );+ }+ const warning = config.status === "warning" || config.healthStatus === "warning";+ return (+ <p className={cn("mt-1 flex items-center gap-1 text-[11px]", warning ? "text-amber-600 dark:text-amber-400" : "text-destructive")}>+ {warning ? <AlertTriangle className="h-3 w-3" /> : <AlertCircle className="h-3 w-3" />}+ {message}+ </p>+ );+}++interface ImportFromVaultButtonProps {+ providerConfigs: CompanySecretProviderConfig[];+ onClick: () => void;+ onManageVaults: () => void;+ className?: string;+}++function ImportFromVaultButton({+ providerConfigs,+ onClick,+ onManageVaults,+ className,+}: ImportFromVaultButtonProps) {+ const awsConfigs = providerConfigs.filter(+ (config) => config.provider === "aws_secrets_manager",+ );+ const eligible = awsConfigs.filter(+ (config) => config.status === "ready" || config.status === "warning",+ );++ if (awsConfigs.length === 0) return null;++ if (eligible.length === 0) {+ return (+ <Button+ variant="ghost"+ size="sm"+ onClick={onManageVaults}+ className={cn("text-xs text-muted-foreground", className)}+ title="Configure an AWS provider vault to enable remote import"+ >+ <Cloud className="h-3.5 w-3.5 mr-1" /> AWS vault disabled — manage+ </Button>+ );+ }++ return (+ <Button+ variant="outline"+ size="sm"+ onClick={onClick}+ className={className}+ data-testid="import-from-vault-button"+ >+ <Cloud className="h-3.5 w-3.5 mr-1" /> Import from vault+ </Button>+ );+}++export function ProviderVaultsTab({+ providers,+ providerConfigs,+ loading,+ error,+ onRetry,+ onCreate,+ onEdit,+ onDisable,+ onSetDefault,+ onHealthCheck,+ pendingActionId,+}: {+ providers: SecretProviderDescriptor[];+ providerConfigs: CompanySecretProviderConfig[];+ loading: boolean;+ error: unknown;+ onRetry: () => void;+ onCreate: (provider: SecretProvider) => void;+ onEdit: (config: CompanySecretProviderConfig) => void;+ onDisable: (config: CompanySecretProviderConfig) => void;+ onSetDefault: (config: CompanySecretProviderConfig) => void;+ onHealthCheck: (config: CompanySecretProviderConfig) => void;+ pendingActionId: string | null;+}) {+ if (loading) {+ return (+ <div className="flex items-center gap-2 py-4 text-sm text-muted-foreground">+ <Loader2 className="h-4 w-4 animate-spin" />+ Loading provider vaults+ </div>+ );+ }++ if (error) {+ return (+ <div className="py-4 text-sm text-destructive flex items-center gap-2">+ <AlertCircle className="h-4 w-4" /> Failed to load provider vaults: {(error as Error).message}+ <Button variant="ghost" size="sm" onClick={onRetry}>+ Retry+ </Button>+ </div>+ );+ }++ const providerMap = new Map(providers.map((provider) => [provider.id, provider]));+ const providerRows = PROVIDER_ORDER.map((providerId) => ({+ id: providerId,+ provider: providerMap.get(providerId),+ Icon: providerFamilyIcon(providerId),+ isComingSoonFamily: providerId === "gcp_secret_manager" || providerId === "vault",+ configs: providerConfigs.filter((config) => config.provider === providerId),+ }));++ return (+ <div className="flex min-h-full gap-6">+ <aside className="hidden w-56 shrink-0 md:block">+ <nav className="sticky top-0 space-y-1">+ {providerRows.map(({ id, provider, Icon }) => (+ <a+ key={id}+ href={`#provider-vaults-${id}`}+ className="flex items-center gap-2 rounded-md px-2 py-1.5 text-sm text-muted-foreground hover:bg-accent/50 hover:text-foreground"+ >+ <Icon className="h-4 w-4" />+ <span className="truncate">{provider?.label ?? id.replaceAll("_", " ")}</span>+ </a>+ ))}+ </nav>+ </aside>++ <div className="min-w-0 flex-1 space-y-6">+ {providerRows.map(({ id, provider, Icon, isComingSoonFamily, configs }) => (+ <section key={id} id={`provider-vaults-${id}`} className={cn("scroll-mt-6 space-y-2", isComingSoonFamily && "opacity-50")}>+ <div className="flex flex-wrap items-center gap-2">+ <Icon className="h-4 w-4 text-muted-foreground" />+ <h2 className="text-sm font-semibold">{provider?.label ?? id.replaceAll("_", " ")}</h2>+ {isComingSoonFamily ? (+ <span className="ml-auto text-xs text-muted-foreground">Coming soon</span>+ ) : (+ <Button variant="outline" size="sm" className="ml-auto" onClick={() => onCreate(id)}>+ <Plus className="h-3.5 w-3.5 mr-1" />+ Add vault+ </Button>+ )}+ </div>+ {configs.length === 0 ? (+ <div className="rounded-md border border-dashed border-border bg-muted/20 p-4 text-sm text-muted-foreground">+ {isComingSoonFamily+ ? "Not yet supported."+ : "No company-specific vaults yet. Secrets can still use the deployment default provider settings."}+ </div>+ ) : (+ <div className="space-y-3">+ {configs.map((config) => (+ <ProviderVaultCard+ key={config.id}+ config={config}+ pending={pendingActionId === config.id}+ onEdit={() => onEdit(config)}+ onDisable={() => onDisable(config)}+ onSetDefault={() => onSetDefault(config)}+ onHealthCheck={() => onHealthCheck(config)}+ />+ ))}+ </div>+ )}+ </section>+ ))}+ </div>+ </div>+ );+}++function ProviderVaultCard({+ config,+ pending,+ onEdit,+ onDisable,+ onSetDefault,+ onHealthCheck,+}: {+ config: CompanySecretProviderConfig;+ pending: boolean;+ onEdit: () => void;+ onDisable: () => void;+ onSetDefault: () => void;+ onHealthCheck: () => void;+}) {+ const blockReason = getProviderConfigBlockReason(config);+ const details = config.healthDetails;+ return (+ <div className="rounded-md border border-border bg-background p-4">+ <div className="flex items-start gap-3">+ <div className="min-w-0 flex-1">+ <div className="flex flex-wrap items-center gap-2">+ <h3 className="text-sm font-medium leading-snug">{config.displayName}</h3>+ {config.isDefault ? (+ <span className="inline-flex items-center gap-1 text-xs text-amber-600 dark:text-amber-400">+ <Star className="h-3 w-3 fill-current" />+ Default+ </span>+ ) : null}+ </div>+ <div className="mt-1 flex flex-wrap items-center gap-2">+ <Badge variant="outline" className={cn("font-medium", providerConfigStatusTone(config.status))}>+ {config.status.replace("_", " ")}+ </Badge>+ {config.healthStatus ? (+ <span className="text-xs text-muted-foreground">+ Health {config.healthStatus.replace("_", " ")} · {formatRelative(config.healthCheckedAt)}+ </span>+ ) : (+ <span className="text-xs text-muted-foreground">Health not checked</span>+ )}+ </div>+ </div>+ <Button variant="ghost" size="sm" onClick={onEdit}>+ <Edit3 className="h-3.5 w-3.5" />+ </Button>+ </div>+ {config.healthMessage || blockReason ? (+ <div className={cn("mt-3 rounded-md p-2 text-xs", blockReason ? "bg-destructive/5 text-destructive" : "bg-muted/40 text-muted-foreground")}>+ {blockReason ?? config.healthMessage}+ {details?.guidance?.length ? (+ <ul className="mt-1 list-disc space-y-0.5 pl-4">+ {details.guidance.map((item) => (+ <li key={item}>{item}</li>+ ))}+ </ul>+ ) : null}+ </div>+ ) : null}+ <div className="mt-3 flex flex-wrap gap-2">+ <Button variant="outline" size="sm" onClick={onHealthCheck} disabled={pending}>+ {pending ? <Loader2 className="h-3.5 w-3.5 animate-spin mr-1" /> : <RefreshCw className="h-3.5 w-3.5 mr-1" />}+ Check health+ </Button>+ <Button+ variant="outline"+ size="sm"+ onClick={onSetDefault}+ disabled={pending || Boolean(blockReason) || config.isDefault}+ >+ <Star className="h-3.5 w-3.5 mr-1" />+ Make default+ </Button>+ <Button+ variant="outline"+ size="sm"+ className="text-destructive hover:text-destructive"+ onClick={onDisable}+ disabled={pending || config.status === "disabled"}+ >+ <Ban className="h-3.5 w-3.5 mr-1" />+ Disable+ </Button>+ </div>+ </div>+ );+}++function ProviderVaultFields({+ form,+ onChange,+}: {+ form: ProviderVaultForm;+ onChange: React.Dispatch<React.SetStateAction<ProviderVaultForm>>;+}) {+ const setField = (key: keyof ProviderVaultForm, value: string | boolean) => {+ onChange((current) => ({ ...current, [key]: value }));+ };++ if (form.provider === "local_encrypted") {+ return (+ <label className="flex items-start gap-2 rounded-md border border-border bg-muted/20 p-3 text-sm">+ <input+ type="checkbox"+ className="mt-0.5 h-4 w-4 rounded border-border"+ checked={form.backupReminderAcknowledged}+ onChange={(event) => setField("backupReminderAcknowledged", event.target.checked)}+ />+ <span>+ I understand backup and restore require both the database metadata and the local encrypted master key file.+ </span>+ </label>+ );+ }++ if (form.provider === "aws_secrets_manager") {+ return (+ <div className="grid gap-3 sm:grid-cols-2">+ <TextField label="AWS region" value={form.region} onChange={(value) => setField("region", value)} placeholder="us-east-1" required />+ <TextField label="Namespace" value={form.namespace} onChange={(value) => setField("namespace", value)} placeholder="production" />+ <TextField label="Secret name prefix" value={form.secretNamePrefix} onChange={(value) => setField("secretNamePrefix", value)} placeholder="paperclip" />+ <TextField label="KMS key id" value={form.kmsKeyId} onChange={(value) => setField("kmsKeyId", value)} placeholder="alias/paperclip-secrets" />+ <TextField label="Owner tag" value={form.ownerTag} onChange={(value) => setField("ownerTag", value)} placeholder="platform" />+ <TextField label="Environment tag" value={form.environmentTag} onChange={(value) => setField("environmentTag", value)} placeholder="prod" />+ </div>+ );+ }++ if (form.provider === "gcp_secret_manager") {+ return (+ <div className="grid gap-3 sm:grid-cols-2">+ <TextField label="Project id" value={form.projectId} onChange={(value) => setField("projectId", value)} placeholder="paperclip-prod" />+ <TextField label="Location" value={form.location} onChange={(value) => setField("location", value)} placeholder="global" />+ <TextField label="Namespace" value={form.namespace} onChange={(value) => setField("namespace", value)} placeholder="production" />+ <TextField label="Secret name prefix" value={form.secretNamePrefix} onChange={(value) => setField("secretNamePrefix", value)} placeholder="paperclip" />+ </div>+ );+ }++ return (+ <div className="grid gap-3 sm:grid-cols-2">+ <TextField label="Address" value={form.address} onChange={(value) => setField("address", value)} placeholder="https://vault.example.com" />+ <TextField label="Namespace" value={form.namespace} onChange={(value) => setField("namespace", value)} placeholder="admin" />+ <TextField label="Mount path" value={form.mountPath} onChange={(value) => setField("mountPath", value)} placeholder="secret" />+ <TextField label="Secret path prefix" value={form.secretPathPrefix} onChange={(value) => setField("secretPathPrefix", value)} placeholder="paperclip/prod" />+ </div>+ );+}++function TextField({+ label,+ value,+ onChange,+ placeholder,+ required,+}: {+ label: string;+ value: string;+ onChange: (value: string) => void;+ placeholder?: string;+ required?: boolean;+}) {+ const id = `provider-vault-${label.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;+ return (+ <div>+ <label className="text-xs font-medium" htmlFor={id}>+ {label}+ {required ? null : <span className="text-muted-foreground/70"> (optional)</span>}+ </label>+ <Input id={id} value={value} onChange={(event) => onChange(event.target.value)} placeholder={placeholder} />+ </div>+ );+}++function SecretDetailsTab({+ secret,+ providerConfigs,+}: {+ secret: CompanySecret;+ providerConfigs: CompanySecretProviderConfig[];+}) {+ return (+ <dl className="grid grid-cols-2 gap-x-4 gap-y-3 text-xs">+ <DetailRow label="Description">+ <span>{secret.description ?? <span className="text-muted-foreground">—</span>}</span>+ </DetailRow>+ <DetailRow label="Custody">{modeLabel(secret.managedMode)}</DetailRow>+ <DetailRow label="Provider">{secret.provider.replaceAll("_", " ")}</DetailRow>+ <DetailRow label="Provider vault">{providerVaultLabel(providerConfigs, secret.providerConfigId)}</DetailRow>+ <DetailRow label="Latest version">v{secret.latestVersion}</DetailRow>+ <DetailRow label="Created">{formatRelative(secret.createdAt)}</DetailRow>+ <DetailRow label="Updated">{formatRelative(secret.updatedAt)}</DetailRow>+ <DetailRow label="Last rotated">{formatRelative(secret.lastRotatedAt)}</DetailRow>+ <DetailRow label="Last resolved">{formatRelative(secret.lastResolvedAt)}</DetailRow>+ {secret.externalRef ? (+ <div className="col-span-2">+ <dt className="text-[11px] uppercase tracking-wide text-muted-foreground mb-1">+ {secret.managedMode === "external_reference" ? "Linked provider reference" : "Provider-managed path"}+ </dt>+ <dd className="font-mono text-xs break-all flex items-center gap-1">+ <ExternalLink className="h-3 w-3" /> {secret.externalRef}+ </dd>+ </div>+ ) : null}+ <div className="col-span-2 rounded-md border border-amber-500/30 bg-amber-500/5 p-2 text-[11px] text-amber-700 dark:text-amber-300">+ {modeDescription(secret.managedMode)} Paperclip never re-displays stored values.+ </div>+ </dl>+ );+}++function DetailRow({ label, children }: { label: string; children: React.ReactNode }) {+ return (+ <div>+ <dt className="text-[11px] uppercase tracking-wide text-muted-foreground">{label}</dt>+ <dd className="text-foreground">{children}</dd>+ </div>+ );+}++function SecretUsageTab({ loading, bindings }: { loading: boolean; bindings: CompanySecretUsageBinding[] }) {+ if (loading) {+ return <div className="py-6 text-center text-xs text-muted-foreground">Loading…</div>;+ }+ if (bindings.length === 0) {+ return (+ <div className="py-6 text-center text-xs text-muted-foreground">+ No active bindings. Add this secret in agent, project, environment, or plugin config to start using it.+ </div>+ );+ }+ return (+ <div className="space-y-2">+ {bindings.map((binding) => (+ <div+ key={binding.id}+ className="rounded-md border border-border bg-muted/30 p-2 text-xs"+ >+ <div className="flex items-center justify-between gap-2">+ <span className="font-medium capitalize">{binding.target.type}</span>+ <span className="font-mono text-muted-foreground">v{binding.versionSelector}</span>+ </div>+ <div className="mt-0.5 flex min-w-0 items-center gap-2">+ {binding.target.href ? (+ <Link to={binding.target.href} className="truncate font-medium text-primary hover:underline">+ {binding.target.label}+ </Link>+ ) : (+ <span className="truncate font-medium">{binding.target.label}</span>+ )}+ {binding.target.status ? (+ <Badge variant="outline" className="h-5 px-1.5 text-[10px] font-normal">+ {binding.target.status.replaceAll("_", " ")}+ </Badge>+ ) : null}+ </div>+ <div className="font-mono text-[11px] text-muted-foreground break-all">+ {binding.targetId}+ </div>+ <div className="text-[11px] text-muted-foreground">+ {binding.configPath} {binding.required ? "· required" : "· optional"}+ </div>+ </div>+ ))}+ </div>+ );+}++function SecretEventsTab({ loading, events }: { loading: boolean; events: SecretAccessEvent[] }) {+ if (loading) {+ return <div className="py-6 text-center text-xs text-muted-foreground">Loading…</div>;+ }+ if (events.length === 0) {+ return (+ <div className="py-6 text-center text-xs text-muted-foreground">+ No access events recorded yet. Each runtime resolution writes a redacted entry here.+ </div>+ );+ }+ return (+ <div className="space-y-1.5">+ {events.map((event) => (+ <div key={event.id} className="rounded border border-border px-2 py-1.5 text-xs">+ <div className="flex items-center justify-between">+ <span className="capitalize">+ {event.consumerType} · {event.outcome}+ </span>+ <span className="text-[11px] text-muted-foreground">{formatRelative(event.createdAt)}</span>+ </div>+ <div className="font-mono text-[11px] text-muted-foreground break-all">+ {event.consumerId}+ </div>+ {event.errorCode ? (+ <div className="text-[11px] text-destructive">{event.errorCode}</div>+ ) : null}+ </div>+ ))}+ </div>+ );+}diff --git a/ui/src/pages/secrets/ImportFromVaultDialog.test.tsx b/ui/src/pages/secrets/ImportFromVaultDialog.test.tsxnew file mode 100644index 0000000000..ea869eab37--- /dev/null+++ b/ui/src/pages/secrets/ImportFromVaultDialog.test.tsx@@ -0,0 +1,820 @@+// @vitest-environment jsdom++import { act } from "react";+import { createRoot } from "react-dom/client";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import type {+ CompanySecret,+ CompanySecretProviderConfig,+ RemoteSecretImportCandidate,+ RemoteSecretImportPreviewResult,+ RemoteSecretImportResult,+} from "@paperclipai/shared";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { ApiError } from "../../api/client";++const mockSecretsApi = vi.hoisted(() => ({+ remoteImportPreview: vi.fn(),+ remoteImport: vi.fn(),+}));++const mockPushToast = vi.hoisted(() => vi.fn());++vi.mock("../../api/secrets", () => ({+ secretsApi: mockSecretsApi,+}));++vi.mock("../../context/ToastContext", () => ({+ useToastActions: () => ({+ pushToast: mockPushToast,+ dismissToast: vi.fn(),+ clearToasts: vi.fn(),+ }),+}));++// eslint-disable-next-line @typescript-eslint/no-explicit-any+(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;++import { ImportFromVaultDialog } from "./ImportFromVaultDialog";++const awsVault: CompanySecretProviderConfig = {+ id: "vault-aws",+ companyId: "company-1",+ provider: "aws_secrets_manager",+ displayName: "AWS production",+ status: "ready",+ isDefault: true,+ config: { region: "us-east-1" },+ healthStatus: null,+ healthCheckedAt: null,+ healthMessage: null,+ healthDetails: null,+ disabledAt: null,+ createdByAgentId: null,+ createdByUserId: null,+ createdAt: new Date(),+ updatedAt: new Date(),+};++function makeCandidate(+ overrides: Partial<RemoteSecretImportCandidate> = {},+): RemoteSecretImportCandidate {+ return {+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/foo-AbCdEf",+ remoteName: "prod/foo",+ name: "prod/foo",+ key: "prod-foo",+ providerVersionRef: null,+ providerMetadata: { name: "prod/foo" },+ status: "ready",+ importable: true,+ conflicts: [],+ ...overrides,+ };+}++function makePreview(+ candidates: RemoteSecretImportCandidate[],+ nextToken: string | null = null,+): RemoteSecretImportPreviewResult {+ return {+ providerConfigId: awsVault.id,+ provider: "aws_secrets_manager",+ nextToken,+ candidates,+ };+}++async function flush() {+ await act(async () => {+ await Promise.resolve();+ await new Promise((resolve) => window.setTimeout(resolve, 0));+ });+}++async function flushDebounce() {+ await act(async () => {+ await new Promise((resolve) => window.setTimeout(resolve, 300));+ });+}++function makeWrapper() {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false } },+ });+ return { queryClient };+}++describe("ImportFromVaultDialog", () => {+ let container: HTMLDivElement;++ beforeEach(() => {+ container = document.createElement("div");+ document.body.appendChild(container);+ });++ afterEach(() => {+ container.remove();+ document.body.innerHTML = "";+ vi.clearAllMocks();+ });++ it("loads candidates and selects rows, persisting through pagination", async () => {+ mockSecretsApi.remoteImportPreview+ .mockResolvedValueOnce(+ makePreview(+ [+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/stripe-ABC",+ remoteName: "prod/stripe",+ name: "prod/stripe",+ key: "prod-stripe",+ }),+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ",+ remoteName: "prod/openai",+ name: "prod/openai",+ key: "prod-openai",+ }),+ ],+ "page-2",+ ),+ )+ .mockResolvedValueOnce(+ makePreview(+ [+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/sendgrid-Q9",+ remoteName: "prod/sendgrid",+ name: "prod/sendgrid",+ key: "prod-sendgrid",+ }),+ ],+ null,+ ),+ );++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const tableBody = document.querySelector('[data-testid="vault-table-body"]');+ expect(tableBody).not.toBeNull();+ expect(document.body.textContent).toContain("prod/stripe");+ expect(document.body.textContent).toContain("prod/openai");++ // Select stripe via row click+ const stripeRow = document.querySelector(+ '[data-testid="vault-row-arn:aws:secretsmanager:us-east-1:1:secret:prod/stripe-ABC"]',+ ) as HTMLElement | null;+ expect(stripeRow).not.toBeNull();+ await act(async () => {+ stripeRow?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ await flush();+ expect(document.body.textContent).toContain("1 selected");++ // Load more page+ const loadMore = document.querySelector('[data-testid="vault-load-more"]') as HTMLButtonElement | null;+ expect(loadMore).not.toBeNull();+ await act(async () => {+ loadMore!.click();+ });+ await flush();+ await flush();++ expect(document.body.textContent).toContain("prod/sendgrid");+ // Selection persisted through pagination.+ expect(document.body.textContent).toContain("1 selected");++ await act(async () => {+ root.unmount();+ });+ });++ it("disables checkboxes for already-imported (duplicate) rows and shows a conflict badge for conflicts", async () => {+ mockSecretsApi.remoteImportPreview.mockResolvedValueOnce(+ makePreview([+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/sendgrid-Q9",+ remoteName: "prod/sendgrid",+ name: "prod/sendgrid",+ key: "prod-sendgrid",+ status: "duplicate",+ importable: false,+ conflicts: [+ { type: "exact_reference", message: "Already imported", existingSecretId: "secret-sg" },+ ],+ }),+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ",+ remoteName: "prod/openai",+ name: "prod/openai",+ key: "prod-openai",+ status: "conflict",+ importable: true,+ conflicts: [+ { type: "name", message: "Name already in use" },+ ],+ }),+ ]),+ );++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const duplicateRow = document.querySelector(+ '[data-testid="vault-row-arn:aws:secretsmanager:us-east-1:1:secret:prod/sendgrid-Q9"]',+ );+ expect(duplicateRow?.getAttribute("data-row-state")).toBe("duplicate");+ const duplicateCheckbox = duplicateRow?.querySelector(+ 'button[role="checkbox"]',+ ) as HTMLButtonElement | null;+ expect(duplicateCheckbox?.getAttribute("data-disabled")).not.toBeNull();++ expect(document.body.textContent).toContain("Conflict");+ expect(document.body.textContent).toContain("Name already in use");++ await act(async () => {+ root.unmount();+ });+ });++ it("blocks import when a review row collides with an existing Paperclip secret", async () => {+ const conflictCandidate = makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ",+ remoteName: "prod/openai",+ name: "OPENAI_API_KEY",+ key: "openai_api_key",+ status: "conflict",+ conflicts: [{ type: "key", message: "Key already in use" }],+ });+ mockSecretsApi.remoteImportPreview.mockResolvedValueOnce(+ makePreview([conflictCandidate]),+ );++ const existing: CompanySecret[] = [+ {+ id: "secret-existing",+ companyId: "company-1",+ key: "openai_api_key",+ name: "OPENAI_API_KEY",+ provider: "aws_secrets_manager",+ status: "active",+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:other-XYZ",+ providerConfigId: awsVault.id,+ providerMetadata: null,+ latestVersion: 1,+ description: null,+ lastResolvedAt: null,+ lastRotatedAt: null,+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: null,+ createdAt: new Date(),+ updatedAt: new Date(),+ },+ ];++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={existing}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ // Select the conflict row+ const row = document.querySelector(+ '[data-testid="vault-row-arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ"]',+ ) as HTMLElement | null;+ await act(async () => {+ row?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ await flush();++ // Click "Continue → Review" button.+ const continueBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.includes("Continue"),+ );+ expect(continueBtn).toBeTruthy();+ await act(async () => {+ continueBtn!.click();+ });+ await flush();++ // Review step: error message visible, Import button disabled.+ expect(document.body.textContent?.toLowerCase()).toContain("a paperclip secret already uses this");++ const importBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.startsWith("Import "),+ ) as HTMLButtonElement | undefined;+ expect(importBtn).toBeTruthy();+ expect(importBtn?.disabled).toBe(true);++ await act(async () => {+ root.unmount();+ });+ });++ it("requires lowercase operator-entered keys during review", async () => {+ const externalRef = "arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ";+ mockSecretsApi.remoteImportPreview.mockResolvedValueOnce(+ makePreview([+ makeCandidate({+ externalRef,+ remoteName: "prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ }),+ ]),+ );++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const row = document.querySelector(+ `[data-testid="vault-row-${externalRef}"]`,+ ) as HTMLElement | null;+ await act(async () => {+ row?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ await flush();++ const continueBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.includes("Continue"),+ );+ await act(async () => {+ continueBtn!.click();+ });+ await flush();++ const keyInput = document.querySelector(+ `[data-testid="review-key-${externalRef}"]`,+ ) as HTMLInputElement | null;+ const valueSetter = Object.getOwnPropertyDescriptor(+ window.HTMLInputElement.prototype,+ "value",+ )?.set;+ await act(async () => {+ valueSetter?.call(keyInput, "MY_KEY");+ keyInput!.dispatchEvent(new Event("input", { bubbles: true }));+ });+ await flush();++ expect(document.body.textContent).toContain("lowercase letters");+ const importBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.startsWith("Import "),+ ) as HTMLButtonElement | undefined;+ expect(importBtn?.disabled).toBe(true);++ await act(async () => {+ root.unmount();+ });+ });++ it("submits the operator-entered review description", async () => {+ const externalRef = "arn:aws:secretsmanager:us-east-1:1:secret:prod/openai-XYZ";+ mockSecretsApi.remoteImportPreview.mockResolvedValueOnce(+ makePreview([+ makeCandidate({+ externalRef,+ remoteName: "prod/openai",+ name: "OpenAI API key",+ key: "openai-api-key",+ providerMetadata: {+ description: "Raw AWS description should not seed the review field",+ },+ }),+ ]),+ );+ mockSecretsApi.remoteImport.mockResolvedValueOnce({+ providerConfigId: awsVault.id,+ provider: "aws_secrets_manager",+ importedCount: 1,+ skippedCount: 0,+ errorCount: 0,+ results: [+ {+ externalRef,+ name: "OpenAI API key",+ key: "openai-api-key",+ status: "imported",+ reason: null,+ secretId: "secret-openai",+ conflicts: [],+ },+ ],+ });++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const row = document.querySelector(+ `[data-testid="vault-row-${externalRef}"]`,+ ) as HTMLElement | null;+ await act(async () => {+ row?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ await flush();++ const continueBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.includes("Continue"),+ );+ await act(async () => {+ continueBtn!.click();+ });+ await flush();++ const descriptionInput = document.querySelector(+ `[data-testid="review-description-${externalRef}"]`,+ ) as HTMLInputElement | null;+ expect(descriptionInput?.value).toBe("");+ const valueSetter = Object.getOwnPropertyDescriptor(+ window.HTMLInputElement.prototype,+ "value",+ )?.set;+ await act(async () => {+ valueSetter?.call(descriptionInput, "Operator-entered OpenAI key");+ descriptionInput!.dispatchEvent(new Event("input", { bubbles: true }));+ });+ await flush();++ const importBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.startsWith("Import "),+ ) as HTMLButtonElement | undefined;+ await act(async () => {+ importBtn!.click();+ });+ await flush();+ await flush();++ expect(mockSecretsApi.remoteImport).toHaveBeenCalledWith("company-1", {+ providerConfigId: awsVault.id,+ secrets: [+ expect.objectContaining({+ externalRef,+ description: "Operator-entered OpenAI key",+ providerMetadata: null,+ }),+ ],+ });++ await act(async () => {+ root.unmount();+ });+ });++ it("renders mixed import results (created/skipped/failed) and shows error reason", async () => {+ mockSecretsApi.remoteImportPreview.mockResolvedValueOnce(+ makePreview([+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:a-AAA",+ remoteName: "alpha",+ name: "alpha",+ key: "alpha",+ }),+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:b-BBB",+ remoteName: "beta",+ name: "beta",+ key: "beta",+ }),+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:c-CCC",+ remoteName: "gamma",+ name: "gamma",+ key: "gamma",+ }),+ ]),+ );++ const result: RemoteSecretImportResult = {+ providerConfigId: awsVault.id,+ provider: "aws_secrets_manager",+ importedCount: 1,+ skippedCount: 1,+ errorCount: 1,+ results: [+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:a-AAA",+ name: "alpha",+ key: "alpha",+ status: "imported",+ reason: null,+ secretId: "secret-alpha",+ conflicts: [],+ },+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:b-BBB",+ name: "beta",+ key: "beta",+ status: "skipped",+ reason: "exact reference already imported",+ secretId: null,+ conflicts: [+ { type: "exact_reference", message: "exact reference already imported" },+ ],+ },+ {+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:c-CCC",+ name: "gamma",+ key: "gamma",+ status: "error",+ reason: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ secretId: null,+ conflicts: [],+ },+ ],+ };+ mockSecretsApi.remoteImport.mockResolvedValueOnce(result);++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ // Select all loaded+ const headerCheckbox = document.querySelector(+ '[data-testid="vault-table-body"]',+ )?.parentElement?.querySelector('thead button[role="checkbox"]') as HTMLButtonElement | null;+ expect(headerCheckbox).toBeTruthy();+ await act(async () => {+ headerCheckbox!.click();+ });+ await flush();++ // Continue+ const continueBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.includes("Continue"),+ );+ await act(async () => {+ continueBtn!.click();+ });+ await flush();++ // Import+ const importBtn = Array.from(document.querySelectorAll("button")).find(+ (btn) => btn.textContent?.startsWith("Import "),+ ) as HTMLButtonElement | undefined;+ expect(importBtn).toBeTruthy();+ await act(async () => {+ importBtn!.click();+ });+ await flush();+ await flush();++ expect(mockSecretsApi.remoteImport).toHaveBeenCalledTimes(1);+ expect(document.body.textContent).toContain("Import complete");+ expect(document.body.textContent).toContain("1 created");+ expect(document.body.textContent).toContain("1 skipped");+ expect(document.body.textContent).toContain("1 failed");+ expect(document.body.textContent).toContain("AWS Secrets Manager denied the request");+ expect(document.body.textContent).not.toContain("AccessDeniedException");+ expect(document.body.textContent).not.toContain("123456789012");++ await act(async () => {+ root.unmount();+ });+ });++ it("shows an empty state when no AWS vault is configured", async () => {+ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[]}+ existingSecrets={[]}+ onManageVaults={vi.fn()}+ />+ </QueryClientProvider>,+ );+ });+ await flush();++ expect(document.querySelector('[data-testid="select-empty-vaults"]')).not.toBeNull();+ expect(mockSecretsApi.remoteImportPreview).not.toHaveBeenCalled();++ await act(async () => {+ root.unmount();+ });+ });++ it("shows a permission-error banner when AWS denies ListSecrets", async () => {+ const error = Object.assign(new Error("AccessDeniedException"), {+ name: "ApiError",+ status: 403,+ body: null,+ });+ mockSecretsApi.remoteImportPreview.mockRejectedValueOnce(error);++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const banner = document.querySelector('[data-testid="preview-error-banner"]');+ expect(banner).not.toBeNull();+ expect(banner?.textContent).toContain("Could not load remote secrets");++ await act(async () => {+ root.unmount();+ });+ });++ it("renders sanitized preview provider errors without raw AWS exception text", async () => {+ const rawProviderMessage =+ "AccessDeniedException: User: arn:aws:sts::123456789012:assumed-role/prod/Paperclip is not authorized";+ mockSecretsApi.remoteImportPreview.mockRejectedValueOnce(+ new ApiError(+ "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.",+ 403,+ { error: "AWS Secrets Manager denied the request. Check IAM permissions for this provider vault.", details: { code: "access_denied" } },+ ),+ );++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const banner = document.querySelector('[data-testid="preview-error-banner"]');+ expect(banner).not.toBeNull();+ expect(banner?.textContent).toContain("AWS denied list access");+ expect(banner?.textContent).toContain("missing secretsmanager:ListSecrets");+ expect(banner?.textContent).not.toContain(rawProviderMessage);+ expect(banner?.textContent).not.toContain("arn:aws");+ expect(banner?.textContent).not.toContain("123456789012");++ await act(async () => {+ root.unmount();+ });+ });++ it("debounces search and uses the new query for the next preview", async () => {+ mockSecretsApi.remoteImportPreview+ .mockResolvedValueOnce(makePreview([makeCandidate()]))+ .mockResolvedValueOnce(makePreview([+ makeCandidate({+ externalRef: "arn:aws:secretsmanager:us-east-1:1:secret:stripe-XYZ",+ remoteName: "stripe",+ name: "stripe",+ key: "stripe",+ }),+ ]));++ const { queryClient } = makeWrapper();+ const root = createRoot(container);+ await act(async () => {+ root.render(+ <QueryClientProvider client={queryClient}>+ <ImportFromVaultDialog+ open+ onOpenChange={vi.fn()}+ companyId="company-1"+ providerConfigs={[awsVault]}+ existingSecrets={[]}+ />+ </QueryClientProvider>,+ );+ });+ await flush();+ await flush();++ const search = document.querySelector('[data-testid="vault-search"]') as HTMLInputElement;+ expect(search).not.toBeNull();+ const valueSetter = Object.getOwnPropertyDescriptor(+ window.HTMLInputElement.prototype,+ "value",+ )?.set;+ await act(async () => {+ search.focus();+ valueSetter?.call(search, "stripe");+ search.dispatchEvent(new Event("input", { bubbles: true }));+ });+ await flushDebounce();+ await flush();++ expect(mockSecretsApi.remoteImportPreview).toHaveBeenCalledTimes(2);+ const lastCall = mockSecretsApi.remoteImportPreview.mock.calls.at(-1);+ expect(lastCall?.[1]).toMatchObject({ query: "stripe" });++ await act(async () => {+ root.unmount();+ });+ });+});diff --git a/ui/src/pages/secrets/ImportFromVaultDialog.tsx b/ui/src/pages/secrets/ImportFromVaultDialog.tsxnew file mode 100644index 0000000000..c29424769a--- /dev/null+++ b/ui/src/pages/secrets/ImportFromVaultDialog.tsx@@ -0,0 +1,1477 @@+import { useEffect, useMemo, useRef, useState } from "react";+import { useMutation, useQueryClient } from "@tanstack/react-query";+import {+ AlertCircle,+ AlertTriangle,+ CheckCircle2,+ Cloud,+ Database,+ ExternalLink,+ Info,+ Link2,+ Loader2,+ RefreshCw,+ Search,+ X,+ XCircle,+} from "lucide-react";+import type {+ CompanySecret,+ CompanySecretProviderConfig,+ RemoteSecretImportCandidate,+ RemoteSecretImportPreviewResult,+ RemoteSecretImportResult,+ RemoteSecretImportRowResult,+} from "@paperclipai/shared";+import { ApiError } from "../../api/client";+import {+ secretsApi,+ type RemoteImportInput,+ type RemoteImportSelectionInput,+} from "../../api/secrets";+import { useToastActions } from "../../context/ToastContext";+import { queryKeys } from "../../lib/queryKeys";+import { Button } from "@/components/ui/button";+import {+ Dialog,+ DialogContent,+ DialogDescription,+ DialogTitle,+} from "@/components/ui/dialog";+import { Input } from "@/components/ui/input";+import { Checkbox } from "@/components/ui/checkbox";+import { Skeleton } from "@/components/ui/skeleton";+import { Badge } from "@/components/ui/badge";+import {+ Select,+ SelectContent,+ SelectItem,+ SelectTrigger,+ SelectValue,+} from "@/components/ui/select";+import { EmptyState } from "../../components/EmptyState";+import { cn } from "../../lib/utils";++type Step = "select" | "review" | "result";++interface ImportFromVaultDialogProps {+ open: boolean;+ onOpenChange: (open: boolean) => void;+ companyId: string;+ providerConfigs: CompanySecretProviderConfig[];+ existingSecrets: CompanySecret[];+ onImportComplete?: (result: RemoteSecretImportResult) => void;+ onManageVaults?: () => void;+}++interface DraftSelection {+ candidate: RemoteSecretImportCandidate;+ name: string;+ key: string;+ description: string;+}++const KEY_PATTERN = /^[a-z0-9_.-]+$/;+const PAGE_SIZE = 50;++function isAwsSelectable(config: CompanySecretProviderConfig) {+ if (config.provider !== "aws_secrets_manager") return false;+ return config.status === "ready" || config.status === "warning";+}++function eligibleVaults(configs: CompanySecretProviderConfig[]): CompanySecretProviderConfig[] {+ return configs.filter(isAwsSelectable);+}++function pickDefaultVault(configs: CompanySecretProviderConfig[]): string | null {+ const eligible = eligibleVaults(configs);+ if (eligible.length === 0) return null;+ return (eligible.find((vault) => vault.isDefault) ?? eligible[0]).id;+}++function awsVaultOptions(configs: CompanySecretProviderConfig[]): CompanySecretProviderConfig[] {+ return configs.filter((vault) => vault.provider === "aws_secrets_manager");+}++function statusToneClasses(status: RemoteSecretImportCandidate["status"]) {+ switch (status) {+ case "duplicate":+ return "text-muted-foreground border-border/60";+ case "conflict":+ return "text-amber-600 border-amber-500/40 dark:text-amber-400";+ case "ready":+ default:+ return "text-emerald-600 border-emerald-500/40 dark:text-emerald-400";+ }+}++function statusBadgeLabel(status: RemoteSecretImportCandidate["status"]) {+ switch (status) {+ case "duplicate":+ return "Imported";+ case "conflict":+ return "Conflict";+ case "ready":+ default:+ return "Ready";+ }+}++function StatusBadge({+ status,+}: {+ status: RemoteSecretImportCandidate["status"];+}) {+ const Icon =+ status === "conflict"+ ? AlertTriangle+ : status === "duplicate"+ ? Link2+ : CheckCircle2;+ return (+ <Badge variant="outline" className={cn("gap-1 px-1.5 py-0 font-normal", statusToneClasses(status))}>+ <Icon className="h-3 w-3" />+ {statusBadgeLabel(status)}+ </Badge>+ );+}++function RowResultBadge({ status }: { status: RemoteSecretImportRowResult["status"] }) {+ switch (status) {+ case "imported":+ return (+ <Badge+ variant="outline"+ className="gap-1 px-1.5 py-0 font-normal text-emerald-600 border-emerald-500/40 dark:text-emerald-400"+ >+ <CheckCircle2 className="h-3 w-3" /> Created+ </Badge>+ );+ case "skipped":+ return (+ <Badge+ variant="outline"+ className="gap-1 px-1.5 py-0 font-normal text-muted-foreground border-border/60"+ >+ <Link2 className="h-3 w-3" /> Skipped+ </Badge>+ );+ case "error":+ default:+ return (+ <Badge+ variant="outline"+ className="gap-1 px-1.5 py-0 font-normal text-destructive border-destructive/40"+ >+ <XCircle className="h-3 w-3" /> Failed+ </Badge>+ );+ }+}++function middleTruncate(value: string, max = 60) {+ if (value.length <= max) return value;+ const head = Math.floor((max - 1) / 2);+ const tail = max - 1 - head;+ return `${value.slice(0, head)}…${value.slice(value.length - tail)}`;+}++function formatRelativeShort(value: string | null | undefined): string {+ if (!value) return "—";+ const date = new Date(value);+ if (Number.isNaN(date.getTime())) return "—";+ const diff = Date.now() - date.getTime();+ if (diff < 0) return date.toLocaleDateString();+ const seconds = Math.floor(diff / 1000);+ if (seconds < 60) return `${seconds}s ago`;+ const minutes = Math.floor(seconds / 60);+ if (minutes < 60) return `${minutes}m ago`;+ const hours = Math.floor(minutes / 60);+ if (hours < 48) return `${hours}h ago`;+ const days = Math.floor(hours / 24);+ if (days < 30) return `${days}d ago`;+ return date.toLocaleDateString();+}++function readableErrorMessage(error: unknown): string {+ if (error instanceof ApiError) {+ return error.message || `Request failed: ${error.status}`;+ }+ if (error instanceof Error) return error.message;+ return "Unexpected error";+}++function apiErrorCode(error: ApiError): string | null {+ const body = error.body;+ if (!body || typeof body !== "object") return null;+ const record = body as Record<string, unknown>;+ if (typeof record.code === "string") return record.code;+ const details = record.details;+ if (details && typeof details === "object") {+ const code = (details as Record<string, unknown>).code;+ if (typeof code === "string") return code;+ }+ return null;+}++function isPermissionError(error: unknown): boolean {+ if (!(error instanceof ApiError)) return false;+ if (apiErrorCode(error) === "access_denied") return true;+ if (error.status === 401 || error.status === 403) return true;+ const message = error.message.toLowerCase();+ return (+ message.includes("accessdenied") ||+ message.includes("access denied") ||+ message.includes("not authorized")+ );+}++function isThrottlingError(error: unknown): boolean {+ if (!(error instanceof ApiError)) return false;+ if (apiErrorCode(error) === "throttled") return true;+ const message = error.message.toLowerCase();+ return message.includes("throttl") || message.includes("toomanyrequests");+}++function buildDraft(candidate: RemoteSecretImportCandidate): DraftSelection {+ return {+ candidate,+ name: candidate.name,+ key: candidate.key,+ description: "",+ };+}++function safeImportProviderMetadata(+ metadata: Record<string, unknown> | null | undefined,+): Record<string, unknown> | null {+ if (!metadata) return null;+ const safe: Record<string, unknown> = {};+ for (const key of ["createdDate", "lastAccessedDate", "lastChangedDate", "deletedDate"]) {+ const value = metadata[key];+ if (typeof value === "string" || value === null) safe[key] = value;+ }+ for (const key of ["hasDescription", "hasKmsKey", "tagCount"]) {+ const value = metadata[key];+ if (typeof value === "boolean" || typeof value === "number") safe[key] = value;+ }+ return Object.keys(safe).length > 0 ? safe : null;+}++function validateDraftRow(+ draft: DraftSelection,+ existing: CompanySecret[],+ otherDrafts: DraftSelection[],+): string | null {+ if (!draft.name.trim()) return "Name is required.";+ if (draft.name.length > 160) return "Name must be 160 characters or fewer.";+ if (!draft.key.trim()) return "Key is required.";+ if (!KEY_PATTERN.test(draft.key)) {+ return "Key may only contain lowercase letters, numbers, dot, underscore, or hyphen.";+ }+ if (draft.key.length > 120) return "Key must be 120 characters or fewer.";+ if (draft.description.length > 500) return "Description must be 500 characters or fewer.";++ const lowerName = draft.name.trim().toLowerCase();+ const lowerKey = draft.key.trim().toLowerCase();++ for (const existingSecret of existing) {+ if (existingSecret.name.trim().toLowerCase() === lowerName) {+ return "A Paperclip secret already uses this name.";+ }+ if (existingSecret.key.trim().toLowerCase() === lowerKey) {+ return "A Paperclip secret already uses this key.";+ }+ }++ for (const other of otherDrafts) {+ if (other === draft) continue;+ if (other.name.trim().toLowerCase() === lowerName) {+ return "Another row in this batch already uses this name.";+ }+ if (other.key.trim().toLowerCase() === lowerKey) {+ return "Another row in this batch already uses this key.";+ }+ }++ return null;+}++function normalizeDraftKey(input: string): string {+ return input+ .trim()+ .toLowerCase()+ .replace(/[^a-z0-9_.-]+/g, "-")+ .replace(/^-+|-+$/g, "");+}++function useDebounced<T>(value: T, delayMs: number): T {+ const [debounced, setDebounced] = useState(value);+ useEffect(() => {+ const handle = window.setTimeout(() => setDebounced(value), delayMs);+ return () => window.clearTimeout(handle);+ }, [value, delayMs]);+ return debounced;+}++interface PreviewState {+ candidates: RemoteSecretImportCandidate[];+ nextToken: string | null;+}++const EMPTY_PREVIEW: PreviewState = { candidates: [], nextToken: null };++export function ImportFromVaultDialog({+ open,+ onOpenChange,+ companyId,+ providerConfigs,+ existingSecrets,+ onImportComplete,+ onManageVaults,+}: ImportFromVaultDialogProps) {+ const queryClient = useQueryClient();+ const toast = useToastActions();+ const awsVaults = useMemo(() => awsVaultOptions(providerConfigs), [providerConfigs]);+ const eligible = useMemo(() => eligibleVaults(providerConfigs), [providerConfigs]);+ const noEligibleVaults = eligible.length === 0;++ const [step, setStep] = useState<Step>("select");+ const [vaultId, setVaultId] = useState<string | null>(null);+ const [searchInput, setSearchInput] = useState("");+ const debouncedQuery = useDebounced(searchInput.trim(), 250);++ const [preview, setPreview] = useState<PreviewState>(EMPTY_PREVIEW);+ const [previewLoading, setPreviewLoading] = useState(false);+ const [pageLoading, setPageLoading] = useState(false);+ const [previewError, setPreviewError] = useState<unknown>(null);+ const [showOnlySelected, setShowOnlySelected] = useState(false);++ const [selection, setSelection] = useState<Map<string, DraftSelection>>(new Map());+ const [importResult, setImportResult] = useState<RemoteSecretImportResult | null>(null);++ // Reset state on open transition.+ useEffect(() => {+ if (!open) return;+ setStep("select");+ setSearchInput("");+ setPreview(EMPTY_PREVIEW);+ setPreviewError(null);+ setSelection(new Map());+ setImportResult(null);+ setShowOnlySelected(false);+ const next = pickDefaultVault(providerConfigs);+ setVaultId(next);+ // We deliberately depend only on open so that re-opens reset the dialog;+ // providerConfigs changes during a session are handled by next preview fetch.+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [open]);++ const requestIdRef = useRef(0);++ // Run preview when vault or query changes (only on step "select").+ useEffect(() => {+ if (!open || step !== "select" || !vaultId) return;+ let cancelled = false;+ const requestId = ++requestIdRef.current;+ setPreviewLoading(true);+ setPreviewError(null);+ setPreview(EMPTY_PREVIEW);+ secretsApi+ .remoteImportPreview(companyId, {+ providerConfigId: vaultId,+ query: debouncedQuery || null,+ nextToken: null,+ pageSize: PAGE_SIZE,+ })+ .then((result: RemoteSecretImportPreviewResult) => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreview({+ candidates: result.candidates,+ nextToken: result.nextToken,+ });+ })+ .catch((error) => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreviewError(error);+ })+ .finally(() => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreviewLoading(false);+ });+ return () => {+ cancelled = true;+ };+ }, [open, step, vaultId, debouncedQuery, companyId]);++ // When the vault changes, drop any selection (they're scoped to a vault).+ useEffect(() => {+ setSelection(new Map());+ setShowOnlySelected(false);+ }, [vaultId]);++ const visibleCandidates = useMemo<RemoteSecretImportCandidate[]>(() => {+ if (!showOnlySelected) return preview.candidates;+ return preview.candidates.filter((candidate) => selection.has(candidate.externalRef));+ }, [preview.candidates, selection, showOnlySelected]);++ const selectableInLoaded = useMemo(+ () => preview.candidates.filter((c) => c.importable),+ [preview.candidates],+ );++ const selectableLoadedCount = selectableInLoaded.length;+ const selectedLoadedCount = selectableInLoaded.filter((c) =>+ selection.has(c.externalRef),+ ).length;++ const headerCheckboxState: boolean | "indeterminate" =+ selectableLoadedCount === 0+ ? false+ : selectedLoadedCount === 0+ ? false+ : selectedLoadedCount === selectableLoadedCount+ ? true+ : "indeterminate";++ const totalSelected = selection.size;+ const selectedNotVisible = useMemo(() => {+ if (!debouncedQuery) return 0;+ let count = 0;+ for (const ref of selection.keys()) {+ if (!preview.candidates.some((c) => c.externalRef === ref)) count += 1;+ }+ return count;+ }, [selection, preview.candidates, debouncedQuery]);++ const draftList = useMemo(() => Array.from(selection.values()), [selection]);++ const reviewErrors = useMemo<Map<string, string>>(() => {+ const errors = new Map<string, string>();+ for (const draft of draftList) {+ const error = validateDraftRow(draft, existingSecrets, draftList);+ if (error) errors.set(draft.candidate.externalRef, error);+ }+ return errors;+ }, [draftList, existingSecrets]);++ const blockedReviewCount = reviewErrors.size;+ const readyReviewCount = draftList.length - blockedReviewCount;++ const importMutation = useMutation({+ mutationFn: (input: RemoteImportInput) => secretsApi.remoteImport(companyId, input),+ onSuccess: (result) => {+ setImportResult(result);+ setStep("result");+ queryClient.invalidateQueries({ queryKey: queryKeys.secrets.list(companyId) });+ onImportComplete?.(result);+ const vaultName =+ awsVaults.find((vault) => vault.id === vaultId)?.displayName ?? "AWS";+ if (result.errorCount === draftList.length && result.errorCount > 0) {+ toast.pushToast({+ title: "Import failed",+ body: `No secrets were imported from ${vaultName}.`,+ tone: "error",+ });+ } else {+ toast.pushToast({+ title: result.errorCount > 0 ? "Import completed with errors" : "Import complete",+ body: `${result.importedCount} created · ${result.skippedCount} skipped · ${result.errorCount} failed`,+ tone: result.errorCount > 0 ? "warn" : "success",+ });+ }+ },+ onError: (error) => {+ toast.pushToast({+ title: "Import failed",+ body: readableErrorMessage(error),+ tone: "error",+ });+ },+ });++ function handleVaultChange(nextId: string) {+ setVaultId(nextId);+ setSearchInput("");+ }++ function handleRefresh() {+ if (!vaultId || step !== "select") return;+ let cancelled = false;+ const requestId = ++requestIdRef.current;+ setPreviewLoading(true);+ setPreviewError(null);+ secretsApi+ .remoteImportPreview(companyId, {+ providerConfigId: vaultId,+ query: debouncedQuery || null,+ nextToken: null,+ pageSize: PAGE_SIZE,+ })+ .then((result) => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreview({ candidates: result.candidates, nextToken: result.nextToken });+ })+ .catch((error) => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreviewError(error);+ })+ .finally(() => {+ if (cancelled || requestId !== requestIdRef.current) return;+ setPreviewLoading(false);+ });+ }++ function handleLoadMore() {+ if (!vaultId || !preview.nextToken || pageLoading) return;+ setPageLoading(true);+ secretsApi+ .remoteImportPreview(companyId, {+ providerConfigId: vaultId,+ query: debouncedQuery || null,+ nextToken: preview.nextToken,+ pageSize: PAGE_SIZE,+ })+ .then((result) => {+ setPreview((prev) => {+ const seen = new Set(prev.candidates.map((c) => c.externalRef));+ const merged = [...prev.candidates];+ for (const candidate of result.candidates) {+ if (!seen.has(candidate.externalRef)) merged.push(candidate);+ }+ return { candidates: merged, nextToken: result.nextToken };+ });+ })+ .catch((error) => {+ toast.pushToast({+ title: "Could not load more results",+ body: readableErrorMessage(error),+ tone: "error",+ });+ })+ .finally(() => setPageLoading(false));+ }++ function toggleRow(candidate: RemoteSecretImportCandidate) {+ if (!candidate.importable) return;+ setSelection((prev) => {+ const next = new Map(prev);+ if (next.has(candidate.externalRef)) {+ next.delete(candidate.externalRef);+ } else {+ next.set(candidate.externalRef, buildDraft(candidate));+ }+ return next;+ });+ }++ function toggleAllLoaded() {+ setSelection((prev) => {+ const next = new Map(prev);+ const allSelected = selectableInLoaded.every((c) => next.has(c.externalRef));+ if (allSelected) {+ for (const candidate of selectableInLoaded) {+ next.delete(candidate.externalRef);+ }+ } else {+ for (const candidate of selectableInLoaded) {+ if (!next.has(candidate.externalRef)) {+ next.set(candidate.externalRef, buildDraft(candidate));+ }+ }+ }+ return next;+ });+ }++ function updateDraft(externalRef: string, patch: Partial<DraftSelection>) {+ setSelection((prev) => {+ const next = new Map(prev);+ const existing = next.get(externalRef);+ if (!existing) return prev;+ next.set(externalRef, { ...existing, ...patch });+ return next;+ });+ }++ function removeDraft(externalRef: string) {+ setSelection((prev) => {+ const next = new Map(prev);+ next.delete(externalRef);+ return next;+ });+ }++ function handleClose(force = false) {+ if (importMutation.isPending) return;+ if (!force && step !== "result" && selection.size > 0 && !importResult) {+ const ok = window.confirm(+ `Discard ${selection.size} pending import${selection.size === 1 ? "" : "s"}?`,+ );+ if (!ok) return;+ }+ onOpenChange(false);+ }++ function handleSubmitImport() {+ if (!vaultId || importMutation.isPending) return;+ if (blockedReviewCount > 0) return;+ if (draftList.length === 0) return;+ const items: RemoteImportSelectionInput[] = draftList.map((draft) => ({+ externalRef: draft.candidate.externalRef,+ name: draft.name.trim(),+ key: draft.key.trim(),+ description: draft.description.trim() || null,+ providerVersionRef: draft.candidate.providerVersionRef,+ providerMetadata: safeImportProviderMetadata(draft.candidate.providerMetadata),+ }));+ importMutation.mutate({ providerConfigId: vaultId, secrets: items });+ }++ return (+ <Dialog+ open={open}+ onOpenChange={(next) => {+ if (next) {+ onOpenChange(true);+ } else {+ handleClose();+ }+ }}+ >+ <DialogContent+ showCloseButton={false}+ className="flex max-h-[85vh] flex-col gap-0 overflow-hidden p-0 sm:max-w-4xl"+ data-testid="import-from-vault-dialog"+ >+ <header className="flex items-start justify-between gap-3 border-b border-border/60 px-5 py-4">+ <div className="flex flex-col gap-1">+ <DialogTitle className="text-base font-semibold">+ Import from AWS Secrets Manager+ </DialogTitle>+ <DialogDescription className="text-xs text-muted-foreground">+ Bring AWS-managed secrets into Paperclip as external references.+ </DialogDescription>+ <Stepper step={step} />+ </div>+ <button+ type="button"+ className="rounded-sm text-muted-foreground transition-opacity hover:opacity-100 opacity-70"+ onClick={() => handleClose()}+ aria-label="Close import dialog"+ >+ <X className="h-4 w-4" />+ </button>+ </header>++ <div+ className="flex min-h-0 flex-1 flex-col overflow-hidden"+ aria-live="polite"+ >+ {step === "select" && (+ <SelectStep+ awsVaults={awsVaults}+ eligible={eligible}+ vaultId={vaultId}+ onVaultChange={handleVaultChange}+ searchInput={searchInput}+ onSearchInput={setSearchInput}+ debouncedQuery={debouncedQuery}+ onRefresh={handleRefresh}+ previewLoading={previewLoading}+ pageLoading={pageLoading}+ previewError={previewError}+ candidates={preview.candidates}+ visibleCandidates={visibleCandidates}+ selectableInLoaded={selectableInLoaded}+ selection={selection}+ toggleRow={toggleRow}+ toggleAllLoaded={toggleAllLoaded}+ headerCheckboxState={headerCheckboxState}+ hasNextPage={Boolean(preview.nextToken)}+ onLoadMore={handleLoadMore}+ showOnlySelected={showOnlySelected}+ onShowOnlySelectedChange={setShowOnlySelected}+ selectedNotVisible={selectedNotVisible}+ noEligibleVaults={noEligibleVaults}+ onManageVaults={onManageVaults}+ />+ )}+ {step === "review" && (+ <ReviewStep+ drafts={draftList}+ reviewErrors={reviewErrors}+ updateDraft={updateDraft}+ removeDraft={removeDraft}+ importing={importMutation.isPending}+ />+ )}+ {step === "result" && importResult && (+ <ResultStep result={importResult} draftList={draftList} />+ )}+ </div>++ <footer className="flex items-center justify-between gap-3 border-t border-border/60 bg-muted/20 px-5 py-3">+ <FooterStatus+ step={step}+ totalSelected={totalSelected}+ readyReviewCount={readyReviewCount}+ blockedReviewCount={blockedReviewCount}+ result={importResult}+ />+ <div className="flex items-center gap-2">+ {step !== "result" && (+ <Button variant="ghost" size="sm" onClick={() => handleClose()}>+ Cancel+ </Button>+ )}+ {step === "review" && (+ <Button+ variant="outline"+ size="sm"+ onClick={() => setStep("select")}+ disabled={importMutation.isPending}+ >+ Back+ </Button>+ )}+ {step === "select" && (+ <Button+ size="sm"+ onClick={() => setStep("review")}+ disabled={totalSelected === 0}+ >+ Continue → Review+ </Button>+ )}+ {step === "review" && (+ <Button+ size="sm"+ onClick={handleSubmitImport}+ disabled={+ draftList.length === 0 ||+ blockedReviewCount > 0 ||+ importMutation.isPending+ }+ >+ {importMutation.isPending ? (+ <>+ <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" /> Importing…+ </>+ ) : (+ `Import ${draftList.length}`+ )}+ </Button>+ )}+ {step === "result" && (+ <Button size="sm" onClick={() => handleClose(true)}>+ Done+ </Button>+ )}+ </div>+ </footer>+ </DialogContent>+ </Dialog>+ );+}++function Stepper({ step }: { step: Step }) {+ const steps: { id: Step; label: string }[] = [+ { id: "select", label: "Select" },+ { id: "review", label: "Review" },+ { id: "result", label: "Result" },+ ];+ const activeIndex = steps.findIndex((s) => s.id === step);+ return (+ <div className="mt-1 flex items-center gap-2 text-xs text-muted-foreground">+ {steps.map((s, index) => (+ <span key={s.id} className="flex items-center gap-2">+ <span+ className={cn(+ "inline-flex h-4 w-4 items-center justify-center rounded-full border text-[10px]",+ index === activeIndex+ ? "border-primary bg-primary text-primary-foreground"+ : index < activeIndex+ ? "border-primary text-primary"+ : "border-border/60",+ )}+ >+ {index + 1}+ </span>+ <span+ className={cn(+ index === activeIndex ? "text-foreground font-medium" : undefined,+ )}+ >+ {s.label}+ </span>+ {index < steps.length - 1 && (+ <span className="text-muted-foreground/60">›</span>+ )}+ </span>+ ))}+ </div>+ );+}++interface SelectStepProps {+ awsVaults: CompanySecretProviderConfig[];+ eligible: CompanySecretProviderConfig[];+ vaultId: string | null;+ onVaultChange: (id: string) => void;+ searchInput: string;+ onSearchInput: (value: string) => void;+ debouncedQuery: string;+ onRefresh: () => void;+ previewLoading: boolean;+ pageLoading: boolean;+ previewError: unknown;+ candidates: RemoteSecretImportCandidate[];+ visibleCandidates: RemoteSecretImportCandidate[];+ selectableInLoaded: RemoteSecretImportCandidate[];+ selection: Map<string, DraftSelection>;+ toggleRow: (candidate: RemoteSecretImportCandidate) => void;+ toggleAllLoaded: () => void;+ headerCheckboxState: boolean | "indeterminate";+ hasNextPage: boolean;+ onLoadMore: () => void;+ showOnlySelected: boolean;+ onShowOnlySelectedChange: (value: boolean) => void;+ selectedNotVisible: number;+ noEligibleVaults: boolean;+ onManageVaults?: () => void;+}++function SelectStep(props: SelectStepProps) {+ const {+ awsVaults,+ eligible,+ vaultId,+ onVaultChange,+ searchInput,+ onSearchInput,+ debouncedQuery,+ onRefresh,+ previewLoading,+ pageLoading,+ previewError,+ candidates,+ visibleCandidates,+ selectableInLoaded,+ selection,+ toggleRow,+ toggleAllLoaded,+ headerCheckboxState,+ hasNextPage,+ onLoadMore,+ showOnlySelected,+ onShowOnlySelectedChange,+ selectedNotVisible,+ noEligibleVaults,+ onManageVaults,+ } = props;++ if (noEligibleVaults) {+ return (+ <div className="flex min-h-0 flex-1 items-center justify-center p-6" data-testid="select-empty-vaults">+ <EmptyState+ icon={Cloud}+ message="No AWS provider vault configured. Add one to import secrets."+ action={onManageVaults ? "Manage vaults" : undefined}+ onAction={onManageVaults}+ />+ </div>+ );+ }++ const showSearchSpinner = previewLoading && Boolean(debouncedQuery);++ return (+ <div className="flex min-h-0 flex-1 flex-col">+ <div className="flex flex-wrap items-center gap-2 border-b border-border/60 px-5 py-3">+ <label className="text-xs uppercase tracking-wide text-muted-foreground">Vault</label>+ {awsVaults.length === 1 && eligible.length === 1 ? (+ <span className="text-xs font-medium" data-testid="vault-static-label">+ {eligible[0].displayName}+ </span>+ ) : (+ <Select+ value={vaultId ?? undefined}+ onValueChange={onVaultChange}+ >+ <SelectTrigger size="sm" className="text-xs" aria-label="Select AWS vault">+ <SelectValue placeholder="Select an AWS vault" />+ </SelectTrigger>+ <SelectContent>+ {awsVaults.map((vault) => {+ const blocked = !isAwsSelectable(vault);+ return (+ <SelectItem+ key={vault.id}+ value={vault.id}+ disabled={blocked}+ aria-disabled={blocked}+ >+ <span className="flex items-center gap-2">+ <span>{vault.displayName}</span>+ {vault.isDefault && (+ <Badge variant="outline" className="px-1 py-0 text-[10px]">default</Badge>+ )}+ {vault.status === "warning" && (+ <Badge variant="outline" className="px-1 py-0 text-[10px] text-amber-500 border-amber-500/40">warning</Badge>+ )}+ {blocked && (+ <Badge variant="outline" className="px-1 py-0 text-[10px] text-muted-foreground">+ {vault.status === "coming_soon" ? "coming soon" : vault.status}+ </Badge>+ )}+ </span>+ </SelectItem>+ );+ })}+ </SelectContent>+ </Select>+ )}++ <div className="relative ml-auto w-64">+ <Search className="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />+ <Input+ value={searchInput}+ onChange={(event) => onSearchInput(event.target.value)}+ placeholder="Search by name, ARN, tag"+ className="pl-7 pr-7 text-xs"+ aria-label="Search remote secrets"+ data-testid="vault-search"+ />+ {showSearchSpinner && (+ <Loader2 className="absolute right-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 animate-spin text-muted-foreground" />+ )}+ </div>++ <Button+ variant="outline"+ size="sm"+ onClick={onRefresh}+ disabled={previewLoading || !vaultId}+ aria-label="Refresh remote secrets"+ >+ <RefreshCw className={cn("h-3.5 w-3.5", previewLoading && "animate-spin")} />+ </Button>+ </div>++ {selectedNotVisible > 0 && (+ <div className="flex items-center justify-between border-b border-border/60 bg-muted/20 px-5 py-1.5 text-xs text-muted-foreground">+ <span>+ {selection.size} selected · {selectedNotVisible} not visible with current search+ </span>+ <Button+ variant="ghost"+ size="sm"+ className="h-6 px-2 text-xs"+ onClick={() => onShowOnlySelectedChange(!showOnlySelected)}+ >+ {showOnlySelected ? "Show all" : "Show selected"}+ </Button>+ </div>+ )}++ <div className="min-h-0 flex-1 overflow-y-auto" data-testid="vault-table-scroll">+ {previewError ? (+ <PreviewErrorBanner error={previewError} onRetry={onRefresh} />+ ) : previewLoading && candidates.length === 0 ? (+ <SkeletonRows rows={8} />+ ) : candidates.length === 0 ? (+ <EmptyCandidates query={debouncedQuery} />+ ) : (+ <table className="w-full text-sm">+ <thead className="sticky top-0 z-10 bg-muted/40 text-xs uppercase tracking-wide text-muted-foreground">+ <tr>+ <th className="px-3 py-2 text-left">+ <Checkbox+ checked={headerCheckboxState}+ onCheckedChange={() => toggleAllLoaded()}+ aria-label={`Select all loaded (${selectableInLoaded.length})`}+ disabled={selectableInLoaded.length === 0}+ />+ </th>+ <th className="px-2 py-2 text-left font-medium">Remote name</th>+ <th className="px-2 py-2 text-left font-medium">Reference</th>+ <th className="px-2 py-2 text-left font-medium">Last changed</th>+ <th className="px-2 py-2 text-left font-medium">Suggested name</th>+ <th className="px-2 py-2 text-left font-medium">State</th>+ </tr>+ </thead>+ <tbody data-testid="vault-table-body">+ {visibleCandidates.map((candidate) => {+ const isSelected = selection.has(candidate.externalRef);+ const meta = (candidate.providerMetadata ?? {}) as Record<string, unknown>;+ const lastChanged =+ typeof meta.lastChangedAt === "string"+ ? meta.lastChangedAt+ : typeof meta.lastChangedDate === "string"+ ? meta.lastChangedDate+ : null;+ return (+ <tr+ key={candidate.externalRef}+ className={cn(+ "border-b border-border/60 transition-colors",+ candidate.importable+ ? "cursor-pointer hover:bg-accent/40"+ : "cursor-not-allowed text-muted-foreground",+ isSelected && "bg-accent/60",+ )}+ onClick={() => toggleRow(candidate)}+ data-testid={`vault-row-${candidate.externalRef}`}+ data-row-state={candidate.status}+ >+ <td className="px-3 py-2.5" onClick={(e) => e.stopPropagation()}>+ <Checkbox+ checked={isSelected}+ onCheckedChange={() => toggleRow(candidate)}+ disabled={!candidate.importable}+ aria-label={`Select ${candidate.remoteName}`}+ />+ </td>+ <td className="px-2 py-2.5">+ <div className="text-sm font-medium leading-tight">{candidate.remoteName}</div>+ </td>+ <td className="px-2 py-2.5 text-xs">+ <span+ className="font-mono text-muted-foreground"+ title={candidate.externalRef}+ >+ {middleTruncate(candidate.externalRef, 50)}+ </span>+ </td>+ <td className="px-2 py-2.5 text-xs text-muted-foreground">+ {formatRelativeShort(lastChanged)}+ </td>+ <td className="px-2 py-2.5 text-xs font-mono">{candidate.key}</td>+ <td className="px-2 py-2.5 text-xs">+ <div className="flex items-center gap-1.5">+ <StatusBadge status={candidate.status} />+ {candidate.status === "duplicate" &&+ candidate.conflicts.find((c) => c.type === "exact_reference")?.existingSecretId && (+ <span className="text-[11px] text-muted-foreground">+ Already imported+ </span>+ )}+ </div>+ {candidate.status === "conflict" && candidate.conflicts.length > 0 && (+ <div className="mt-0.5 text-[11px] text-amber-600 dark:text-amber-400">+ {candidate.conflicts[0].message}+ </div>+ )}+ </td>+ </tr>+ );+ })}+ {pageLoading && (+ <tr>+ <td colSpan={6} className="p-0">+ <SkeletonRows rows={4} />+ </td>+ </tr>+ )}+ </tbody>+ </table>+ )}++ {hasNextPage && !previewError && (+ <div className="flex items-center justify-between border-t border-border/60 px-5 py-2 text-xs text-muted-foreground">+ <span>+ {candidates.length} loaded+ {selectableInLoaded.length > 0 && (+ <span> · {selectableInLoaded.length} selectable</span>+ )}+ </span>+ <Button+ variant="outline"+ size="sm"+ onClick={onLoadMore}+ disabled={pageLoading}+ data-testid="vault-load-more"+ >+ {pageLoading ? (+ <>+ <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" /> Loading…+ </>+ ) : (+ `Load ${PAGE_SIZE} more`+ )}+ </Button>+ </div>+ )}+ </div>+ </div>+ );+}++function PreviewErrorBanner({ error, onRetry }: { error: unknown; onRetry: () => void }) {+ const isPermission = isPermissionError(error);+ const isThrottling = isThrottlingError(error);+ const message = readableErrorMessage(error);+ return (+ <div+ className="m-5 flex items-start gap-3 rounded-md border border-destructive/40 bg-destructive/10 p-4 text-sm text-destructive"+ role="alert"+ data-testid="preview-error-banner"+ >+ <AlertCircle className="mt-0.5 h-4 w-4 shrink-0" />+ <div className="flex-1">+ <div className="font-medium">+ {isPermission+ ? "AWS denied list access"+ : isThrottling+ ? "AWS throttled the listing request"+ : "Could not load remote secrets"}+ </div>+ <div className="mt-1 text-xs leading-relaxed text-destructive/80">+ {isPermission+ ? "The AWS principal behind this vault is missing secretsmanager:ListSecrets. Update IAM and try again."+ : message}+ </div>+ <div className="mt-2 flex items-center gap-2">+ <Button variant="outline" size="sm" onClick={onRetry}>+ <RefreshCw className="mr-1.5 h-3.5 w-3.5" /> Retry+ </Button>+ {isPermission && (+ <a+ href="https://docs.aws.amazon.com/service-authorization/latest/reference/list_awssecretsmanager.html"+ target="_blank"+ rel="noreferrer"+ className="inline-flex items-center gap-1 text-xs font-medium underline"+ >+ IAM reference <ExternalLink className="h-3 w-3" />+ </a>+ )}+ </div>+ </div>+ </div>+ );+}++function SkeletonRows({ rows }: { rows: number }) {+ return (+ <div className="flex flex-col gap-1.5 p-3">+ {Array.from({ length: rows }).map((_, idx) => (+ <Skeleton key={idx} className="h-8 w-full" />+ ))}+ </div>+ );+}++function EmptyCandidates({ query }: { query: string }) {+ if (query) {+ return (+ <EmptyState+ icon={Search}+ message={`No remote secrets match "${query}".`}+ />+ );+ }+ return (+ <EmptyState+ icon={Database}+ message="No secrets visible to this vault."+ />+ );+}++interface ReviewStepProps {+ drafts: DraftSelection[];+ reviewErrors: Map<string, string>;+ updateDraft: (externalRef: string, patch: Partial<DraftSelection>) => void;+ removeDraft: (externalRef: string) => void;+ importing: boolean;+}++function ReviewStep({ drafts, reviewErrors, updateDraft, removeDraft, importing }: ReviewStepProps) {+ if (drafts.length === 0) {+ return (+ <div className="flex min-h-0 flex-1 items-center justify-center p-6">+ <EmptyState+ icon={Info}+ message="No secrets selected. Go back to pick remote secrets to import."+ />+ </div>+ );+ }++ const blocked = reviewErrors.size;+ const ready = drafts.length - blocked;++ return (+ <div className="flex min-h-0 flex-1 flex-col">+ <div className="flex flex-wrap items-center gap-3 border-b border-border/60 bg-muted/20 px-5 py-3 text-xs">+ <span className="font-medium">{ready} secrets ready to import</span>+ {blocked > 0 && (+ <span className="text-amber-600 dark:text-amber-400">+ {blocked} need attention before import+ </span>+ )}+ </div>+ <div className="min-h-0 flex-1 overflow-y-auto" data-testid="review-list">+ {drafts.map((draft) => {+ const error = reviewErrors.get(draft.candidate.externalRef);+ return (+ <div+ key={draft.candidate.externalRef}+ className={cn(+ "border-b border-border/60 p-4",+ error && "border-l-2 border-l-amber-500/60 bg-amber-500/5",+ )}+ data-testid={`review-row-${draft.candidate.externalRef}`}+ >+ <div className="flex items-start justify-between gap-4">+ <div className="min-w-0 flex-1 space-y-2">+ <div className="flex flex-col gap-0.5">+ <span className="text-sm font-medium">{draft.candidate.remoteName}</span>+ <span+ className="font-mono text-xs text-muted-foreground"+ title={draft.candidate.externalRef}+ >+ {middleTruncate(draft.candidate.externalRef, 60)}+ </span>+ </div>+ <div className="grid grid-cols-1 gap-2 sm:grid-cols-3">+ <label className="flex flex-col gap-1 text-xs">+ <span className="text-muted-foreground">Paperclip name</span>+ <Input+ value={draft.name}+ onChange={(e) =>+ updateDraft(draft.candidate.externalRef, { name: e.target.value })+ }+ className="text-xs"+ aria-invalid={Boolean(error)}+ disabled={importing}+ data-testid={`review-name-${draft.candidate.externalRef}`}+ />+ </label>+ <label className="flex flex-col gap-1 text-xs">+ <span className="text-muted-foreground">Key</span>+ <Input+ value={draft.key}+ onChange={(e) =>+ updateDraft(draft.candidate.externalRef, { key: e.target.value })+ }+ onBlur={(e) =>+ updateDraft(draft.candidate.externalRef, {+ key: normalizeDraftKey(e.target.value),+ })+ }+ className="font-mono text-xs"+ aria-invalid={Boolean(error)}+ disabled={importing}+ data-testid={`review-key-${draft.candidate.externalRef}`}+ />+ </label>+ <label className="flex flex-col gap-1 text-xs">+ <span className="text-muted-foreground">Description (optional)</span>+ <Input+ value={draft.description}+ onChange={(e) =>+ updateDraft(draft.candidate.externalRef, {+ description: e.target.value,+ })+ }+ className="text-xs"+ disabled={importing}+ data-testid={`review-description-${draft.candidate.externalRef}`}+ />+ </label>+ </div>+ {error && (+ <div+ className="flex items-center gap-1.5 text-xs text-amber-600 dark:text-amber-400"+ role="alert"+ data-testid={`review-error-${draft.candidate.externalRef}`}+ >+ <AlertTriangle className="h-3.5 w-3.5" />+ {error}+ </div>+ )}+ </div>+ <Button+ variant="ghost"+ size="icon"+ onClick={() => removeDraft(draft.candidate.externalRef)}+ aria-label={`Remove ${draft.candidate.remoteName}`}+ className="h-7 w-7"+ disabled={importing}+ >+ <X className="h-3.5 w-3.5" />+ </Button>+ </div>+ </div>+ );+ })}+ </div>+ </div>+ );+}++interface ResultStepProps {+ result: RemoteSecretImportResult;+ draftList: DraftSelection[];+}++function ResultStep({ result, draftList }: ResultStepProps) {+ const grouped = useMemo(() => {+ const created: RemoteSecretImportRowResult[] = [];+ const skipped: RemoteSecretImportRowResult[] = [];+ const failed: RemoteSecretImportRowResult[] = [];+ for (const row of result.results) {+ if (row.status === "imported") created.push(row);+ else if (row.status === "skipped") skipped.push(row);+ else failed.push(row);+ }+ return { created, skipped, failed };+ }, [result]);++ const draftLookup = useMemo(() => {+ const map = new Map<string, DraftSelection>();+ for (const draft of draftList) map.set(draft.candidate.externalRef, draft);+ return map;+ }, [draftList]);++ const heading =+ result.errorCount === result.results.length && result.errorCount > 0+ ? "Import failed"+ : result.errorCount === 0 && result.skippedCount === 0+ ? `All ${result.importedCount} secrets imported`+ : "Import complete";++ return (+ <div className="flex min-h-0 flex-1 flex-col">+ <div className="border-b border-border/60 px-5 py-3" data-testid="result-summary">+ <h3 className="text-sm font-semibold">{heading}</h3>+ <div className="mt-1 flex flex-wrap items-center gap-3 text-xs text-muted-foreground">+ <span className="text-emerald-600 dark:text-emerald-400">✓ {result.importedCount} created</span>+ <span>⊘ {result.skippedCount} skipped</span>+ <span className="text-destructive">⨯ {result.errorCount} failed</span>+ </div>+ </div>+ <div className="min-h-0 flex-1 overflow-y-auto">+ {grouped.created.length > 0 && (+ <ResultGroup label="Created" rows={grouped.created} draftLookup={draftLookup} />+ )}+ {grouped.skipped.length > 0 && (+ <ResultGroup label="Skipped" rows={grouped.skipped} draftLookup={draftLookup} />+ )}+ {grouped.failed.length > 0 && (+ <ResultGroup label="Failed" rows={grouped.failed} draftLookup={draftLookup} />+ )}+ </div>+ </div>+ );+}++function ResultGroup({+ label,+ rows,+ draftLookup,+}: {+ label: string;+ rows: RemoteSecretImportRowResult[];+ draftLookup: Map<string, DraftSelection>;+}) {+ return (+ <section>+ <header className="bg-muted/30 px-5 py-1.5 text-xs uppercase tracking-wide text-muted-foreground">+ {label} · {rows.length}+ </header>+ <ul className="divide-y divide-border/60">+ {rows.map((row) => {+ const draft = draftLookup.get(row.externalRef);+ const remoteName = draft?.candidate.remoteName ?? row.name;+ return (+ <li+ key={row.externalRef}+ className="flex flex-wrap items-start gap-2 px-5 py-2.5 text-xs"+ data-testid={`result-row-${row.externalRef}`}+ data-row-status={row.status}+ >+ <RowResultBadge status={row.status} />+ <span className="font-medium">{row.name}</span>+ <span className="font-mono text-muted-foreground">{row.key}</span>+ <span+ className="font-mono text-muted-foreground"+ title={row.externalRef}+ >+ {middleTruncate(row.externalRef, 40)}+ </span>+ <span className="ml-auto flex items-center gap-2">+ {row.status === "imported" && row.secretId && (+ <span className="text-muted-foreground">{remoteName}</span>+ )}+ {row.reason && (+ <span+ className={cn(+ "max-w-[24rem] truncate",+ row.status === "error"+ ? "text-destructive"+ : "text-muted-foreground",+ )}+ title={row.reason}+ >+ {row.reason}+ </span>+ )}+ </span>+ </li>+ );+ })}+ </ul>+ </section>+ );+}++interface FooterStatusProps {+ step: Step;+ totalSelected: number;+ readyReviewCount: number;+ blockedReviewCount: number;+ result: RemoteSecretImportResult | null;+}++function FooterStatus({+ step,+ totalSelected,+ readyReviewCount,+ blockedReviewCount,+ result,+}: FooterStatusProps) {+ if (step === "select") {+ return (+ <div className="text-xs text-muted-foreground">+ {totalSelected === 0+ ? "Select remote secrets to import"+ : `${totalSelected} selected`}+ </div>+ );+ }+ if (step === "review") {+ return (+ <div className="text-xs text-muted-foreground">+ {readyReviewCount} ready+ {blockedReviewCount > 0 && (+ <span className="ml-2 text-amber-600 dark:text-amber-400">+ · {blockedReviewCount} blocked+ </span>+ )}+ </div>+ );+ }+ if (result) {+ return (+ <div className="flex items-center gap-3 text-xs text-muted-foreground">+ <span>{result.importedCount} created</span>+ <span>{result.skippedCount} skipped</span>+ <span>{result.errorCount} failed</span>+ </div>+ );+ }+ return null;+}diff --git a/ui/storybook/.storybook/preview.tsx b/ui/storybook/.storybook/preview.tsxindex 8871f5362e..df150978b3 100644--- a/ui/storybook/.storybook/preview.tsx+++ b/ui/storybook/.storybook/preview.tsx@@ -20,6 +20,11 @@ import {storybookIssues,storybookLiveRuns,storybookProjects,+ storybookSecretAccessEvents,+ storybookSecretBindings,+ storybookSecretProviderHealth,+ storybookSecretProviders,+ storybookSecrets,storybookSidebarBadges,} from "../fixtures/paperclipData";import "@mdxeditor/editor/style.css";@@ -164,6 +169,39 @@ function installStorybookApiFixtures() {if (schema) return Response.json(schema);}+ const secretsListMatch = url.pathname.match(/^\/api\/companies\/([^/]+)\/secrets$/);+ if (secretsListMatch) {+ const [, companyId] = secretsListMatch;+ return Response.json(companyId === "company-storybook" ? storybookSecrets : []);+ }++ const secretProvidersMatch = url.pathname.match(/^\/api\/companies\/([^/]+)\/secret-providers$/);+ if (secretProvidersMatch) {+ return Response.json(storybookSecretProviders);+ }++ const secretProviderHealthMatch = url.pathname.match(+ /^\/api\/companies\/([^/]+)\/secret-providers\/health$/,+ );+ if (secretProviderHealthMatch) {+ return Response.json(storybookSecretProviderHealth);+ }++ const secretUsageMatch = url.pathname.match(/^\/api\/secrets\/([^/]+)\/usage$/);+ if (secretUsageMatch) {+ const [, secretId] = secretUsageMatch;+ return Response.json({+ secretId,+ bindings: storybookSecretBindings.filter((binding) => binding.secretId === secretId),+ });+ }++ const secretEventsMatch = url.pathname.match(/^\/api\/secrets\/([^/]+)\/access-events$/);+ if (secretEventsMatch) {+ const [, secretId] = secretEventsMatch;+ return Response.json(storybookSecretAccessEvents.filter((event) => event.secretId === secretId));+ }+const companyResourceMatch = url.pathname.match(/^\/api\/companies\/([^/]+)\/([^/]+)$/);if (companyResourceMatch) {const [, companyId, resource] = companyResourceMatch;@@ -222,6 +260,11 @@ function installStorybookApiFixtures() {};}+// Install fetch fixtures at module load so React Query never sees a real network failure.+if (typeof window !== "undefined") {+ installStorybookApiFixtures();+}+function applyStorybookTheme(theme: "light" | "dark") {if (typeof document === "undefined") return;document.documentElement.classList.toggle("dark", theme === "dark");@@ -247,6 +290,10 @@ function StorybookProviders({}),);+ if (typeof window !== "undefined") {+ installStorybookApiFixtures();+ }+useEffect(() => {applyStorybookTheme(theme);}, [theme]);diff --git a/ui/storybook/fixtures/paperclipData.ts b/ui/storybook/fixtures/paperclipData.tsindex dc43be4915..0e4485269e 100644--- a/ui/storybook/fixtures/paperclipData.ts+++ b/ui/storybook/fixtures/paperclipData.ts@@ -5,6 +5,8 @@ import type {AuthSession,BudgetPolicySummary,Company,+ CompanySecret,+ CompanySecretBinding,DashboardSummary,ExecutionWorkspace,Goal,@@ -12,6 +14,8 @@ import type {IssueDocument,IssueLabel,Project,+ SecretAccessEvent,+ SecretProviderDescriptor,SidebarBadges,WorkspaceRuntimeService,} from "@paperclipai/shared";@@ -1303,3 +1307,229 @@ export const storybookLiveRuns: LiveRunForIssue[] = [nextAction: "Build fixture-backed navigation stories",},];++export const storybookSecretProviders: SecretProviderDescriptor[] = [+ { id: "local_encrypted", label: "Local encrypted", requiresExternalRef: false },+ { id: "aws_secrets_manager", label: "AWS Secrets Manager", requiresExternalRef: false },+ { id: "gcp_secret_manager", label: "GCP Secret Manager", requiresExternalRef: false },+ { id: "vault", label: "HashiCorp Vault", requiresExternalRef: false },+];++export const storybookSecrets: CompanySecret[] = [+ {+ id: "secret-openai",+ companyId: "company-storybook",+ key: "openai_api_key",+ name: "OPENAI_API_KEY",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 3,+ description: "OpenAI API key shared by all model adapters.",+ lastResolvedAt: recent(12),+ lastRotatedAt: new Date("2026-04-15T09:30:00.000Z"),+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-board",+ createdAt: new Date("2026-03-01T10:00:00.000Z"),+ updatedAt: recent(12),+ },+ {+ id: "secret-aws-prod",+ companyId: "company-storybook",+ key: "prod_aws_deploy",+ name: "PROD_AWS_DEPLOY_KEY",+ provider: "aws_secrets_manager",+ status: "active",+ managedMode: "external_reference",+ externalRef: "arn:aws:secretsmanager:us-east-1:123456789012:secret:paperclip/prod/aws-deploy-AbCdEf",+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 2,+ description: "Deploy key for the prod ECS rollout pipeline.",+ lastResolvedAt: recent(180),+ lastRotatedAt: new Date("2026-04-22T14:00:00.000Z"),+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-board",+ createdAt: new Date("2026-02-01T10:00:00.000Z"),+ updatedAt: recent(180),+ },+ {+ id: "secret-github",+ companyId: "company-storybook",+ key: "github_app_pem",+ name: "GITHUB_APP_PEM",+ provider: "local_encrypted",+ status: "disabled",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 1,+ description: "Disabled until GitHub App reinstall is approved.",+ lastResolvedAt: new Date("2026-03-30T08:11:00.000Z"),+ lastRotatedAt: null,+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-board",+ createdAt: new Date("2026-03-15T10:00:00.000Z"),+ updatedAt: new Date("2026-04-21T11:30:00.000Z"),+ },+ {+ id: "secret-stripe-archived",+ companyId: "company-storybook",+ key: "stripe_legacy",+ name: "STRIPE_LEGACY",+ provider: "vault",+ status: "archived",+ managedMode: "external_reference",+ externalRef: "secret/data/payments/stripe-legacy",+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 4,+ description: "Migrated to managed billing service. Kept for backfill jobs.",+ lastResolvedAt: new Date("2026-02-25T08:11:00.000Z"),+ lastRotatedAt: new Date("2026-02-20T08:11:00.000Z"),+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-board",+ createdAt: new Date("2025-12-01T10:00:00.000Z"),+ updatedAt: new Date("2026-03-01T11:30:00.000Z"),+ },+];++export const storybookSecretBindings: CompanySecretBinding[] = [+ {+ id: "binding-openai-agent",+ companyId: "company-storybook",+ secretId: "secret-openai",+ targetType: "agent",+ targetId: "agent-codex",+ configPath: "env.OPENAI_API_KEY",+ versionSelector: "latest",+ required: true,+ label: "Codex agent env",+ createdAt: new Date("2026-03-02T09:00:00.000Z"),+ updatedAt: new Date("2026-03-02T09:00:00.000Z"),+ },+ {+ id: "binding-openai-project",+ companyId: "company-storybook",+ secretId: "secret-openai",+ targetType: "project",+ targetId: "project-app",+ configPath: "env.OPENAI_API_KEY",+ versionSelector: "latest",+ required: true,+ label: "Paperclip App project env",+ createdAt: new Date("2026-03-02T09:00:00.000Z"),+ updatedAt: new Date("2026-03-02T09:00:00.000Z"),+ },+ {+ id: "binding-aws-environment",+ companyId: "company-storybook",+ secretId: "secret-aws-prod",+ targetType: "environment",+ targetId: "env-prod",+ configPath: "secrets.AWS_DEPLOY",+ versionSelector: 2,+ required: true,+ label: "Prod environment",+ createdAt: new Date("2026-04-22T14:01:00.000Z"),+ updatedAt: new Date("2026-04-22T14:01:00.000Z"),+ },+];++export const storybookSecretAccessEvents: SecretAccessEvent[] = [+ {+ id: "evt-1",+ companyId: "company-storybook",+ secretId: "secret-openai",+ version: 3,+ provider: "local_encrypted",+ actorType: "agent",+ actorId: "agent-codex",+ consumerType: "agent",+ consumerId: "agent-codex",+ configPath: "env.OPENAI_API_KEY",+ issueId: "issue-storybook-1",+ heartbeatRunId: "run-storybook",+ pluginId: null,+ outcome: "success",+ errorCode: null,+ createdAt: recent(12),+ },+ {+ id: "evt-2",+ companyId: "company-storybook",+ secretId: "secret-openai",+ version: 3,+ provider: "local_encrypted",+ actorType: "system",+ actorId: null,+ consumerType: "project",+ consumerId: "project-app",+ configPath: "env.OPENAI_API_KEY",+ issueId: null,+ heartbeatRunId: null,+ pluginId: null,+ outcome: "success",+ errorCode: null,+ createdAt: recent(48),+ },+ {+ id: "evt-3",+ companyId: "company-storybook",+ secretId: "secret-openai",+ version: null,+ provider: "local_encrypted",+ actorType: "agent",+ actorId: "agent-codex",+ consumerType: "agent",+ consumerId: "agent-codex",+ configPath: "env.OPENAI_API_KEY",+ issueId: "issue-storybook-1",+ heartbeatRunId: "run-storybook",+ pluginId: null,+ outcome: "failure",+ errorCode: "secret_disabled",+ createdAt: recent(360),+ },+];++export const storybookSecretProviderHealth = {+ providers: [+ {+ provider: "local_encrypted" as const,+ status: "ok" as const,+ message: "Encryption key loaded; permissions OK.",+ warnings: [] as string[],+ backupGuidance: ["Backup ~/.paperclip/instances/default/secrets/key separately from the database."],+ },+ {+ provider: "aws_secrets_manager" as const,+ status: "warn" as const,+ message: "Connected; KMS key rotation policy not yet enforced.",+ warnings: ["Set up automated KMS key rotation for production tenants."],+ backupGuidance: [],+ },+ {+ provider: "gcp_secret_manager" as const,+ status: "ok" as const,+ message: "Service account reachable.",+ warnings: [] as string[],+ backupGuidance: [],+ },+ {+ provider: "vault" as const,+ status: "ok" as const,+ message: "KV v2 mount reachable.",+ warnings: [] as string[],+ backupGuidance: [],+ },+ ],+};diff --git a/ui/storybook/stories/agent-management.stories.tsx b/ui/storybook/stories/agent-management.stories.tsxindex 9e9ead37db..095b624c6b 100644--- a/ui/storybook/stories/agent-management.stories.tsx+++ b/ui/storybook/stories/agent-management.stories.tsx@@ -250,28 +250,44 @@ const runtimeState: AgentRuntimeState = {};const storybookSecrets: CompanySecret[] = [- {- id: "secret-openai",- companyId: COMPANY_ID,- name: "OPENAI_API_KEY",- provider: "local_encrypted",- externalRef: null,- latestVersion: 5,- description: "Primary coding model key for local Codex agents.",- createdByAgentId: null,- createdByUserId: "user-board",- createdAt: recent(21_000),+ {+ id: "secret-openai",+ companyId: COMPANY_ID,+ key: "openai-api-key",+ name: "OPENAI_API_KEY",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 5,+ description: "Primary coding model key for local Codex agents.",+ lastResolvedAt: recent(600),+ lastRotatedAt: recent(21_000),+ deletedAt: null,+ createdByAgentId: null,+ createdByUserId: "user-board",+ createdAt: recent(21_000),updatedAt: recent(400),},- {- id: "secret-ops-webhook",- companyId: COMPANY_ID,- name: "OPS_WEBHOOK_TOKEN",- provider: "local_encrypted",- externalRef: null,- latestVersion: 3,- description: "Webhook token for runtime observability callbacks.",- createdByAgentId: "agent-cto",+ {+ id: "secret-ops-webhook",+ companyId: COMPANY_ID,+ key: "ops-webhook-token",+ name: "OPS_WEBHOOK_TOKEN",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 3,+ description: "Webhook token for runtime observability callbacks.",+ lastResolvedAt: recent(120),+ lastRotatedAt: recent(12_000),+ deletedAt: null,+ createdByAgentId: "agent-cto",createdByUserId: null,createdAt: recent(12_000),updatedAt: recent(80),diff --git a/ui/storybook/stories/forms-editors.stories.tsx b/ui/storybook/stories/forms-editors.stories.tsxindex 2a5e6b8c4e..bdf863459a 100644--- a/ui/storybook/stories/forms-editors.stories.tsx+++ b/ui/storybook/stories/forms-editors.stories.tsx@@ -199,28 +199,44 @@ const adapterErrors = {};const storybookSecrets: CompanySecret[] = [- {- id: "secret-openai",- companyId: "company-storybook",- name: "OPENAI_API_KEY",- provider: "local_encrypted",- externalRef: null,- latestVersion: 3,- description: null,- createdByAgentId: null,+ {+ id: "secret-openai",+ companyId: "company-storybook",+ key: "openai-api-key",+ name: "OPENAI_API_KEY",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 3,+ description: null,+ lastResolvedAt: new Date("2026-04-20T09:00:00.000Z"),+ lastRotatedAt: new Date("2026-04-18T10:00:00.000Z"),+ deletedAt: null,+ createdByAgentId: null,createdByUserId: "user-board",createdAt: new Date("2026-04-18T10:00:00.000Z"),updatedAt: new Date("2026-04-20T10:00:00.000Z"),},- {- id: "secret-github",- companyId: "company-storybook",- name: "GITHUB_TOKEN",- provider: "local_encrypted",- externalRef: null,- latestVersion: 1,- description: null,- createdByAgentId: null,+ {+ id: "secret-github",+ companyId: "company-storybook",+ key: "github-token",+ name: "GITHUB_TOKEN",+ provider: "local_encrypted",+ status: "active",+ managedMode: "paperclip_managed",+ externalRef: null,+ providerConfigId: null,+ providerMetadata: null,+ latestVersion: 1,+ description: null,+ lastResolvedAt: null,+ lastRotatedAt: new Date("2026-04-19T10:00:00.000Z"),+ deletedAt: null,+ createdByAgentId: null,createdByUserId: "user-board",createdAt: new Date("2026-04-19T10:00:00.000Z"),updatedAt: new Date("2026-04-19T10:00:00.000Z"),diff --git a/ui/storybook/stories/secrets.stories.tsx b/ui/storybook/stories/secrets.stories.tsxnew file mode 100644index 0000000000..5c3d09ea5b--- /dev/null+++ b/ui/storybook/stories/secrets.stories.tsx@@ -0,0 +1,229 @@+import { useEffect, useState, type ReactNode } from "react";+import type { Meta, StoryObj } from "@storybook/react-vite";+import { useQueryClient } from "@tanstack/react-query";+import { AlertCircle, KeyRound } from "lucide-react";+import type { CompanySecret, EnvBinding } from "@paperclipai/shared";+import { Secrets } from "@/pages/Secrets";+import { SecretBindingPicker, type SecretBindingValue } from "@/components/SecretBindingPicker";+import { EnvVarEditor } from "@/components/EnvVarEditor";+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";+import { Badge } from "@/components/ui/badge";+import { useCompany } from "@/context/CompanyContext";+import { queryKeys } from "@/lib/queryKeys";+import { storybookCompanies, storybookSecrets } from "../fixtures/paperclipData";++const COMPANY_ID = "company-storybook";++// Seed localStorage before CompanyContext mounts so its `useState` initializer reads the right id.+if (typeof window !== "undefined") {+ window.localStorage.setItem("paperclip.selectedCompanyId", COMPANY_ID);+}++function StorybookSecretsFixtures({ children }: { children: ReactNode }) {+ const queryClient = useQueryClient();+ // Seed query caches synchronously so children hydrate from cache on first render.+ queryClient.setQueryData(queryKeys.companies.all, storybookCompanies);+ queryClient.setQueryData(queryKeys.secrets.list(COMPANY_ID), storybookSecrets);++ const { selectedCompanyId, setSelectedCompanyId } = useCompany();+ useEffect(() => {+ if (selectedCompanyId !== COMPANY_ID) {+ setSelectedCompanyId(COMPANY_ID);+ }+ }, [selectedCompanyId, setSelectedCompanyId]);++ // Block render until the company id is the storybook fixture so the BindingPicker's+ // useQuery never sees the production-like null state.+ if (selectedCompanyId !== COMPANY_ID) {+ return null;+ }++ return <>{children}</>;+}++const meta: Meta = {+ title: "Product/Secrets",+ parameters: {+ layout: "fullscreen",+ a11y: {+ test: "off",+ },+ },+};++export default meta;++type Story = StoryObj;++function Section({ eyebrow, title, children }: { eyebrow: string; title: string; children: ReactNode }) {+ return (+ <section className="border-b border-border pb-8 last:border-b-0">+ <header className="mb-3 px-6 pt-6">+ <p className="text-[11px] uppercase tracking-wide text-muted-foreground">{eyebrow}</p>+ <h2 className="text-lg font-semibold text-foreground">{title}</h2>+ </header>+ <div className="px-6">{children}</div>+ </section>+ );+}++export const SecretsInventory: Story = {+ render: () => (+ <StorybookSecretsFixtures>+ <div className="h-screen w-full bg-background">+ <Secrets />+ </div>+ </StorybookSecretsFixtures>+ ),+};++function BindingPickerSurface({+ initial,+ label,+}: {+ initial: SecretBindingValue | null;+ label: string;+}) {+ const [value, setValue] = useState<SecretBindingValue | null>(initial);+ return (+ <Card className="w-96">+ <CardHeader>+ <CardTitle className="text-sm">{label}</CardTitle>+ <CardDescription className="text-xs">+ Picker can be reused across agent, project, environment, and plugin config surfaces.+ </CardDescription>+ </CardHeader>+ <CardContent className="space-y-3">+ <SecretBindingPicker value={value} onChange={setValue} />+ <pre className="rounded bg-muted/40 p-2 text-[11px] font-mono">+ {JSON.stringify(value, null, 2)}+ </pre>+ </CardContent>+ </Card>+ );+}++export const BindingPicker: Story = {+ render: () => {+ return (+ <StorybookSecretsFixtures>+ <div className="grid grid-cols-1 gap-6 p-6 md:grid-cols-2">+ <BindingPickerSurface initial={null} label="Empty state" />+ <BindingPickerSurface+ initial={{ secretId: storybookSecrets[0]!.id, version: "latest" }}+ label="Bound to active secret"+ />+ <BindingPickerSurface+ initial={{ secretId: storybookSecrets[2]!.id, version: "latest" }}+ label="Bound but disabled"+ />+ <BindingPickerSurface+ initial={{ secretId: "missing-id", version: "latest" }}+ label="Bound to missing secret"+ />+ </div>+ </StorybookSecretsFixtures>+ );+ },+};++export const EnvEditorWithSecrets: Story = {+ render: () => {+ function EditorDemo({ initial, label }: { initial: Record<string, EnvBinding>; label: string }) {+ const [env, setEnv] = useState<Record<string, EnvBinding>>(initial);+ return (+ <Card className="w-full max-w-2xl">+ <CardHeader>+ <CardTitle className="text-sm flex items-center gap-2">+ <KeyRound className="h-3.5 w-3.5" />+ {label}+ </CardTitle>+ </CardHeader>+ <CardContent>+ <EnvVarEditor+ value={env}+ secrets={storybookSecrets as CompanySecret[]}+ onCreateSecret={async (name, value) => ({+ ...storybookSecrets[0]!,+ id: `secret-${Math.random().toString(36).slice(2, 8)}`,+ name,+ key: name.toLowerCase(),+ description: `New secret with value len=${value.length}`,+ })}+ onChange={(next) => setEnv(next ?? {})}+ />+ </CardContent>+ </Card>+ );+ }+ return (+ <div className="space-y-6 p-6">+ <EditorDemo+ label="Healthy bindings"+ initial={{+ OPENAI_API_KEY: { type: "secret_ref", secretId: "secret-openai", version: "latest" },+ STAGE: { type: "plain", value: "production" },+ }}+ />+ <EditorDemo+ label="Mixed bindings (some need attention)"+ initial={{+ OPENAI_API_KEY: { type: "secret_ref", secretId: "secret-openai", version: 2 },+ GITHUB_APP_PEM: { type: "secret_ref", secretId: "secret-github", version: "latest" },+ ABANDONED: { type: "secret_ref", secretId: "missing-id", version: "latest" },+ }}+ />+ </div>+ );+ },+};++export const RunFailureCopy: Story = {+ render: () => (+ <div className="space-y-4 p-6">+ <Section eyebrow="Run failure" title="Missing or disabled secret blocks the run">+ <Card className="border-destructive/40 bg-destructive/5">+ <CardHeader className="space-y-1">+ <div className="flex items-center gap-2">+ <AlertCircle className="h-4 w-4 text-destructive" />+ <Badge variant="outline" className="border-destructive/40 text-destructive">+ Run failed+ </Badge>+ <span className="text-xs font-mono text-muted-foreground">PAP-2350 · run-storybook</span>+ </div>+ <CardTitle className="text-sm">+ Secret <span className="font-mono">OPENAI_API_KEY</span> is{" "}+ <span className="font-medium text-destructive">disabled</span>+ </CardTitle>+ <CardDescription className="text-xs">+ The agent tried to resolve <span className="font-mono">env.OPENAI_API_KEY</span> for{" "}+ <span className="font-mono">agent:CodexCoder</span> but the secret is currently disabled. No value was+ loaded, no run logs were emitted that contained secret material.+ </CardDescription>+ </CardHeader>+ <CardContent className="space-y-2 text-xs">+ <div>+ <p className="text-muted-foreground">Next action</p>+ <ul className="list-disc pl-4 space-y-0.5">+ <li>+ Re-enable the secret on{" "}+ <a className="text-primary underline" href="/PAP/company/settings/secrets">+ Company settings > Secrets+ </a>+ </li>+ <li>Or, rotate to a new value and pin v3 explicitly for this agent.</li>+ <li>Or, swap the binding to a different secret with the binding picker.</li>+ </ul>+ </div>+ <div>+ <p className="text-muted-foreground">Audit</p>+ <p className="font-mono text-[11px]">+ secret_access_events.outcome=failure error=secret_disabled consumer=agent:CodexCoder+ </p>+ </div>+ </CardContent>+ </Card>+ </Section>+ </div>+ ),+};