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
feat(claude): environment-aware test-environment probe and claude-local CI coverage (#10833)
Devin Foleyf0b06d2de956
diff --git a/docs/adapters/claude-local.md b/docs/adapters/claude-local.mdindex 76cb4b337b..1a13d0459c 100644--- a/docs/adapters/claude-local.md+++ b/docs/adapters/claude-local.md@@ -8,8 +8,9 @@ The `claude_local` adapter runs Anthropic's Claude Code CLI locally. It supports## Prerequisites- Claude Code CLI installed (`claude` command available)-- Either `ANTHROPIC_API_KEY` in adapter env/host env, or a Claude Code- subscription login available to the execution target+- Either `ANTHROPIC_API_KEY` or `CLAUDE_CODE_OAUTH_TOKEN` in adapter or+ environment env (or host env), or a Claude Code subscription login+ available to the execution target## Configuration Fields@@ -72,6 +73,7 @@ The adapter creates a temporary directory with symlinks to Paperclip skills and## Remote credential ownership+When no API key or `CLAUDE_CODE_OAUTH_TOKEN` is configured,`claude_local` uses a snapshot-owns-auth topology for managed sandbox executiontargets. When the run uses a sandbox execution target and no explicit`CLAUDE_CONFIG_DIR` is configured, Paperclip creates a remote@@ -111,5 +113,12 @@ Use the "Test Environment" button in the UI to validate the adapter config. It c- Claude CLI is installed and accessible- Working directory is absolute and available (auto-created if missing and permitted)-- API key/auth mode hints (`ANTHROPIC_API_KEY` vs subscription login)+- API key/auth mode hints (`ANTHROPIC_API_KEY` vs `CLAUDE_CODE_OAUTH_TOKEN` vs subscription login)- A live hello probe (`claude --print - --output-format stream-json --verbose` with prompt `Respond with hello.`) to verify CLI readiness++The probe sees the same layered env as a real run: when an environment is+selected, its environment variables (secret refs included) are resolved and+merged under the adapter config's `env`, so environment-level auth is+reflected in the test result. A secret binding that is missing surfaces as+an `environment_env_binding_missing` failure instead of a silently passing+probe.diff --git a/docs/adapters/overview.md b/docs/adapters/overview.mdindex 83c14e10ef..6fdf1723f3 100644--- a/docs/adapters/overview.md+++ b/docs/adapters/overview.md@@ -39,7 +39,7 @@ before the CLI starts:| Adapter | Credential topology | Which credential file wins on managed sandbox targets ||---------|---------------------|-------------------------------------------------------|| [`codex_local`](/adapters/codex-local) | Host-owns-auth for Paperclip-managed `CODEX_HOME` | A host-owned `auth.json` is symlinked into the managed `CODEX_HOME` and uploaded to the sandbox. If a per-agent `OPENAI_API_KEY` is configured, Paperclip writes an API-key `auth.json` instead and that file wins. A login baked into the sandbox image is shadowed because Codex runs with Paperclip's uploaded `CODEX_HOME`. |-| [`claude_local`](/adapters/claude-local) | Snapshot-owns-auth for managed remote Claude config | Paperclip uploads only sanitized settings and skill/runtime assets. When the remote managed config has no Claude credential files, it copies `.credentials.json` or `credentials.json` from the sandbox image's own `$HOME/.claude`, so the image's login wins. |+| [`claude_local`](/adapters/claude-local) | Snapshot-owns-auth for managed remote Claude config | A configured `ANTHROPIC_API_KEY` or `CLAUDE_CODE_OAUTH_TOKEN` (agent or environment env) wins over any stored login. Otherwise Paperclip uploads only sanitized settings and skill/runtime assets, and when the remote managed config has no Claude credential files it copies `.credentials.json` or `credentials.json` from the sandbox image's own `$HOME/.claude`, so the image's login wins. |Worked examples:diff --git a/packages/adapters/claude-local/src/server/execute.remote.test.ts b/packages/adapters/claude-local/src/server/execute.remote.test.tsindex fad8dc2bb4..ab27ab03f6 100644--- a/packages/adapters/claude-local/src/server/execute.remote.test.ts+++ b/packages/adapters/claude-local/src/server/execute.remote.test.ts@@ -169,11 +169,16 @@ describe("claude remote execution", () => {localDir: workspaceDir,remoteDir: managedRemoteWorkspace,}));- expect(syncDirectoryToSsh).toHaveBeenCalledTimes(1);+ // One sync per registered runtime asset: skills and mcp-config.+ expect(syncDirectoryToSsh).toHaveBeenCalledTimes(2);expect(syncDirectoryToSsh).toHaveBeenCalledWith(expect.objectContaining({remoteDir: `${managedRemoteWorkspace}/.paperclip-runtime/claude/skills`,followSymlinks: true,}));+ expect(syncDirectoryToSsh).toHaveBeenCalledWith(expect.objectContaining({+ remoteDir: `${managedRemoteWorkspace}/.paperclip-runtime/claude/mcp-config`,+ followSymlinks: true,+ }));expect(runChildProcess).toHaveBeenCalledTimes(1);const call = runChildProcess.mock.calls[0] as unknown as| [string, string, string[], { env: Record<string, string>; remoteExecution?: { remoteCwd: string } | null }]diff --git a/packages/adapters/claude-local/src/server/test.probe.test.ts b/packages/adapters/claude-local/src/server/test.probe.test.tsindex 9ff7b5f0e8..58088fa47d 100644--- a/packages/adapters/claude-local/src/server/test.probe.test.ts+++ b/packages/adapters/claude-local/src/server/test.probe.test.ts@@ -101,7 +101,7 @@ describe("claude sandbox hello probe diagnostics", () => {expect(failed?.detail).not.toContain('"subtype":"init"');});- it("classifies rate-limit/overload failures as a transient warning, not a hard fail", async () => {+ it("classifies subscription usage-limit failures as a usage-limited warning, not a hard fail", async () => {probeResult.value = {exitCode: 1,stdout: [@@ -119,7 +119,31 @@ describe("claude sandbox hello probe diagnostics", () => {environmentName: "Daytona",});+ expect(result.checks.some((check) => check.code === "claude_hello_probe_usage_limited")).toBe(true);+ expect(result.checks.some((check) => check.code === "claude_hello_probe_transient_upstream")).toBe(false);+ expect(result.checks.some((check) => check.code === "claude_hello_probe_failed")).toBe(false);+ });++ it("classifies overload failures as a transient warning, not a hard fail", async () => {+ probeResult.value = {+ exitCode: 1,+ stdout: [+ initLine,+ '{"type":"result","subtype":"error_during_execution","is_error":true,"result":"API Error: 529 overloaded_error","session_id":"abc"}',+ ].join("\n"),+ stderr: "",+ };++ const result = await testEnvironment({+ companyId: "company-1",+ adapterType: "claude_local",+ config: { engine: "cli", command: "claude" },+ executionTarget: sandboxTarget,+ environmentName: "Daytona",+ });+expect(result.checks.some((check) => check.code === "claude_hello_probe_transient_upstream")).toBe(true);+ expect(result.checks.some((check) => check.code === "claude_hello_probe_usage_limited")).toBe(false);expect(result.checks.some((check) => check.code === "claude_hello_probe_failed")).toBe(false);});@@ -161,3 +185,58 @@ describe("claude sandbox hello probe diagnostics", () => {expect(failed?.detail).toBeUndefined();});});++describe("claude auth mode hints", () => {+ const successStdout = [+ initLine,+ '{"type":"result","subtype":"success","is_error":false,"result":"hello","session_id":"abc"}',+ ].join("\n");++ it("reports the configured subscription token for remote targets", async () => {+ probeResult.value = { exitCode: 0, stdout: successStdout, stderr: "" };++ const result = await testEnvironment({+ companyId: "company-1",+ adapterType: "claude_local",+ config: {+ engine: "cli",+ command: "claude",+ env: { CLAUDE_CODE_OAUTH_TOKEN: "oauth-test-token" },+ },+ executionTarget: sandboxTarget,+ environmentName: "Daytona",+ });++ const hint = result.checks.find((check) => check.code === "claude_oauth_token_configured");+ expect(hint).toBeTruthy();+ expect(hint?.level).toBe("info");+ expect(hint?.detail).toContain("configured environment variables");+ expect(+ result.checks.some((check) => check.code === "claude_anthropic_api_key_overrides_subscription"),+ ).toBe(false);+ });++ it("keeps the API-key warning authoritative when both ANTHROPIC_API_KEY and the token are set", async () => {+ probeResult.value = { exitCode: 0, stdout: successStdout, stderr: "" };++ const result = await testEnvironment({+ companyId: "company-1",+ adapterType: "claude_local",+ config: {+ engine: "cli",+ command: "claude",+ env: {+ ANTHROPIC_API_KEY: "api-test-key",+ CLAUDE_CODE_OAUTH_TOKEN: "oauth-test-token",+ },+ },+ executionTarget: sandboxTarget,+ environmentName: "Daytona",+ });++ expect(+ result.checks.some((check) => check.code === "claude_anthropic_api_key_overrides_subscription"),+ ).toBe(true);+ expect(result.checks.some((check) => check.code === "claude_oauth_token_configured")).toBe(false);+ });+});diff --git a/packages/adapters/claude-local/src/server/test.ts b/packages/adapters/claude-local/src/server/test.tsindex caedc9d732..1c50a7ae47 100644--- a/packages/adapters/claude-local/src/server/test.ts+++ b/packages/adapters/claude-local/src/server/test.ts@@ -28,6 +28,7 @@ import {import {describeClaudeFailure,detectClaudeLoginRequired,+ isClaudeProviderQuotaError,isClaudeTransientUpstreamError,parseClaudeStreamJson,} from "./parse.js";@@ -278,6 +279,20 @@ export async function testEnvironment(detail: `Detected in ${source}.`,hint: "Unset ANTHROPIC_API_KEY if you want subscription-based Claude login behavior.",});+ } else if (+ isNonEmpty(env.CLAUDE_CODE_OAUTH_TOKEN) ||+ (considerHostEnv && isNonEmpty(process.env.CLAUDE_CODE_OAUTH_TOKEN))+ ) {+ const source = isNonEmpty(env.CLAUDE_CODE_OAUTH_TOKEN)+ ? "configured environment variables"+ : "server environment";+ checks.push({+ code: "claude_oauth_token_configured",+ level: "info",+ message:+ "CLAUDE_CODE_OAUTH_TOKEN is set. Claude will authenticate with the configured subscription token; no stored login is needed on the execution target.",+ detail: `Detected in ${source}.`,+ });} else if (!targetIsRemote) {checks.push({code: "claude_subscription_mode_possible",@@ -428,27 +443,44 @@ export async function testEnvironment((stdoutFallback ? truncateDetail(stdoutFallback) : "") ||detail ||"";+ // Provider-quota exhaustion (usage/session limit) is classified+ // separately from generic transient upstream errors: auth works, the+ // subscription's usage window is just spent. Surface it as its own+ // warning instead of a hard probe failure.+ const usageLimited = isClaudeProviderQuotaError({+ parsed,+ stdout: probe.stdout,+ stderr: probe.stderr,+ });const transient = isClaudeTransientUpstreamError({parsed,stdout: probe.stdout,stderr: probe.stderr,});checks.push(- transient+ usageLimited? {- code: "claude_hello_probe_transient_upstream",+ code: "claude_hello_probe_usage_limited",level: "warn",- message: "Claude hello probe hit a transient upstream error (rate limit or overload).",+ message: "Claude hello probe hit the subscription usage limit.",...(failureDetail ? { detail: failureDetail } : {}),- hint: "This is usually temporary. Wait a moment and re-run Test.",+ hint: "Authentication works; the account's usage window is exhausted. Wait for the limit to reset and re-run Test.",}- : {- code: "claude_hello_probe_failed",- level: "error",- message: "Claude hello probe failed.",- ...(failureDetail ? { detail: failureDetail } : {}),- hint: `Exit code ${probe.exitCode ?? "unknown"}. Run \`claude --print - --output-format stream-json --verbose\` manually in this directory and prompt \`Respond with hello\` to debug.`,- },+ : transient+ ? {+ code: "claude_hello_probe_transient_upstream",+ level: "warn",+ message: "Claude hello probe hit a transient upstream error (rate limit or overload).",+ ...(failureDetail ? { detail: failureDetail } : {}),+ hint: "This is usually temporary. Wait a moment and re-run Test.",+ }+ : {+ code: "claude_hello_probe_failed",+ level: "error",+ message: "Claude hello probe failed.",+ ...(failureDetail ? { detail: failureDetail } : {}),+ hint: `Exit code ${probe.exitCode ?? "unknown"}. Run \`claude --print - --output-format stream-json --verbose\` manually in this directory and prompt \`Respond with hello\` to debug.`,+ },);}}diff --git a/scripts/run-vitest-stable.mjs b/scripts/run-vitest-stable.mjsindex d37ee4d405..4712c86fec 100644--- a/scripts/run-vitest-stable.mjs+++ b/scripts/run-vitest-stable.mjs@@ -19,6 +19,7 @@ const nonServerProjects = ["@paperclipai/skills-catalog","@paperclipai/db","@paperclipai/adapter-utils",+ "@paperclipai/adapter-claude-local","@paperclipai/adapter-codex-local","@paperclipai/adapter-opencode-local","@paperclipai/plugin-sdk",diff --git a/server/src/__tests__/agent-test-environment-routes.test.ts b/server/src/__tests__/agent-test-environment-routes.test.tsindex de490e11ba..fef44e1e1a 100644--- a/server/src/__tests__/agent-test-environment-routes.test.ts+++ b/server/src/__tests__/agent-test-environment-routes.test.ts@@ -19,6 +19,12 @@ const mockAccessService = vi.hoisted(() => ({const mockSecretService = vi.hoisted(() => ({normalizeAdapterConfigForPersistence: vi.fn(async (_companyId: string, config: Record<string, unknown>) => config),resolveAdapterConfigForRuntime: vi.fn(async (_companyId: string, config: Record<string, unknown>) => ({ config })),+ collectMissingRuntimeBindings: vi.fn(async () => [] as Array<Record<string, unknown>>),+ resolveEnvBindings: vi.fn(async () => ({+ env: {} as Record<string, string>,+ secretKeys: new Set<string>(),+ manifest: [],+ })),}));const mockEnvironmentService = vi.hoisted(() => ({@@ -348,4 +354,157 @@ describe("agent test-environment route", () => {status: "failed",});});++ describe("environment envVars merge", () => {+ const environmentId = "11111111-1111-4111-8111-111111111111";+ const sandboxExecutionTarget = {+ kind: "remote",+ transport: "sandbox",+ remoteCwd: "/home/user/paperclip-workspace",+ providerKey: "fake-plugin",+ runner: { execute: vi.fn() },+ };++ it("merges resolved environment envVars under the agent adapterConfig env", async () => {+ mockEnvironmentService.getById.mockResolvedValue({+ id: environmentId,+ companyId: "company-1",+ name: "Sandbox QA",+ driver: "sandbox",+ config: { provider: "fake-plugin" },+ envVars: {+ CLAUDE_CODE_OAUTH_TOKEN: { type: "secret_ref", secretId: "secret-1" },+ FOO: { type: "plain", value: "env-foo" },+ PAPERCLIP_API_KEY: { type: "plain", value: "must-not-flow" },+ },+ });+ mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce(sandboxExecutionTarget);+ mockSecretService.resolveEnvBindings.mockResolvedValueOnce({+ env: { CLAUDE_CODE_OAUTH_TOKEN: "resolved-token", FOO: "env-foo" },+ secretKeys: new Set(["CLAUDE_CODE_OAUTH_TOKEN"]),+ manifest: [],+ });+ const app = await createApp();++ const res = await request(app)+ .post("/api/companies/company-1/adapters/external_test/test-environment")+ .send({+ adapterConfig: { env: { FOO: "agent-foo" } },+ environmentId,+ });++ expect(res.status, JSON.stringify(res.body)).toBe(200);+ expect(mockSecretService.resolveEnvBindings).toHaveBeenCalledWith(+ "company-1",+ {+ CLAUDE_CODE_OAUTH_TOKEN: { type: "secret_ref", secretId: "secret-1" },+ FOO: { type: "plain", value: "env-foo" },+ },+ expect.objectContaining({+ consumerType: "environment",+ consumerId: environmentId,+ }),+ );+ expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);+ // Environment env is the base layer; the agent's own env wins on conflicts.+ expect(testEnvironmentSpy.mock.calls[0]?.[0]?.config?.env).toEqual({+ CLAUDE_CODE_OAUTH_TOKEN: "resolved-token",+ FOO: "agent-foo",+ });+ expect(res.body.status).toBe("pass");+ });++ it("skips env vars with missing secret bindings and fails the test", async () => {+ mockEnvironmentService.getById.mockResolvedValue({+ id: environmentId,+ companyId: "company-1",+ name: "Sandbox QA",+ driver: "sandbox",+ config: { provider: "fake-plugin" },+ envVars: {+ MISSING_TOKEN: { type: "secret_ref", secretId: "secret-gone" },+ GOOD: { type: "plain", value: "ok" },+ },+ });+ mockResolveEnvironmentExecutionTarget.mockResolvedValueOnce(sandboxExecutionTarget);+ mockSecretService.collectMissingRuntimeBindings.mockResolvedValueOnce([+ {+ consumerType: "environment",+ consumerId: environmentId,+ configPath: "env.MISSING_TOKEN",+ envKey: "MISSING_TOKEN",+ secretId: "secret-gone",+ secretName: "Gone",+ },+ ]);+ mockSecretService.resolveEnvBindings.mockResolvedValueOnce({+ env: { GOOD: "ok" },+ secretKeys: new Set<string>(),+ manifest: [],+ });+ const app = await createApp();++ const res = await request(app)+ .post("/api/companies/company-1/adapters/external_test/test-environment")+ .send({ adapterConfig: {}, environmentId });++ expect(res.status, JSON.stringify(res.body)).toBe(200);+ // The unresolved key is excluded from resolution; the rest still flows.+ expect(mockSecretService.resolveEnvBindings).toHaveBeenCalledWith(+ "company-1",+ { GOOD: { type: "plain", value: "ok" } },+ expect.objectContaining({ consumerType: "environment" }),+ );+ expect(testEnvironmentSpy).toHaveBeenCalledTimes(1);+ expect(testEnvironmentSpy.mock.calls[0]?.[0]?.config?.env).toEqual({ GOOD: "ok" });+ // A missing binding blocks real dispatch, so the test reports fail even+ // though the adapter probe itself passed.+ expect(res.body.status).toBe("fail");+ expect(res.body.checks).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ code: "environment_env_binding_missing",+ level: "error",+ message: expect.stringContaining("MISSING_TOKEN"),+ }),+ ]),+ );+ });++ it("includes environment env checks when the environment cannot produce an execution target", async () => {+ mockEnvironmentService.getById.mockResolvedValue({+ id: environmentId,+ companyId: "company-1",+ name: "Sandbox QA",+ driver: "sandbox",+ config: { provider: "fake-plugin" },+ envVars: {+ MISSING_TOKEN: { type: "secret_ref", secretId: "secret-gone" },+ },+ });+ mockSecretService.collectMissingRuntimeBindings.mockResolvedValueOnce([+ {+ consumerType: "environment",+ consumerId: environmentId,+ configPath: "env.MISSING_TOKEN",+ envKey: "MISSING_TOKEN",+ secretId: "secret-gone",+ secretName: "Gone",+ },+ ]);+ const app = await createApp();++ const res = await request(app)+ .post("/api/companies/company-1/adapters/external_test/test-environment")+ .send({ adapterConfig: {}, environmentId });++ expect(res.status, JSON.stringify(res.body)).toBe(200);+ expect(testEnvironmentSpy).not.toHaveBeenCalled();+ expect(res.body.status).toBe("fail");+ expect(res.body.checks).toEqual([+ expect.objectContaining({ code: "environment_target_unsupported", level: "warn" }),+ expect.objectContaining({ code: "environment_env_binding_missing", level: "error" }),+ ]);+ });+ });});diff --git a/server/src/routes/agents.ts b/server/src/routes/agents.tsindex d3659591b2..70a5b3400c 100644--- a/server/src/routes/agents.ts+++ b/server/src/routes/agents.ts@@ -30,6 +30,8 @@ import {LOW_TRUST_REVIEW_PRESET,} from "@paperclipai/shared";import {+ isForbiddenConfigEnvKey,+ parseObject,resolvePaperclipInstanceRootForAdapter,readPaperclipSkillSyncPreference,writePaperclipSkillSyncPreference,@@ -1836,20 +1838,77 @@ export function agentRoutes(let releaseStatus: "released" | "failed" = "released";try {+ // Mirror the run path (resolveExecutionRunAdapterConfig): the selected+ // environment's envVars are the base env layer and the agent's+ // adapterConfig.env wins on key conflicts. Without this merge the probe+ // cannot see environment-level auth (e.g. CLAUDE_CODE_OAUTH_TOKEN) that+ // real runs receive.+ const environmentEnvChecks: AdapterEnvironmentCheck[] = [];+ let effectiveAdapterConfig = runtimeAdapterConfig;+ if (requestedEnvironmentId) {+ const selectedEnvironment = await environmentsSvc.getById(requestedEnvironmentId);+ const environmentEnv = Object.fromEntries(+ Object.entries(parseObject(selectedEnvironment?.envVars)).filter(+ ([key]) => !isForbiddenConfigEnvKey(key),+ ),+ );+ if (Object.keys(environmentEnv).length > 0) {+ const environmentSecretContext = buildActorSecretContext(req, {+ consumerType: "environment",+ consumerId: requestedEnvironmentId,+ });+ const missingBindings =+ typeof secretsSvc.collectMissingRuntimeBindings === "function"+ ? await secretsSvc.collectMissingRuntimeBindings(+ companyId,+ environmentEnv,+ environmentSecretContext,+ )+ : [];+ const missingKeys = new Set(missingBindings.map((binding) => binding.envKey));+ if (missingKeys.size > 0) {+ environmentEnvChecks.push({+ code: "environment_env_binding_missing",+ level: "error",+ message: `Environment variables with missing secret bindings were skipped: ${[...missingKeys].join(", ")}.`,+ hint: "Re-save the environment's variables to restore the secret binding, then test again.",+ });+ }+ const resolvableEnvironmentEnv = Object.fromEntries(+ Object.entries(environmentEnv).filter(([key]) => !missingKeys.has(key)),+ );+ const environmentEnvResolution = await secretsSvc.resolveEnvBindings(+ companyId,+ resolvableEnvironmentEnv,+ environmentSecretContext,+ );+ if (Object.keys(environmentEnvResolution.env).length > 0) {+ effectiveAdapterConfig = {+ ...runtimeAdapterConfig,+ env: {+ ...environmentEnvResolution.env,+ ...parseObject(runtimeAdapterConfig.env),+ },+ };+ }+ }+ }+// If the caller explicitly selected an environment, never fall back to// probing the host when we couldn't resolve that environment's// execution target. Surface the diagnostic checks instead.if (requestedEnvironmentId && !executionTarget && fallbackChecks.length > 0) {- const status: AdapterEnvironmentTestResult["status"] = fallbackChecks.some((c) => c.level === "error")+ const combinedChecks = [...fallbackChecks, ...environmentEnvChecks];+ const status: AdapterEnvironmentTestResult["status"] = combinedChecks.some((c) => c.level === "error")? "fail"- : fallbackChecks.some((c) => c.level === "warn")+ : combinedChecks.some((c) => c.level === "warn")? "warn": "pass";if (status === "fail") releaseStatus = "failed";const synthesized: AdapterEnvironmentTestResult = {adapterType: type,status,- checks: fallbackChecks,+ checks: combinedChecks,testedAt: new Date().toISOString(),};res.json(synthesized);@@ -1859,15 +1918,24 @@ export function agentRoutes(const result = await adapter.testEnvironment({companyId,adapterType: type,- config: runtimeAdapterConfig,+ config: effectiveAdapterConfig,executionTarget,environmentName,});- if (result.status === "fail") releaseStatus = "failed";+ const prefixChecks = [+ ...(sandboxIdentityCheck ? [sandboxIdentityCheck] : []),+ ...environmentEnvChecks,+ ];+ // A missing environment secret binding blocks real dispatch+ // (ConfigurationIncompleteFailure in the heartbeat), so the test+ // reports fail even when the adapter probe itself passed.+ const status = environmentEnvChecks.some((c) => c.level === "error") ? "fail" : result.status;+ if (status === "fail") releaseStatus = "failed";res.json({...result,- checks: sandboxIdentityCheck ? [sandboxIdentityCheck, ...result.checks] : result.checks,+ status,+ checks: prefixChecks.length > 0 ? [...prefixChecks, ...result.checks] : result.checks,});} catch (err) {releaseStatus = "failed";