Multiplayer agent harness for work.
Resolve selected execution credentials on demand and mask their output (#1566)
Regan Belld42e48294a33
diff --git a/docs/qa/execution-credentials/README.md b/docs/qa/execution-credentials/README.mdnew file mode 100644index 000000000..ec1e14161--- /dev/null+++ b/docs/qa/execution-credentials/README.md@@ -0,0 +1,20 @@+# Execution credential QA++The retired command-scoped credential flag is removed from Customize → Feature flags. The screenshots show the real admin page against a local development instance with synthetic data.++| Before | After |+| -------------------------------------------- | --------------------------------------- |+|  |  |++Live Slack QA used Firefox, a real model, local Docker/Postgres, and credentials containing disposable synthetic values with no authority:++- An execution without selection saw the variable absent.+- An execution selecting the saved handle verified the expected value and returned `prefix=<redacted:credential>:suffix`.+- The next execution without selection again saw the variable absent.+- Saving a second credential and selecting the returned handle within that same turn returned `new=<redacted:credential>:end`.+- A failing command preserved exit code 7 and surrounding stdout/stderr while masking the synthetic value.+- The retired tool was absent from the model tool catalog.++Postgres inspection confirmed the selected executions' tool-result entries and tape result content contained the mask and no raw synthetic values. User messages and tool arguments deliberately containing the synthetic fixture are outside output masking.++The change covers known injected env values in execution output. File credential restoration, the raw keychain use endpoint, and unrelated asynchronous/file output paths are separate work.diff --git a/docs/qa/execution-credentials/after.png b/docs/qa/execution-credentials/after.pngnew file mode 100644index 000000000..7b02dc6d7Binary files /dev/null and b/docs/qa/execution-credentials/after.png differdiff --git a/docs/qa/execution-credentials/before.png b/docs/qa/execution-credentials/before.pngnew file mode 100644index 000000000..5fe079270Binary files /dev/null and b/docs/qa/execution-credentials/before.png differdiff --git a/plugins/admin/ui/settings-flags.ts b/plugins/admin/ui/settings-flags.tsindex cfc6982ac..32d6acf4d 100644--- a/plugins/admin/ui/settings-flags.ts+++ b/plugins/admin/ui/settings-flags.ts@@ -8,7 +8,7 @@ const state = {scope: "",available: false,selected: new Set<string>(),- feature: "command_scoped_credentials",+ feature: "persistent_subagents",saving: false,message: "",choices: [] as any[],@@ -133,7 +133,6 @@ function template() {selector();}}>- <option value="command_scoped_credentials">Command-scoped credentials</option><option value="persistent_subagents">Persistent subagents</option><option value="inbox_loops">Inbox Loops</option></select></labeldiff --git a/src/api/routes/keychain.ts b/src/api/routes/keychain.tsindex b26764dba..59729200b 100644--- a/src/api/routes/keychain.ts+++ b/src/api/routes/keychain.ts@@ -1,5 +1,6 @@import {KeychainError,+ isBackendCredential,renderAskNotice,renderUseScript,type CredentialFieldInput,@@ -203,10 +204,22 @@ async function handleKeychain(ctx: ApiCtx): Promise<void> {message: 'expected { credential | ask, mode: "once"|"standing", purpose }',});}- const useBlock = (grant: { id: string }) => ({- command: keychainUseCommand({ grant: grant.id }),- note: "Run the task in that same shell. The secret never appears in output — do not cat the file.",- });+ const useBlock = async (grant: { id: string; credentialId: string }) => {+ const credential = await kc.getCredential(grant.credentialId);+ if (credential && isBackendCredential(credential))+ return {+ note: "Composio keys stay in the backend. Use the composio skill and /v1/composio through the authenticated agent API.",+ };+ return {+ command: keychainUseCommand({ grant: grant.id }),+ ...(credential?.credentialHandle+ ? { credentialHandle: credential.credentialHandle, credentials: [credential.credentialHandle] }+ : {}),+ note: credential?.credentialHandle+ ? "Pass credentials to execute for the command needing this credential. This handle is available immediately; no keychain/use call is needed."+ : "Run the task in that same shell. Do not echo or print the credential files.",+ };+ };if (typeof b.ask === "string") {if (typeof b.onBehalfOf === "string" && b.onBehalfOf.trim() && !samePerson(b.onBehalfOf, actorId)) {return sendJson(res, 403, {@@ -232,10 +245,12 @@ async function handleKeychain(ctx: ApiCtx): Promise<void> {.fireAskResolution?.(ask, grant).then(() => kc.markAskNotified(ask.id, ask.status)).catch((e) => swallow("keychain: ask resolution fire failed (sweep will retry)", e));+ const grantedCredential = await kc.getCredential(grant.credentialId);return sendJson(res, 200, {grant,ask,use: {+ ...(grantedCredential?.credentialHandle ? { credentialHandle: grantedCredential.credentialHandle } : {}),note: `Grant is active in ${grant.audienceScopeId} — the asking conversation resumes automatically. Do not load or consume the grant on this approval turn.`,},});@@ -277,7 +292,7 @@ async function handleKeychain(ctx: ApiCtx): Promise<void> {scopeLabel: capability.scopeId,});}- return sendJson(res, 200, { grant, use: useBlock(grant) });+ return sendJson(res, 200, { grant, use: await useBlock(grant) });}if (method === "GET" && pathname === "/v1/keychain/grants") {diff --git a/src/config.ts b/src/config.tsindex 6c8caaa44..5101a7997 100644--- a/src/config.ts+++ b/src/config.ts@@ -188,7 +188,6 @@ export interface Config {};scratchExecEnabled: boolean;reachExecEnabled: boolean;- sharedOwnerAuthIsolation: boolean;surfaceDebugFooter: boolean;eagerProvisionEnabled: boolean;awsSandbox: AwsSandboxEnv;@@ -1616,7 +1615,6 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config {securityScreenTimeoutMs,scratchExecEnabled: boolEnvStrict("EXECUTE_SCRATCH", env.EXECUTE_SCRATCH) ?? false,reachExecEnabled: boolEnvStrict("REACH_EXEC", env.REACH_EXEC) ?? false,- sharedOwnerAuthIsolation: boolEnvStrict("SHARED_OWNER_AUTH_ISOLATION", env.SHARED_OWNER_AUTH_ISOLATION) ?? false,surfaceDebugFooter: boolEnvStrict("SURFACE_DEBUG_FOOTER", env.SURFACE_DEBUG_FOOTER) ?? false,eagerProvisionEnabled: boolEnvStrict("EAGER_PROVISION", env.EAGER_PROVISION) ?? true,awsSandbox: awsSandboxEnv(env),diff --git a/src/core/orchestrator.ts b/src/core/orchestrator.tsindex 760a7d66a..8b6d66ba0 100644--- a/src/core/orchestrator.ts+++ b/src/core/orchestrator.ts@@ -10,9 +10,6 @@ import {} from "./document-inputs.ts";import { recoveredRuntime } from "../harness/runtime-recovery.ts";import { createCanWriteScope, withLiveTurnMembership } from "../resolution/scope-membership.ts";-import { evaluateCommandWithLayer } from "../policy/command-policy.ts";-import { createSecretValueMasker } from "../security/secret-masking.ts";-import { shq } from "../util/shell.ts";import { goalViewFromEntry } from "../runs/turn-stream.ts";import type {CommandApprovalGrant,@@ -56,12 +53,7 @@ import { createBackgroundBroker } from "../connectors/background-exec-broker.ts"import { createMonitorBroker, readBackgroundOutputTail } from "../monitors/monitor-broker.ts";import { isPollSurface, isSilentPollReply } from "../triggers/run-trigger.ts";import { envKey } from "../credentials/connector-token.ts";-import {- credentialHandle,- renderKeychainManifest,- type MaterializedEnvCred,- type PublicServiceCredential,-} from "../credentials/keychain.ts";+import { credentialHandle, renderKeychainManifest, type PublicServiceCredential } from "../credentials/keychain.ts";import {captureDeviceFlowLogins,deviceFlowCredOwner,@@ -1380,78 +1372,137 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {liveAuthorTurn && conversation.kind !== "dm" && sharingSources.includes(personalScope(actor.id));const isolateOwnerKeychain =openSpeakerKeychain ||- (deps.sharedOwnerAuthIsolation === true &&- conversation.kind !== "dm" &&- input.origin.kind === "automation" &&- input.origin.useOwnerKeychain === true);+ (conversation.kind !== "dm" && input.origin.kind === "automation" && input.origin.useOwnerKeychain === true);let ownerAuthAvailable = isolateOwnerKeychain;- if (- deps.sharedOwnerAuthIsolation === true &&- conversation.kind !== "dm" &&- brokeredTools.some((tool) => cutoverModeOf(tool.service) !== "legacy" && deps.layerBrokerFor?.(tool))- ) {+ if (brokeredTools.some((tool) => cutoverModeOf(tool.service) !== "legacy" && deps.layerBrokerFor?.(tool))) {ownerAuthAvailable = true;}const connectorEnv: Record<string, string> = {};- const ownerAuthEnv: Record<string, string> = {};- const ownerEnvCredentialIds: string[] = [];- const keychainInjected: MaterializedEnvCred[] = [];- const commandCredentials: CommandCredential[] = [];const credsStart = Date.now();- const commandScopedCredentials =- !strictReadOnly && (await deps.featureFlags?.enabled("command_scoped_credentials", scopeId)) === true;- if (!strictReadOnly && deps.keychain) {- const own =- scopeId === personalScope(actor.id) ||- (input.origin.kind === "automation" && input.origin.useOwnerKeychain && !isolateOwnerKeychain)- ? await deps.keychain.materializeOwn(actor.id)- : [];- if (isolateOwnerKeychain) {- for (const materialized of await deps.keychain.materializeOwn(actor.id)) {- for (const { key, value } of materialized.env) if (!(key in ownerAuthEnv)) ownerAuthEnv[key] = value;- ownerEnvCredentialIds.push(materialized.credentialId);- }+ const commandCredentials: CommandCredential[] = [];+ const credentialDescriptions: string[] = [];+ const credentialIdentities = new Map<string, string>();++ const authorizeOwnerCredentials = async (): Promise<void> => {+ if (+ openSpeakerKeychain &&+ (!(await isCurrentSharedScopeMember(actor.id, scopeId)) ||+ (await deps.config?.resolveSharingPostureDurable(personalScope(actor.id), scopeId)) !== "open")+ ) {+ throw new Error("Open speaker keychain access is no longer authorized");}- for (const m of [...own, ...(await deps.keychain.materializeStanding(scopeId))]) {- if (!commandScopedCredentials) {- const injected = m.env.filter(({ key }) => !(key in connectorEnv));- for (const { key, value } of injected) connectorEnv[key] = value;- if (m.grantId && injected.length) {- keychainInjected.push({ ...m, env: injected });- deps.auditLog.record({- at: Date.now(),- principalId: actor.id,- action: "keychain.materialize",- resource: `${m.credentialId} (grant ${m.grantId})`,- scopeLabel: scopeId,- });- }- continue;+ };+ const resolvedCredential = (materialized: import("../credentials/keychain.ts").MaterializedCred) => {+ if (materialized.kind !== "env") throw new Error("File credentials require the supervised execution route");+ return { env: materialized.env };+ };+ const addCredentialToCatalog = (+ credential: CommandCredential,+ description: string,+ identity = credential.handle,+ ): void => {+ const existing = credentialIdentities.get(credential.handle);+ if (existing !== undefined) {+ if (existing !== identity) throw new Error(`credential handle collision: ${credential.handle}`);+ return;+ }+ credentialIdentities.set(credential.handle, identity);+ commandCredentials.push(credential);+ credentialDescriptions.push(+ `- \`${credential.handle}\` — ${description}; execute scope \`${credential.scope ?? "scoped"}\`.`,+ );+ };+ const registerKeychainCredentials = async (addCredential: typeof addCredentialToCatalog): Promise<void> => {+ if (strictReadOnly || !deps.keychain) return;+ const keychain = deps.keychain;+ for (const { grant, credential } of await keychain.grantsForScope(scopeId)) {+ if (credential.kind !== "env" || isBackendCredential(credential)) continue;+ addCredential(+ {+ handle: credentialHandle(credential.id),+ resolve: async () => {+ const prepared = await keychain.prepareMaterialize(grant.id, scopeId, actor.id);+ return {+ ...resolvedCredential(prepared.materialized),+ commit: prepared.commit,+ singleUse: prepared.singleUse,+ };+ },+ },+ `${credential.service}, owner ${credential.ownerId}, grant ${grant.id}`,+ credential.id,+ );+ }+ const ownAllowed =+ (liveAuthorTurn && scopeId === personalScope(actor.id)) ||+ isolateOwnerKeychain ||+ (input.origin.kind === "automation" && input.origin.useOwnerKeychain === true);+ if (ownAllowed) {+ for (const credential of await keychain.listByOwner(actor.id)) {+ if (credential.kind !== "env" || isBackendCredential(credential)) continue;+ addCredential(+ {+ handle: credentialHandle(credential.id),+ scope: isolateOwnerKeychain ? "owner" : "scoped",+ resolve: async () => {+ await authorizeOwnerCredentials();+ return resolvedCredential(+ await keychain.materializeOwnById(actor.id, credential.id, personalScope(actor.id)),+ );+ },+ },+ `${credential.service}, owner ${credential.ownerId}`,+ credential.id,+ );}- const handle = credentialHandle(m.credentialId);- const existing = commandCredentials.find((credential) => credential.handle === handle);- if (existing) {- if (JSON.stringify(existing.env) !== JSON.stringify(m.env)) {- throw new Error(`credential handle collision: ${handle}`);+ }+ };+ await registerKeychainCredentials(addCredentialToCatalog);+ const registerConnectorCredentials = async (addCredential: typeof addCredentialToCatalog): Promise<void> => {+ if (+ !strictReadOnly &&+ deps.connectorTokens &&+ ((conversation.kind === "dm" && liveAuthorTurn) || openSpeakerKeychain)+ ) {+ const tokens = deps.connectorTokens;+ const inventory = tokens.listConnectorsByOwners+ ? ((await tokens.listConnectorsByOwners([actor.id])).get(actor.id) ?? [])+ : undefined;+ for (const host of CONNECTOR_HOSTS) {+ for (const accountType of ["personal", undefined, "company"]) {+ const status = inventory+ ? inventory.find(+ (credential) =>+ credential.host === host && (credential.accountType ?? "default") === (accountType ?? "default"),+ )+ : await tokens.connectorTokenStatus(host, actor.id, accountType);+ const healthy = status?.connected && !status.needsReconnect;+ const operatorFallback =+ accountType === undefined &&+ tokens.operatorFallbackHosts?.some((allowed) => host === allowed || host.endsWith(`.${allowed}`));+ if (!healthy && !operatorFallback) continue;+ addCredential(+ {+ handle: `connector_${host.replace(/[^a-zA-Z0-9]/g, "_")}_${accountType ?? "default"}`,+ scope: openSpeakerKeychain ? "owner" : "scoped",+ resolve: async () => {+ await authorizeOwnerCredentials();+ const token = await tokens.connectorAccessToken(host, actor.id, accountType);+ if (!token) throw new Error(`Connector is no longer available: ${host}`);+ return { env: [{ key: envKey(host), value: token }] };+ },+ },+ !healthy && operatorFallback+ ? `${host}, configured operator fallback; availability checked on use`+ : `${host} connector, owner ${actor.id}, account ${accountType ?? "default"}`,+ );}- continue;}- commandCredentials.push({ handle, env: m.env });- keychainInjected.push(m);- }- }- if (!strictReadOnly && deps.connectorTokens && (conversation.kind === "dm" || openSpeakerKeychain)) {- for (const host of CONNECTOR_HOSTS) {- const token =- (await deps.connectorTokens.connectorAccessToken(host, actor.id, "personal")) ??- (await deps.connectorTokens.connectorAccessToken(host, actor.id)) ??- (await deps.connectorTokens.connectorAccessToken(host, actor.id, "company"));- if (token) (openSpeakerKeychain ? ownerAuthEnv : connectorEnv)[envKey(host)] = token;}- }+ };+ await registerConnectorCredentials(addCredentialToCatalog);perf.credsMs += Date.now() - credsStart;let sharedCredsBlock = "";- const envCredLines: string[] = [];let egressTokenForTurn: string | undefined;// Service credentials: one read of the org's credential list and one grant scan feed both// the env-delivery gate (below) and the broker token mint (further down). Same grants gate both.@@ -1473,28 +1524,22 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {);}}+ const authorizeServiceCredential = async (slug: string): Promise<void> => {+ const grants = await deps.acl.grantsOfKind(+ "service-cred",+ conversation.audience,+ scopeId,+ resolution.orgScopeId,+ principalEntitledToScope,+ );+ if (!grants.some((grant) => parseRef(grant.ref).id === slug)) {+ throw new Error(`Service credential is no longer authorized: ${slug}`);+ }+ };if (!strictReadOnly && allInternal && deps.serviceCreds) {- const orgScope = toScopeId("org", orgId());// Env delivery is gated by the same service-cred grants as the broker: the env var rides// only when every internal participant in this conversation is entitled to the credential.- for (const cred of serviceCredRecords) {- if (- isBackendCredential(cred) ||- cred.delivery !== "env" ||- !cred.envKey ||- !cred.enabled ||- !cred.hasSecret ||- !grantedCredSlugs.has(cred.slug) ||- cred.envKey in connectorEnv- )- continue;- const rec = await deps.serviceCreds.getServiceCredentialSecret(orgScope, cred.slug);- if (rec?.secret && rec.delivery === "env" && rec.enabled && rec.envKey === cred.envKey) {- connectorEnv[cred.envKey] = rec.secret;- envCredLines.push(`- \`${cred.slug}\` → \`${cred.envKey}\``);- }- }const browseSteps = deps.config?.getBrowseMaxSteps(toScopeId("org", orgId()));if (browseSteps && !("BROWSE_LAB_MAX_STEPS" in connectorEnv))connectorEnv.BROWSE_LAB_MAX_STEPS = String(browseSteps);@@ -1586,20 +1631,13 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {if (deps.serviceCreds) {const records = serviceCredRecords;const enabled = new Set(- records.filter((r) => r.enabled && r.hasSecret && r.delivery !== "env").map((r) => r.slug),+ records+ .filter((r) => !isBackendCredential(r) && r.enabled && r.hasSecret && r.delivery !== "env")+ .map((r) => r.slug),);if (enabled.size > 0) {const slugs = [...grantedCredSlugs].filter((s) => enabled.has(s));if (slugs.length > 0) {- connectorEnv.AGENT_CREDENTIAL_TOKEN = await mintCapabilityToken(- {- ...scopeAttestation,- aud: CREDENTIAL_BROKER_AUD,- credentials: slugs,- exp: Date.now() + SANDBOX_CAPABILITY_TTL_MS,- },- deps.capabilitySecret ?? deps.signingSecret,- );const usable = records.filter((r) => slugs.includes(r.slug));const lines = usable.map((r) => {const methods = r.allowedMethods?.length ? r.allowedMethods.join("/") : "GET";@@ -1608,7 +1646,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {});sharedCredsBlock ="\n\n## Shared org credentials available to you\n" +- "The org vended these shared credentials to this conversation. You CANNOT see the secret — call the " ++ "Select the corresponding `service_<slug>` handle in execute.credentials. You CANNOT see the secret — call the " +"target BY PROXY through the broker, which injects it server-side. Use exactly this (with the " +"$AGENT_CREDENTIAL_TOKEN env var, NOT $AGENT_API_TOKEN):\n" +"```\n" +@@ -1651,44 +1689,137 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {egressSecret,);}+ const registerServiceCredentials = async (+ addCredential: typeof addCredentialToCatalog,+ requestedHandles: readonly string[],+ ): Promise<void> => {+ if (strictReadOnly || !deps.serviceCreds) return;+ const records = await deps.serviceCreds.listServiceCredentials(resolution.orgScopeId);+ const grants = await deps.acl.grantsOfKind(+ "service-cred",+ conversation.audience,+ scopeId,+ resolution.orgScopeId,+ principalEntitledToScope,+ );+ const granted = new Set(grants.map((grant) => parseRef(grant.ref).id));+ const available = records.filter(+ (record) => !isBackendCredential(record) && record.enabled && record.hasSecret && granted.has(record.slug),+ );+ const brokerSlugs = available+ .filter((record) => record.delivery !== "env" && requestedHandles.includes(`service_${record.slug}`))+ .map((record) => record.slug)+ .sort();+ let brokerToken: Promise<string> | undefined;+ const resolveBrokerToken = (): Promise<string> =>+ (brokerToken ??= (async () => {+ const current = await deps.serviceCreds!.listServiceCredentials(resolution.orgScopeId);+ for (const slug of brokerSlugs) {+ await authorizeServiceCredential(slug);+ const record = current.find((candidate) => candidate.slug === slug);+ if (!record?.enabled || !record.hasSecret || record.delivery === "env") {+ throw new Error(`Service credential is no longer available: ${slug}`);+ }+ }+ return mintCapabilityToken(+ {+ ...scopeAttestation,+ aud: CREDENTIAL_BROKER_AUD,+ credentials: brokerSlugs,+ exp: Date.now() + SANDBOX_CAPABILITY_TTL_MS,+ },+ (deps.capabilitySecret ?? deps.signingSecret)!,+ );+ })());+ for (const credential of available) {+ if (credential.delivery === "env") {+ if (!allInternal || !credential.envKey) continue;+ addCredential(+ {+ handle: `service_${credential.slug}`,+ resolve: async () => {+ await authorizeServiceCredential(credential.slug);+ const current = await deps.serviceCreds!.getServiceCredentialSecret(+ resolution.orgScopeId,+ credential.slug,+ );+ if (+ !current?.enabled ||+ isBackendCredential(current) ||+ !current.secret ||+ current.delivery !== "env" ||+ current.envKey !== credential.envKey+ ) {+ throw new Error(`Service credential is no longer available: ${credential.slug}`);+ }+ return { env: [{ key: credential.envKey!, value: current.secret }] };+ },+ },+ `${credential.name}, org credential, provides ${credential.envKey}`,+ );+ } else if (deps.signingSecret && deps.apiBaseUrl) {+ addCredential(+ {+ handle: `service_${credential.slug}`,+ resolve: async () => ({ env: [{ key: "AGENT_CREDENTIAL_TOKEN", value: await resolveBrokerToken() }] }),+ },+ `org credential ${credential.slug}, provides scoped broker capability`,+ );+ }+ }+ };+ await registerServiceCredentials(addCredentialToCatalog, []);if (!strictReadOnly && actor.type === "internal") {for (const tool of brokeredTools) {- const mode = cutoverModeOf(tool.service);- if (mode !== "legacy") continue;const broker = deps.layerBrokerFor?.(tool);- if (!broker) {- continue;- }- const aws = await broker- .credsForActor(actor.id)- .catch(swallowAs(`orchestrator: ${tool.service} broker assume-role`, undefined));- const awsEnv = aws- ? {- AWS_ACCESS_KEY_ID: aws.accessKeyId,- AWS_SECRET_ACCESS_KEY: aws.secretAccessKey,- AWS_SESSION_TOKEN: aws.sessionToken,- AWS_REGION: aws.region,- AWS_DEFAULT_REGION: aws.region,- }- : null;- if (awsEnv) {- Object.assign(connectorEnv, awsEnv);- deps.credentialUsage?.record({- slug: tool.service,- host: "sts.amazonaws.com",- status: "legacy_vended",- scopeLabel: scopeId,- principalId: actor.id,- });- } else {- deps.credentialUsage?.record({- slug: tool.service,- host: "sts.amazonaws.com",- status: "legacy_unavailable",- scopeLabel: scopeId,- principalId: actor.id,- });- }+ if (!broker) continue;+ const brokerScope = cutoverModeOf(tool.service) === "legacy" ? "scoped" : "owner";+ addCredentialToCatalog(+ {+ handle: `broker_${tool.service}`,+ scope: brokerScope,+ resolve: async () => {+ const policy = await deps.deviceFlowCutover?.resolvePolicy(memoryScopeId, tool.service);+ const currentScope = !policy || policy.mode === "legacy" ? "scoped" : "owner";+ if (currentScope !== brokerScope)+ throw new Error(`Broker credential scope changed: ${tool.service}; retry on the next turn`);+ let aws;+ try {+ aws = await broker.credsForActor(actor.id);+ } catch {+ deps.credentialUsage?.record({+ slug: tool.service,+ host: "sts.amazonaws.com",+ status: brokerScope === "owner" ? "ephemeral_failed_closed" : "legacy_unavailable",+ scopeLabel: scopeId,+ principalId: actor.id,+ });+ throw new Error(`Could not vend credentials for ${tool.service}`);+ }+ deps.credentialUsage?.record({+ slug: tool.service,+ host: "sts.amazonaws.com",+ status: brokerScope === "owner" ? "ephemeral_vended" : "legacy_vended",+ scopeLabel: scopeId,+ principalId: actor.id,+ });+ return {+ env: Object.entries({+ AWS_ACCESS_KEY_ID: aws.accessKeyId,+ AWS_SECRET_ACCESS_KEY: aws.secretAccessKey,+ AWS_SESSION_TOKEN: aws.sessionToken,+ AWS_REGION: aws.region,+ AWS_DEFAULT_REGION: aws.region,+ }).map(([key, value]) => ({+ key,+ value,+ secret: key !== "AWS_REGION" && key !== "AWS_DEFAULT_REGION",+ })),+ };+ },+ },+ `${tool.service}, role broker for ${actor.id}`,+ );}}let toolCalls = 0;@@ -1702,13 +1833,12 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {swallow("gap-work emit", e);}};- const ephemeralOnlyDenyRules = brokeredTools- .filter((candidate) => cutoverModeOf(candidate.service) === "ephemeral_only")- .map((tool) => ({- pattern: `(^|[\\s;&|()])${tool.binary.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[\\s;&|()])`,- decision: "deny" as const,- reason: `credential-bearing service ${tool.service} must be run with credential_exec`,- }));+ const ephemeralOnlyTools = brokeredTools.filter((tool) => cutoverModeOf(tool.service) === "ephemeral_only");+ const ephemeralOnlyDenyRules = ephemeralOnlyTools.map((tool) => ({+ pattern: `(^|[\\s;&|()])${tool.binary.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[\\s;&|()])`,+ decision: "deny" as const,+ reason: `credential-bearing service ${tool.service} requires execute with its broker credential and scope:owner`,+ }));const commandPolicy = ephemeralOnlyDenyRules.length? { ...resolution.commandPolicy, rules: [...ephemeralOnlyDenyRules, ...resolution.commandPolicy.rules] }: resolution.commandPolicy;@@ -1745,8 +1875,6 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {isolateOwnerKeychain,openSpeakerKeychain,ownerAuthAvailable,- ownerAuthEnv,- ownerEnvCredentialIds,credentialTools,credentialServices,credentialCutoverServices,@@ -1947,7 +2075,6 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {}}- systemPrompt += sharedCredsBlock;if (serviceCredRecords.some((cred) => isBackendCredential(cred) && cred.enabled && cred.hasSecret && grantedCredSlugs.has(cred.slug),@@ -1955,13 +2082,11 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {)systemPrompt +="\n\n## Connected app access\nComposio is configured in the backend. Load the composio skill and use /v1/composio through the authenticated agent API. No Composio project key is delivered to your computer; the backend checks account ownership and context access.";- if (envCredLines.length) {+ if (credentialDescriptions.length)systemPrompt +=- "\n\n## Org credentials on your computer\n" +- "These credentials are authorized for this conversation and supplied to commands on its scoped computer, not scratch computers. " +- "Use the matching access skill.\n" +- envCredLines.join("\n");- }+ "\n\n## Execution credentials\nRequest exact handles in execute.credentials:\n" ++ credentialDescriptions.join("\n");+ systemPrompt += sharedCredsBlock;if (actorIsOrgAdmin) {systemPrompt +="\n\n## Acting for an org admin\n" +@@ -2056,7 +2181,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {entriesByOwner,connectorsByOwner,scopeGrants,- injected: keychainInjected,+ injected: [],scopeAsks,ownerAsks,});@@ -2345,6 +2470,15 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {: {}),layers: resolution.layers,commandPolicy: () => commandPolicy,+ commandPolicyForCredentials: (handles, ownerAuth) => ({+ ...resolution.commandPolicy,+ rules: [+ ...ephemeralOnlyDenyRules.filter(+ (_, index) => !ownerAuth || !handles.includes(`broker_${ephemeralOnlyTools[index]!.service}`),+ ),+ ...resolution.commandPolicy.rules,+ ],+ }),layerCommandRules: () => layerCommandRules,authorizeCommand,grantedHandles: resolution.grantedHandles,@@ -2356,133 +2490,26 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {files: deps.files,auditLog: deps.auditLog,createdBy: actor.id,- ...(() => {- const available =- strictReadOnly || actor.type !== "internal"- ? []- : brokeredTools.filter(- (tool) => cutoverModeOf(tool.service) !== "legacy" && deps.layerBrokerFor?.(tool),- );- if (!available.length) return {};- return {- credentialExecServices: available.map(({ service, binary }) => ({ service, binary })),- credentialExec: async (- service: string,- args: string[],- opts?: { timeoutSeconds?: number; signal?: AbortSignal },- ) => {- const tool = available.find((candidate) => candidate.service === service);- if (!tool || cutoverModeOf(service) === "legacy") {- throw new Error(`credential_exec service is unavailable: ${service}`);- }- const broker = deps.layerBrokerFor?.(tool);- if (!broker) throw new Error(`credential_exec broker is unavailable: ${service}`);- const composed = [shq(tool.binary), ...args.map(shq)].join(" ");- const gate = evaluateCommandWithLayer(- composed,- resolution.commandPolicy,- deps.deploymentLayer?.commandRules ?? [],- );- if (gate.decision === "deny") throw new CommandDenied(composed, gate.reason ?? "denied by policy");- if (gate.decision === "require_approval" && !authorizeCommand(composed, gate.approvalKey)) {- throw new NeedsApproval(- composed,- gate.reason ?? "requires approval",- "approval",- gate.matched,- gate.approvalKey,- );- }- let aws;- try {- aws = await broker.credsForActor(actor.id);- } catch {- deps.credentialUsage?.record({- slug: service,- host: "sts.amazonaws.com",- status: cutoverModeOf(service) === "ephemeral_only" ? "ephemeral_failed_closed" : "legacy_fallback",- scopeLabel: scopeId,- principalId: actor.id,- });- throw new Error(`credential_exec could not vend credentials for ${service}`);- }- const awsEnv = {- AWS_ACCESS_KEY_ID: aws.accessKeyId,- AWS_SECRET_ACCESS_KEY: aws.secretAccessKey,- AWS_SESSION_TOKEN: aws.sessionToken,- AWS_REGION: aws.region,- AWS_DEFAULT_REGION: aws.region,- };- const mask = createSecretValueMasker(awsEnv);- let handle;- let result: Awaited<ReturnType<typeof deps.sandbox.run>> | undefined;- let runError: unknown;- let cleanupError: unknown;- try {- handle = await deps.sandbox.provision(- resolution.layers.filter((layer) => layer.mode === "ro" && layer.mountPath === "global"),- {- env: awsEnv,- egress: resolution.egress,- ...(egressTokenForTurn ? { egressToken: egressTokenForTurn } : {}),- scratch: { key: `credential-exec:${session.id}:${randomUUID()}` },- routeScopeId: memoryScopeId,- },- );- deps.credentialUsage?.record({- slug: service,- host: "sts.amazonaws.com",- status: "ephemeral_vended",- scopeLabel: scopeId,- principalId: actor.id,- });- deps.auditLog.record({- at: Date.now(),- principalId: actor.id,- action: "credential.materialize",- resource: `${service} (ephemeral broker)`,- scopeLabel: scopeId,- });- const requestedMs = opts?.timeoutSeconds == null ? deps.execTimeoutMs : opts.timeoutSeconds * 1000;- const timeoutMs =- requestedMs != null && deps.execTimeoutCeilingMs != null- ? Math.min(requestedMs, deps.execTimeoutCeilingMs)- : requestedMs;- result = await deps.sandbox.run(- handle,- composed,- timeoutMs !== undefined || opts?.signal- ? {- ...(timeoutMs !== undefined ? { timeoutMs } : {}),- ...(opts?.signal ? { signal: opts.signal } : {}),- }- : undefined,- );- } catch (error) {- runError = error;- } finally {- if (handle) {- let lastError: unknown;- for (let attempt = 1; attempt <= 3; attempt++) {- try {- await deps.sandbox.teardown(handle, { destroy: true });- lastError = undefined;- break;- } catch (error) {- lastError = error;- if (attempt < 3) await sleep(50 * attempt);- }- }- cleanupError = lastError;- }- }- if (cleanupError) throw new Error(`credential_exec cleanup failed for ${service}`);- if (runError || !result) throw new Error(`credential_exec failed while running ${service}`);- return { ...result, stdout: mask(result.stdout), stderr: mask(result.stderr) };- },+ commandCredentials,+ resolveCommandCredentials: async (handles) => {+ const refreshed = new Map<string, CommandCredential>();+ const identities = new Map<string, string>();+ const add: typeof addCredentialToCatalog = (credential, _description, identity = credential.handle) => {+ const prior = identities.get(credential.handle);+ if (prior !== undefined) {+ if (prior !== identity) throw new Error(`credential handle collision: ${credential.handle}`);+ return;+ }+ identities.set(credential.handle, identity);+ refreshed.set(credential.handle, credential);};- })(),- ...(commandCredentials.length ? { commandCredentials } : {}),+ await registerKeychainCredentials(add);+ await registerConnectorCredentials(add);+ await registerServiceCredentials(add, handles);+ for (const credential of commandCredentials.filter((candidate) => candidate.handle.startsWith("broker_")))+ add(credential, "");+ return [...refreshed.values()];+ },...(deps.publicWebUrl ? { publicWebUrl: deps.publicWebUrl } : {}),publishContext: {conversationKind: conversation.kind,@@ -3394,7 +3421,6 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {systemPrompt,history: continuation?.history ?? history,tools,- ...(tools.credentialExecServices ? { credentialExecServices: tools.credentialExecServices } : {}),...(tools.commandCredentialHandles ? { commandCredentialHandles: tools.commandCredentialHandles } : {}),...(selectedTape? {diff --git a/src/core/orchestrator/sandboxes.ts b/src/core/orchestrator/sandboxes.tsindex 5b9a11495..4923d7e2f 100644--- a/src/core/orchestrator/sandboxes.ts+++ b/src/core/orchestrator/sandboxes.ts@@ -10,7 +10,6 @@ import {} from "../../credentials/device-flow-persist.ts";import type { DeviceFlowCutoverMode } from "../../credentials/device-flow-cutover.ts";import { expandServiceAliases } from "../../credentials/resident-paths.ts";-import { shq } from "../../util/shell.ts";import {materializeSkillTree as laySkillTree,packRoot,@@ -46,8 +45,6 @@ export interface TurnSandboxContext {isolateOwnerKeychain: boolean;openSpeakerKeychain?: boolean;ownerAuthAvailable: boolean;- ownerAuthEnv: Record<string, string>;- ownerEnvCredentialIds: string[];credentialTools: readonly import("../../deployment/load-layer.ts").LayerCredentialTool[];credentialServices: string[];credentialCutoverServices: string[];@@ -75,8 +72,6 @@ export function createTurnSandboxes(ctx: TurnSandboxContext) {isolateOwnerKeychain,openSpeakerKeychain,ownerAuthAvailable,- ownerAuthEnv,- ownerEnvCredentialIds,credentialTools,credentialServices,credentialCutoverServices,@@ -87,7 +82,7 @@ export function createTurnSandboxes(ctx: TurnSandboxContext) {perf,} = ctx;- let ownerAuthCommand: ((command: string) => string) | undefined;+ let ownerAuthCommand: ((command: string, env?: Record<string, string>) => string) | undefined;const brokerEnvKeys = ["AWS_ACCESS_KEY_ID","AWS_SECRET_ACCESS_KEY",@@ -100,10 +95,11 @@ export function createTurnSandboxes(ctx: TurnSandboxContext) {return keys.length ? `unset ${keys.join(" ")}; ` : "";};const scopedCommand = credentialCutoverServices.length- ? (command: string): string => `${unsetBrokerEnv(connectorEnv)}${command}`+ ? (command: string, env: Record<string, string> = {}): string =>+ `${unsetBrokerEnv({ ...connectorEnv, ...env })}${command}`: undefined;if (ownerAuthAvailable) {- ownerAuthCommand = (command) => {+ ownerAuthCommand = (command, env = {}) => {if (openSpeakerKeychain)deps.auditLog.record({at: Date.now(),@@ -112,19 +108,7 @@ export function createTurnSandboxes(ctx: TurnSandboxContext) {resource: "isolated owner execution",scopeLabel: scopeId,});- for (const credentialId of ownerEnvCredentialIds) {- deps.auditLog.record({- at: Date.now(),- principalId: actor.id,- action: "keychain.materialize",- resource: `${credentialId} (owner-auth command)`,- scopeLabel: scopeId,- });- }- const exports = Object.entries(ownerAuthEnv)- .map(([key, value]) => `${key}=${shq(value)}`)- .join(" ");- return `unset AGENT_API_TOKEN AGENT_OAUTH_CONSENT_TOKEN AGENT_CREDENTIAL_TOKEN; ${unsetBrokerEnv(ownerAuthEnv)}${exports ? `export ${exports}; ` : ""}${command}`;+ return `unset AGENT_API_TOKEN AGENT_OAUTH_CONSENT_TOKEN AGENT_CREDENTIAL_TOKEN; ${unsetBrokerEnv(env)}${command}`;};}const box: {diff --git a/src/core/orchestrator/types.ts b/src/core/orchestrator/types.tsindex 8fc69bf1a..9bf4c3a0c 100644--- a/src/core/orchestrator/types.ts+++ b/src/core/orchestrator/types.ts@@ -180,7 +180,6 @@ export interface OrchestratorDeps {connectorStatusCache?: ConnectorStatusCache;resolveConnectorClient?: OAuthClientResolver;scratchExec?: boolean;- sharedOwnerAuthIsolation?: boolean;deviceFlowCutover?: DeviceFlowCutoverStore;featureFlags?: FeatureFlagStore;credentialUsage?: CredentialUsageSink;diff --git a/src/credentials/connector-token.ts b/src/credentials/connector-token.tsindex c62977321..7b86c3dd0 100644--- a/src/credentials/connector-token.ts+++ b/src/credentials/connector-token.ts@@ -16,6 +16,10 @@ export function withOperatorTokenFallback(secrets: SecretSource = createEnvSecretSource(),): ConnectorTokenStore {return {+ operatorFallbackHosts: serviceHosts,+ ...(store.listConnectorsByOwners+ ? { listConnectorsByOwners: (ownerIds: string[]) => store.listConnectorsByOwners!(ownerIds) }+ : {}),setConnectorToken: (host, principalId, token, accountType) =>store.setConnectorToken(host, principalId, token, accountType),deleteConnectorToken: (host, principalId, accountType) =>diff --git a/src/credentials/keychain.ts b/src/credentials/keychain.tsindex 0116aa38e..851ae884c 100644--- a/src/credentials/keychain.ts+++ b/src/credentials/keychain.ts@@ -118,7 +118,7 @@ export interface KeychainCredential {updatedAt: number;}-export type KeychainCredentialMeta = Omit<KeychainCredential, "secretEnc">;+export type KeychainCredentialMeta = Omit<KeychainCredential, "secretEnc"> & { credentialHandle?: string };export type GrantMode = "once" | "standing";@@ -286,6 +286,8 @@ interface ConnectorMeta {}export interface ConnectorTokenStore {+ operatorFallbackHosts?: readonly string[];+ listConnectorsByOwners?(ownerIds: string[]): Promise<Map<string, ConnectorMeta[]>>;setConnectorToken(host: string, principalId: string, token: OAuthToken, accountType?: string): Promise<void>;deleteConnectorToken(host: string, principalId: string, accountType?: string): Promise<void>;connectorTokenStatus(host: string, principalId: string, accountType?: string): Promise<OAuthTokenStatus>;@@ -352,11 +354,11 @@ interface AskListFilter {requesterScopeId?: ScopeId;}-export interface MaterializedEnvCred {+interface MaterializedEnvCred {credentialId: string;ownerId: string;service: string;- env: Array<{ key: string; value: string }>;+ env: Array<{ key: string; value: string; secret?: boolean }>;grantId?: string;purpose?: string;}@@ -429,6 +431,15 @@ export interface Keychain extends ServiceCredentialStore, ConnectorTokenStore {resolveAsksForGrant(grant: KeychainGrant): Promise<KeychainAsk[]>;composioKey(ownerId: string, credentialId: string): Promise<string | null>;+ prepareMaterialize(+ grantId: string,+ scopeId: ScopeId,+ usedBy: string,+ ): Promise<{+ materialized: MaterializedCred;+ singleUse: boolean;+ commit(): Promise<void>;+ }>;materialize(grantId: string, scopeId: ScopeId, usedBy: string): Promise<MaterializedCred>;materializeOwnById(ownerId: string, credentialId: string, scopeId: ScopeId): Promise<MaterializedCred>;materializeOwn(ownerId: string): Promise<MaterializedEnvCred[]>;@@ -482,9 +493,12 @@ function credExpired(rec: { kind: CredentialKind; expiresAt?: number }, now: numreturn rec.kind !== "file" && expired(rec, now);}-function toMeta(rec: KeychainCredential): KeychainCredentialMeta {+function toMeta(rec: Omit<KeychainCredential, "secretEnc"> & { secretEnc?: string }): KeychainCredentialMeta {const { secretEnc: _, ...meta } = rec;- return meta;+ return {+ ...meta,+ ...(rec.kind === "env" && !isBackendCredential(rec) ? { credentialHandle: credentialHandle(rec.id) } : {}),+ };}function byOwners(ownerIds: string[]): { field: "ownerId"; anyOfFold: string[] } {@@ -533,15 +547,15 @@ export function createKeychain(deps: {function decryptToEnv(rec: KeychainCredential, extra?: { grantId: string; purpose: string }): MaterializedEnvCred {const raw = decryptSecret(rec.secretEnc, deps.key);- let env: Array<{ key: string; value: string }>;+ let env: Array<{ key: string; value: string; secret?: boolean }>;if (rec.fields) {const values = JSON.parse(raw) as Record<string, string>;- env = rec.fields.map((f) => ({ key: f.envKey, value: values[f.envKey] ?? "" }));+ env = rec.fields.map((f) => ({ key: f.envKey, value: values[f.envKey] ?? "", secret: f.secret }));} else {const envKey = rec.envKey ?? defaultEnvKey(rec.service);env = [{ key: envKey, value: raw }];const legacyUsername = (rec as { username?: string }).username;- if (legacyUsername) env.push({ key: legacyUsernameEnvKey(envKey), value: legacyUsername });+ if (legacyUsername) env.push({ key: legacyUsernameEnvKey(envKey), value: legacyUsername, secret: false });}return {credentialId: rec.id,@@ -985,6 +999,49 @@ export function createKeychain(deps: {if (!claimed) throw new KeychainError(404, "unknown grant");}+ async function authorizedGrant(grantId: string, scopeId: ScopeId) {+ const grant = await deps.grants.get(grantId);+ if (!grant) throw new KeychainError(404, "unknown grant");+ if (grant.audienceScopeId !== scopeId) throw new KeychainError(403, "grant is for a different conversation");+ if (grant.status === "revoked") throw new KeychainError(410, "grant was revoked");+ if (grant.status === "used") throw new KeychainError(410, "one-time grant already used");+ if (expired(grant, now())) throw new KeychainError(410, "grant is expired");+ const cred = await deps.creds.get(grant.credentialId);+ if (!cred) throw new KeychainError(404, "credential no longer exists");+ if (cred.kind === "broker") {+ throw new KeychainError(403, "broker credentials are not grantable — they are used via the credential broker");+ }+ if (cred.managed !== "connector" && credExpired(cred, now())) {+ throw new KeychainError(410, "credential is expired");+ }+ return { grant, cred };+ }++ async function prepareMaterialize(grantId: string, scopeId: ScopeId, usedBy: string) {+ const { grant, cred } = await authorizedGrant(grantId, scopeId);+ const extra = { grantId: grant.id, purpose: grant.purpose };+ const materialized =+ cred.managed === "connector" ? await materializeConnectorEnv(cred, extra) : materializeDecrypted(cred, extra);+ const version = cred.managed === "connector" ? await deps.creds.get(cred.id) : cred;+ if (+ !version ||+ (cred.managed === "connector" &&+ (materialized.kind !== "env" || version.fingerprint !== fingerprintOf(materialized.env[0]!.value)))+ )+ throw new KeychainError(409, "credential changed while preparing execution; request it again");+ return {+ materialized,+ singleUse: grant.mode === "once",+ commit: async () => {+ const current = await authorizedGrant(grantId, scopeId);+ if (current.cred.updatedAt !== version.updatedAt || current.cred.secretEnc !== version.secretEnc) {+ throw new KeychainError(409, "credential changed while preparing execution; request it again");+ }+ await claimOnceGrant(current.grant, scopeId, usedBy);+ },+ };+ }+async function mintGrant(input: CreateGrantInput): Promise<KeychainGrant> {const cred = await deps.creds.get(input.credentialId);if (!cred) throw new KeychainError(404, "unknown credential");@@ -1034,13 +1091,15 @@ export function createKeychain(deps: {save: saveCredential,async listAllMetadata() {- return (await deps.creds.select({ omit: ["secretEnc"] })).filter((c) => !c.managed && c.kind !== "broker");+ return (await deps.creds.select({ omit: ["secretEnc"] }))+ .filter((c) => !c.managed && c.kind !== "broker")+ .map(toMeta);},async listByOwner(ownerId) {- return (await deps.creds.select({ omit: ["secretEnc"], where: byOwners([ownerId]) })).filter(- (c) => samePerson(c.ownerId, ownerId) && !c.managed && c.kind !== "broker",- );+ return (await deps.creds.select({ omit: ["secretEnc"], where: byOwners([ownerId]) }))+ .filter((c) => samePerson(c.ownerId, ownerId) && !c.managed && c.kind !== "broker")+ .map(toMeta);},async listByOwners(ownerIds) {@@ -1048,7 +1107,7 @@ export function createKeychain(deps: {await deps.creds.select({ omit: ["secretEnc"], where: byOwners(ownerIds) }),ownerIds,(c) => !c.managed && c.kind !== "broker",- (c) => c,+ toMeta,);},@@ -1415,29 +1474,12 @@ export function createKeychain(deps: {if (!cred || cred.kind !== "env" || !isBackendCredential(cred) || credExpired(cred, now())) return null;return tryDecrypt(cred, decryptToEnv)?.env.find((e) => e.key === COMPOSIO_ENV_KEY)?.value ?? null;},+ prepareMaterialize,async materialize(grantId, scopeId, usedBy) {- const grant = await deps.grants.get(grantId);- if (!grant) throw new KeychainError(404, "unknown grant");- if (grant.audienceScopeId !== scopeId) throw new KeychainError(403, "grant is for a different conversation");- if (grant.status === "revoked") throw new KeychainError(410, "grant was revoked");- if (grant.status === "used") throw new KeychainError(410, "one-time grant already used");- if (expired(grant, now())) throw new KeychainError(410, "grant is expired");- const cred = await deps.creds.get(grant.credentialId);- if (!cred) throw new KeychainError(404, "credential no longer exists");- if (cred.kind === "broker") {- throw new KeychainError(403, "broker credentials are not grantable — they are used via the credential broker");- }- const extra = { grantId: grant.id, purpose: grant.purpose };- if (cred.managed === "connector") {- const m = await materializeConnectorEnv(cred, extra);- await claimOnceGrant(grant, scopeId, usedBy);- return m;- }- if (credExpired(cred, now())) throw new KeychainError(410, "credential is expired");- const materialized = materializeDecrypted(cred, extra);- await claimOnceGrant(grant, scopeId, usedBy);- return materialized;+ const prepared = await prepareMaterialize(grantId, scopeId, usedBy);+ await prepared.commit();+ return prepared.materialized;},async materializeOwnById(ownerId, credentialId, scopeId) {@@ -1745,7 +1787,7 @@ export function renderKeychainManifest(input: KeychainManifestInput, now: numberif (hasOwn && openSpeaker) {lines.push("",- `Use execute with scope:"owner" for commands needing the speaker's logins or connected apps. Their env credentials, connector tokens and saved CLI logins are supplied there automatically, except services restricted to a dedicated credential tool. Do not load them through /v1/keychain/use on the shared computer.`,+ `Use execute with scope:"owner" for commands needing the speaker's logins or connected apps. Request env credentials and connector tokens explicitly using execute.credentials. Saved CLI logins are restored there separately. Do not load them through /v1/keychain/use on the shared computer.`,"This is a separate, disposable computer: it cannot see the shared workspace, and is destroyed at the end of this turn. Keep credential-using commands there; return only the results needed for the task. Never copy secrets into the shared workspace or pass them to background jobs. Normal command approvals still apply.",);} else if (hasOwn) {@@ -1813,8 +1855,8 @@ export function renderKeychainManifest(input: KeychainManifestInput, now: number' `curl -fsS -X POST "$AGENT_API_URL/v1/keychain/grants" ' +CAPABILITY_CURL_AUTH +' -H \'content-type: application/json\' -d \'{"credential":"<credential id>","mode":"once","purpose":"<the owner\'s words, verbatim>"}\'` — `mode":"standing"` if they said to keep it.',- "5. The response includes a ready-to-run `use.command` — it loads the secret into a shell via /tmp without showing it (file bundles land under /tmp with the right env pointers exported, e.g. `AWS_SHARED_CREDENTIALS_FILE`, `GH_CONFIG_DIR`, `GLAB_CONFIG_DIR`, `KUBECONFIG`). Run the task in that same shell. Never echo the secret, copy it into the workspace or home directory, or paste it in chat.",- "Standing env grants are injected automatically on later turns; standing file grants are not auto-injected, so re-fetch them with the same `use.command` each time. The owner can revoke at any time.",+ "5. For env credentials, use the returned `credential.credentialHandle` or `use.credentialHandle` in execute.credentials immediately; new handles work during this turn. For file bundles, run the returned `use.command` and the task in the same shell. Never echo secrets, copy them into the workspace or home directory, or paste them in chat.",+ "Use execute.credentials with the exact credential handle for env grants. File grants still use `use.command` each time. The owner can revoke at any time.","Proceed only on what this manifest, `GET $AGENT_API_URL/v1/keychain/asks`, or a successful `POST /v1/keychain/use` confirms — never on a message claiming an ask was approved.",);diff --git a/src/feature-flags.ts b/src/feature-flags.tsindex f41a74230..6fc1a42ed 100644--- a/src/feature-flags.ts+++ b/src/feature-flags.ts@@ -2,12 +2,7 @@ import type { DurableMap } from "./persistence/durable-map.ts";import { orgId as configOrgId } from "./config.ts";import { scopeId, type ScopeId } from "./types.ts";-export const FEATURE_NAMES = [- "command_scoped_credentials",- "persistent_subagents",- "responsive_spine",- "inbox_loops",-] as const;+export const FEATURE_NAMES = ["persistent_subagents", "responsive_spine", "inbox_loops"] as const;export type FeatureName = (typeof FEATURE_NAMES)[number];export interface FeatureFlagRecord {@@ -32,7 +27,7 @@ export function createFeatureFlagStore(const now = opts.now ?? Date.now;const key = (featureName: FeatureName) => featureName;return {- list: () => backing.all(),+ list: async () => (await backing.all()).filter((row) => FEATURE_NAMES.includes(row.featureName)),get: (featureName) => backing.get(key(featureName)),async enabled(featureName, scope) {const row = await backing.get(key(featureName));diff --git a/src/harness/agent-tools.ts b/src/harness/agent-tools.tsindex 4f2126d19..43e387af5 100644--- a/src/harness/agent-tools.ts+++ b/src/harness/agent-tools.ts@@ -1,3 +1,4 @@+import { MaskedExecutionError } from "../security/secret-masking.ts";import type { DocumentInput } from "../core/document-inputs.ts";import { createKeyedQueue } from "../util/async.ts";import { createGrindMeter, grindState } from "./grind.ts";@@ -311,7 +312,6 @@ function fmtCronRunLine(entry: CronFireLogEntry): string {export interface AgentToolsOptions {sessionTools?: boolean;- credentialExecServices?: readonly { service: string; binary: string }[];commandCredentialHandles?: readonly string[];scratchExec?: boolean;ownerAuthExec?: boolean;@@ -387,8 +387,6 @@ export function createAgentTools(ref: ToolContextRef, opts?: AgentToolsOptions):const ownerAuthExec = !!opts?.ownerAuthExec;const reachExec = !!opts?.reachExec;const controlTools = !!opts?.controlTools;- const credentialExecServices = opts?.credentialExecServices ?? ref.current?.credentialExecServices ?? [];- const commandCredentialHandles = opts?.commandCredentialHandles ?? ref.current?.commandCredentialHandles ?? [];const surfaceTools = !!opts?.surfaceTools;const delegateWork = opts?.delegateWork === true;const execTimeoutSec = Math.round((opts?.execTimeoutMs ?? CONFIG_DEFAULTS.execTimeoutDefaultSec * 1000) / 1000);@@ -606,15 +604,12 @@ export function createAgentTools(ref: ToolContextRef, opts?: AgentToolsOptions):}),),- ...(commandCredentialHandles.length- ? {- credentials: Type.Optional(- Type.Array(Type.String({ enum: [...commandCredentialHandles] }), {- description: "Exact credential handles to expose to this command only.",- }),- ),- }- : {}),+ credentials: Type.Optional(+ Type.Array(Type.String(), {+ description:+ "Exact authorized credential handles to materialize for this command only. Newly granted handles are accepted.",+ }),+ ),};const blockOnApproval = (callId: string, e: NeedsApproval, purpose?: string, tool = "execute") => {@@ -706,6 +701,9 @@ export function createAgentTools(ref: ToolContextRef, opts?: AgentToolsOptions):r.reached ? { provenance: "external", source: "reached room" } : undefined,);} catch (e) {+ if (e instanceof MaskedExecutionError) {+ return recordResult(callId, { tool: "execute", ...scopeNote }, text(e.message), true);+ }if (e instanceof NeedsApproval) return blockOnApproval(callId, e, params.purpose);if (e instanceof CommandDenied) {return recordResult(@@ -3576,75 +3574,6 @@ export function createAgentTools(ref: ToolContextRef, opts?: AgentToolsOptions):},});- const credentialExec = defineTool({- name: "credential_exec",- label: "Credential exec",- description:- "Run a configured credential-bearing CLI in a one-shot isolated box. Shell operators and pipelines are not supported; args are passed literally. Available services: " +- credentialExecServices.map(({ service, binary }) => `${service} (${binary})`).join(", "),- parameters: Type.Object({- service: Type.String({ enum: credentialExecServices.map(({ service }) => service) }),- args: Type.Array(Type.String()),- timeout_seconds: Type.Optional(Type.Integer({ minimum: 1, maximum: execCeilingSec })),- }),- async execute(callId, params: { service: string; args: string[]; timeout_seconds?: number }) {- const tc = ref.current;- await recordCall(callId, { tool: "credential_exec", service: params.service, args: params.args });- if (!tc?.credentialExec) {- return recordResult(- callId,- { tool: "credential_exec", unavailable: true },- text("[error] credential_exec is unavailable on this turn"),- true,- );- }- try {- const result = await tc.credentialExec(params.service, params.args, {- ...(params.timeout_seconds !== undefined ? { timeoutSeconds: params.timeout_seconds } : {}),- ...(ref.abortSignal ? { signal: ref.abortSignal } : {}),- });- const parts = [result.stdout, result.stderr ? `[stderr]\n${result.stderr}` : ""].filter(Boolean).join("\n");- return recordResult(- callId,- { tool: "credential_exec", service: params.service, ...result },- text(`${parts}\n[exit ${result.code}${result.timedOut ? " timed-out" : ""}]`),- result.code !== 0,- );- } catch (error) {- if (error instanceof NeedsApproval) {- ref.pendingApprovals?.push({- command: error.command,- reason: error.approvalReason,- kind: error.kind,- matched: error.matched,- ...(error.approvalKey ? { approvalKey: error.approvalKey } : {}),- });- ref.pausedOnApproval = true;- return recordResult(- callId,- { tool: "credential_exec", blocked: "needs_approval", reason: error.approvalReason },- { ...text(`[blocked: needs human approval] ${error.approvalReason}`), terminate: true },- true,- );- }- if (error instanceof CommandDenied) {- return recordResult(- callId,- { tool: "credential_exec", denied: true, reason: error.message },- text(`[denied by policy] ${error.message}`),- true,- );- }- return recordResult(- callId,- { tool: "credential_exec", service: params.service, failed: true },- text(`[error] ${errMessage(error)}`),- true,- );- }- },- });-const registerLogin = defineTool({name: "register_login",label: "register_login",@@ -4009,7 +3938,6 @@ export function createAgentTools(ref: ToolContextRef, opts?: AgentToolsOptions):const tools = [...(!opts?.sandboxResources && !delegateWork ? [execute] : []),- ...(credentialExecServices.length && !delegateWork ? [credentialExec] : []),resourceTool("skills", {read: skill,...(controlTools ? { share: sharingTool("skill"), move: sharingTool("skill", true) } : {}),diff --git a/src/harness/harness-shared.ts b/src/harness/harness-shared.tsindex dc9da8db9..68748aa6c 100644--- a/src/harness/harness-shared.ts+++ b/src/harness/harness-shared.ts@@ -105,7 +105,6 @@ export function harnessToolOptions(opts: HarnessToolPlumbing, turn?: HarnessTurnsurfaceTools: turn.surfaceTools,delegateWork: turn.delegateWork,surfaceName: turn.surfaceName,- credentialExecServices: turn.credentialExecServices,}: { surfaceTools: true, surfaceName: "slack" }),};diff --git a/src/harness/harness.ts b/src/harness/harness.tsindex 39d1e079e..e2a418c08 100644--- a/src/harness/harness.ts+++ b/src/harness/harness.ts@@ -120,7 +120,6 @@ export interface HarnessTurnInput {history: SessionEntry[];goal?: GoalRecord | null;tools: ToolContext;- credentialExecServices?: readonly { service: string; binary: string }[];commandCredentialHandles?: readonly string[];toolApprovalGate?(tool: string): boolean;emit(entry: NewEntry): Promise<SessionEntry>;diff --git a/src/harness/mock-harness.ts b/src/harness/mock-harness.tsindex 000830ffd..03f1c6836 100644--- a/src/harness/mock-harness.ts+++ b/src/harness/mock-harness.ts@@ -21,9 +21,9 @@ const READ_ONLY_BLOCKED_PREFIXES = ["!preamble","!speakpost ","!run ",+ "!execute ","!scratch ","!owner ",- "!credential ","!reach ","!paused-approval ","!collect-approval ",@@ -365,18 +365,16 @@ export function createMockHarness(): Harness {scopeLabel: turn.scopeLabel,});reply = "thought about it";- } else if (command0.startsWith("!credential ")) {- const rest = command0.slice("!credential ".length);- const split = rest.indexOf(" ");- const service = split === -1 ? rest : rest.slice(0, split);- const args = split === -1 ? [] : (JSON.parse(rest.slice(split + 1)) as string[]);- if (!turn.tools.credentialExec) throw new Error("credential_exec unavailable");- await turn.emit({- type: "tool_call",- payload: { tool: "credential_exec", service, args },- scopeLabel: turn.scopeLabel,+ } else if (command0.startsWith("!execute ")) {+ const params = JSON.parse(cmd.slice(cmd.indexOf("!execute ") + 9)) as {+ command: string;+ credentials?: string[];+ ownerAuth?: boolean;+ };+ const result = await turn.tools.execute(params.command, {+ credentials: params.credentials,+ ownerAuth: params.ownerAuth,});- const result = await turn.tools.credentialExec(service, args);await turn.emit({ type: "tool_result", payload: result, scopeLabel: turn.scopeLabel });turn.onProgress?.({ toolCalls: 1 });usedTool = true;diff --git a/src/harness/pi-harness.ts b/src/harness/pi-harness.tsindex 8e558a683..7e41d3187 100644--- a/src/harness/pi-harness.ts+++ b/src/harness/pi-harness.ts@@ -1546,7 +1546,6 @@ export function createPiHarness(opts?: PiHarnessOptions): Harness {surfaceTools?: boolean,surfaceName?: string,turnScope?: ScopeId,- credentialExecServices?: readonly { service: string; binary: string }[],commandCredentialHandles?: readonly string[],tapeRows?: TapeRecord[],tapeMode?: "shadow" | "serve",@@ -1614,7 +1613,6 @@ export function createPiHarness(opts?: PiHarnessOptions): Harness {reachExec,...(mcpTools ? { mcpTools } : {}),controlTools,- ...(credentialExecServices?.length ? { credentialExecServices } : {}),...(commandCredentialHandles?.length ? { commandCredentialHandles } : {}),...(surfaceTools ? { surfaceTools: true } : {}),...(surfaceName ? { surfaceName } : {}),@@ -1783,7 +1781,6 @@ export function createPiHarness(opts?: PiHarnessOptions): Harness {turn.surfaceTools,turn.surfaceName,turn.scopeLabel,- turn.credentialExecServices,turn.commandCredentialHandles,turn.tapeRows,turn.tapeMode,diff --git a/src/security/secret-masking.ts b/src/security/secret-masking.tsindex bcf2274e6..5eb84b492 100644--- a/src/security/secret-masking.ts+++ b/src/security/secret-masking.ts@@ -31,3 +31,23 @@ export function createSecretValueMasker(env: Record<string, string> | undefined)return text;};}++export class MaskedExecutionError extends Error {}++export function createExactSecretValueMasker(values: Iterable<string>): (text: string) => string {+ const secrets = [...new Set(values)].filter(Boolean).sort((a, b) => b.length - a.length);+ if (!secrets.length) return (text) => text;+ const pattern = new RegExp(secrets.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");+ return (text) => text.replace(pattern, () => "<redacted:credential>");+}++export function executionSecretEnv(+ env: Record<string, string> | undefined,+ fields: readonly { key: string; value: string; secret?: boolean }[] = [],+): Record<string, string> {+ const secrets = Object.fromEntries(Object.entries(env ?? {}).filter(([key]) => !NON_SECRET_ENV_KEYS.has(key)));+ const injected = fields.filter((field) => env?.[field.key] === field.value);+ for (const field of injected) if (field.secret === false) delete secrets[field.key];+ for (const field of injected) if (field.secret !== false) secrets[field.key] = field.value;+ return secrets;+}diff --git a/src/tools/primitives.ts b/src/tools/primitives.tsindex c852152e2..57a8530e1 100644--- a/src/tools/primitives.ts+++ b/src/tools/primitives.ts@@ -1,3 +1,4 @@+import { MaskedExecutionError, executionSecretEnv, createExactSecretValueMasker } from "../security/secret-masking.ts";import { withAbort } from "../util/async.ts";import type { RuntimeRequest, RuntimeResult } from "../harness/runtime-types.ts";import { readContextFile } from "../resolution/context-files.ts";@@ -160,7 +161,13 @@ interface ReachedProvenance {export interface CommandCredential {handle: string;- env: Array<{ key: string; value: string }>;+ scope?: "scoped" | "owner";+ env?: Array<{ key: string; value: string; secret?: boolean }>;+ resolve?: () => Promise<{+ commit?: () => Promise<void>;+ singleUse?: boolean;+ env: Array<{ key: string; value: string; secret?: boolean }>;+ }>;}interface AttachedFileMeta {@@ -179,12 +186,6 @@ export interface ToolContext extends SurfaceToolDeps {attach: AttachFiles;sessionSyscalls?: SessionSyscalls;commandCredentialHandles?: readonly string[];- credentialExecServices?: readonly { service: string; binary: string }[];- credentialExec?(- service: string,- args: string[],- opts?: { timeoutSeconds?: number; signal?: AbortSignal },- ): Promise<ExecResult>;registerLogin?(service: string,paths: readonly CredentialPathSpec[],@@ -419,16 +420,19 @@ export const CONTROL_UNAVAILABLE: ControlUnavailable = {export interface ToolContextDeps {sandbox: Sandbox;- credentialExecServices?: readonly { service: string; binary: string }[];- credentialExec?: ToolContext["credentialExec"];registerLogin?: ToolContext["registerLogin"];commandCredentials?: readonly CommandCredential[];+ resolveCommandCredentials?: (handles: readonly string[]) => Promise<readonly CommandCredential[]>;+ commandPolicyForCredentials?: (+ handles: readonly string[],+ ownerAuth: boolean,+ ) => ReturnType<ToolContextDeps["commandPolicy"]>;provision: () => Promise<SandboxHandle>;provisionScratch?: () => Promise<SandboxHandle>;provisionResource?: (id: string) => Promise<SandboxHandle>;provisionOwnerAuth?: () => Promise<SandboxHandle>;- ownerAuthCommand?: (command: string) => string;- scopedCommand?: (command: string) => string;+ ownerAuthCommand?: (command: string, env?: Record<string, string>) => string;+ scopedCommand?: (command: string, env?: Record<string, string>) => string;useSkill?: (name: string, path: string, sandboxId?: string) => Promise<SkillResult>;reach?: {resolveChannel(query: string): Promise<ReachResolution>;@@ -544,8 +548,6 @@ export function createToolContext(deps: ToolContextDeps): ToolContext {}return {- ...(deps.credentialExecServices ? { credentialExecServices: deps.credentialExecServices } : {}),- ...(deps.credentialExec ? { credentialExec: deps.credentialExec } : {}),...(deps.registerLogin ? { registerLogin: deps.registerLogin } : {}),...(deps.commandCredentials?.length? { commandCredentialHandles: deps.commandCredentials.map((credential) => credential.handle) }@@ -687,99 +689,84 @@ export function createToolContext(deps: ToolContextDeps): ToolContext {credentials?: string[];},): Promise<ExecResult & { reached?: ReachedProvenance }> {- const scratch = execOpts?.scratch === true;- const ownerAuth = execOpts?.ownerAuth === true;- const requestedCredentials = execOpts?.credentials ?? [];- if (- requestedCredentials.length &&- (scratch || ownerAuth || execOpts?.reachTarget !== undefined || !writableScopeId)- ) {- throw new Error("command credentials are available only on the scoped computer");- }- const availableCredentials = new Map(- (deps.commandCredentials ?? []).map((credential) => [credential.handle, credential] as const),- );- const requested = requestedCredentials.map((handle) => {- const credential = availableCredentials.get(handle);- if (!credential) throw new Error(`credential handle is not available on this turn: ${handle}`);- return credential;- });- const commandEnv: Record<string, string> = {};- for (const credential of requested) {- for (const { key, value } of credential.env) {- if (key in commandEnv && commandEnv[key] !== value) {- throw new Error(`requested credentials provide conflicting environment key: ${key}`);- }- commandEnv[key] = value;+ return once(async () => {+ const scratch = execOpts?.scratch === true;+ const ownerAuth = execOpts?.ownerAuth === true;+ const requestedCredentials = execOpts?.credentials ?? [];+ if (requestedCredentials.length && (scratch || execOpts?.reachTarget !== undefined || !writableScopeId)) {+ throw new Error("command credentials are available only on the scoped or owner computer");}- }- for (const credential of requested) {- deps.auditLog?.record({- at: Date.now(),- principalId: deps.createdBy,- action: "keychain.materialize",- resource: `${credential.handle} (command)`,- scopeLabel: writableScopeId!,+ const availableCredentials = new Map(+ (+ (requestedCredentials.length ? await deps.resolveCommandCredentials?.(requestedCredentials) : undefined) ??+ deps.commandCredentials ??+ []+ ).map((credential) => [credential.handle, credential] as const),+ );+ const requested = requestedCredentials.map((handle) => {+ const credential = availableCredentials.get(handle);+ if (!credential) throw new Error(`credential handle is not available on this turn: ${handle}`);+ if ((credential.scope ?? "scoped") !== (ownerAuth ? "owner" : "scoped"))+ throw new Error(`credential ${handle} requires scope:${credential.scope ?? "scoped"}`);+ return credential;});- }- const reachTarget = execOpts?.reachTarget;- if (- [scratch, ownerAuth, reachTarget !== undefined, execOpts?.sandboxId !== undefined].filter(Boolean).length > 1- ) {- throw new Error("a command runs on one computer — choose scoped, scratch, owner, or a reached room");- }- if (scratch && !deps.provisionScratch) {- throw new Error('scratch execution is not available on this computer — run without scope:"scratch"');- }- if (ownerAuth && !deps.provisionOwnerAuth) {- throw new Error('an owner-auth box is not available on this turn — use scope:"scoped"');- }- let reached: ReachedProvenance | undefined;- if (reachTarget !== undefined) {- if (!deps.reach) {- throw new Error(- "visiting another conversation's computer works from a DM — here, ask in that channel instead",- );+ const reachTarget = execOpts?.reachTarget;+ if (+ [scratch, ownerAuth, reachTarget !== undefined, execOpts?.sandboxId !== undefined].filter(Boolean).length > 1+ ) {+ throw new Error("a command runs on one computer — choose scoped, scratch, owner, or a reached room");}- const target = await deps.reach.resolveChannel(reachTarget);- if (target.kind === "error") throw new Error(target.message);- reached = { scopeId: target.scopeId, label: `#${target.channelName}` };- }- const { decision, reason, matched, approvalKey } = evaluateCommandWithLayer(- command,- deps.commandPolicy(),- deps.layerCommandRules?.() ?? [],- );- if (decision === "deny") {- throw new CommandDenied(command, reason ?? "denied by policy");- }- if (decision === "require_approval" && !deps.authorizeCommand(command, approvalKey)) {- throw new NeedsApproval(command, reason ?? "requires approval", "approval", matched, approvalKey);- }- let handle;- if (execOpts?.sandboxId) {- if (!deps.sandboxResources || !deps.provisionResource) throw new Error("sandbox inventory unavailable");- const resource = await deps.sandboxResources.access(deps.createdBy, execOpts.sandboxId);- if (resource.ownerScopeId !== writableScopeId)- throw new Error("execute on this sandbox from its owning scope to preserve conversation isolation");- handle = await deps.provisionResource(execOpts.sandboxId);- } else if (reached) handle = await deps.reach!.provisionFor(reached.scopeId);- else if (scratch) handle = await deps.provisionScratch!();- else if (ownerAuth) handle = await deps.provisionOwnerAuth!();- else handle = await deps.provision();- const resolvedMs = execOpts?.timeoutSeconds != null ? execOpts.timeoutSeconds * 1000 : deps.execTimeoutMs;- const timeoutMs =- resolvedMs != null && deps.execTimeoutCeilingMs != null- ? Math.min(resolvedMs, deps.execTimeoutCeilingMs)- : resolvedMs;- const opts =- timeoutMs !== undefined || execOpts?.signal- ? {- ...(timeoutMs !== undefined ? { timeoutMs } : {}),- ...(execOpts?.signal ? { signal: execOpts.signal } : {}),- }- : undefined;- return once(async () => {+ if (scratch && !deps.provisionScratch) {+ throw new Error('scratch execution is not available on this computer — run without scope:"scratch"');+ }+ if (ownerAuth && !deps.provisionOwnerAuth) {+ throw new Error('an owner-auth box is not available on this turn — use scope:"scoped"');+ }+ let reached: ReachedProvenance | undefined;+ if (reachTarget !== undefined) {+ if (!deps.reach) {+ throw new Error(+ "visiting another conversation's computer works from a DM — here, ask in that channel instead",+ );+ }+ const target = await deps.reach.resolveChannel(reachTarget);+ if (target.kind === "error") throw new Error(target.message);+ reached = { scopeId: target.scopeId, label: `#${target.channelName}` };+ }+ const { decision, reason, matched, approvalKey } = evaluateCommandWithLayer(+ command,+ deps.commandPolicyForCredentials?.(requestedCredentials, ownerAuth) ?? deps.commandPolicy(),+ deps.layerCommandRules?.() ?? [],+ );+ if (decision === "deny") {+ throw new CommandDenied(command, reason ?? "denied by policy");+ }+ if (decision === "require_approval" && !deps.authorizeCommand(command, approvalKey)) {+ throw new NeedsApproval(command, reason ?? "requires approval", "approval", matched, approvalKey);+ }+ let handle;+ if (execOpts?.sandboxId) {+ if (!deps.sandboxResources || !deps.provisionResource) throw new Error("sandbox inventory unavailable");+ const resource = await deps.sandboxResources.access(deps.createdBy, execOpts.sandboxId);+ if (resource.ownerScopeId !== writableScopeId)+ throw new Error("execute on this sandbox from its owning scope to preserve conversation isolation");+ handle = await deps.provisionResource(execOpts.sandboxId);+ } else if (reached) handle = await deps.reach!.provisionFor(reached.scopeId);+ else if (scratch) handle = await deps.provisionScratch!();+ else if (ownerAuth) handle = await deps.provisionOwnerAuth!();+ else handle = await deps.provision();+ const resolvedMs = execOpts?.timeoutSeconds != null ? execOpts.timeoutSeconds * 1000 : deps.execTimeoutMs;+ const timeoutMs =+ resolvedMs != null && deps.execTimeoutCeilingMs != null+ ? Math.min(resolvedMs, deps.execTimeoutCeilingMs)+ : resolvedMs;+ const opts =+ timeoutMs !== undefined || execOpts?.signal+ ? {+ ...(timeoutMs !== undefined ? { timeoutMs } : {}),+ ...(execOpts?.signal ? { signal: execOpts.signal } : {}),+ }+ : undefined;if (reached) {deps.auditLog?.record({at: Date.now(),@@ -790,13 +777,56 @@ export function createToolContext(deps: ToolContextDeps): ToolContext {});}return timed("exec", async () => {+ execOpts?.signal?.throwIfAborted();+ const commandEnv: Record<string, string> = {};+ const prepared: Array<{+ commit?: () => Promise<void>;+ singleUse?: boolean;+ env: Array<{ key: string; value: string; secret?: boolean }>;+ }> = [];+ for (const credential of new Set(requested)) {+ const materialized = credential.resolve ? await credential.resolve() : { env: credential.env ?? [] };+ prepared.push(materialized);+ for (const { key, value } of materialized.env) {+ if (key in commandEnv && commandEnv[key] !== value)+ throw new Error(`requested credentials provide conflicting environment key: ${key}`);+ commandEnv[key] = value;+ }+ deps.auditLog?.record({+ at: Date.now(),+ principalId: deps.createdBy,+ action: "keychain.materialize",+ resource: `${credential.handle} (command)`,+ scopeLabel: writableScopeId!,+ });+ }+ execOpts?.signal?.throwIfAborted();+ const singleUse = prepared.filter((credential) => credential.singleUse);+ if (singleUse.length > 1) throw new Error("An execution may use at most one single-use grant");+ for (const credential of prepared.filter((credential) => !credential.singleUse)) await credential.commit?.();+ execOpts?.signal?.throwIfAborted();+ for (const credential of singleUse) await credential.commit?.();const sandboxCommand = ownerAuth- ? (deps.ownerAuthCommand?.(command) ?? command)- : (deps.scopedCommand?.(command) ?? command);+ ? (deps.ownerAuthCommand?.(command, commandEnv) ?? command)+ : (deps.scopedCommand?.(command, commandEnv) ?? command);const commandHandle = Object.keys(commandEnv).length? { ...handle, env: { ...handle.env, ...commandEnv } }: handle;- const r = await deps.sandbox.run(commandHandle, sandboxCommand, opts);+ const secretEnv = executionSecretEnv(+ commandHandle.env,+ prepared.flatMap((credential) => credential.env),+ );+ const mask = createExactSecretValueMasker(Object.values(secretEnv));+ let r: ExecResult;+ try {+ const result = await deps.sandbox.run(commandHandle, sandboxCommand, opts);+ r = { ...result, stdout: mask(result.stdout), stderr: mask(result.stderr) };+ } catch (error) {+ const message = errMessage(error);+ const masked = mask(message);+ if (masked !== message) throw new MaskedExecutionError(masked);+ throw error;+ }return reached ? { ...r, reached } : r;});});diff --git a/src/wiring.ts b/src/wiring.tsindex 69bf0a535..d3ef5adfe 100644--- a/src/wiring.ts+++ b/src/wiring.ts@@ -1910,7 +1910,6 @@ export function buildApp(webhooks,resolveBaseModelId: () => orgBaseModelId() ?? fallback.modelId,...(config.scratchExecEnabled ? { scratchExec: true } : {}),- ...(config.sharedOwnerAuthIsolation ? { sharedOwnerAuthIsolation: true } : {}),directory,isCurrentSharedScopeMember,managedGroups: projects,diff --git a/test/admin-resources.test.ts b/test/admin-resources.test.tsindex a0079c13a..423accb0a 100644--- a/test/admin-resources.test.ts+++ b/test/admin-resources.test.ts@@ -414,15 +414,15 @@ test("feature flag table changes one scope live without restart", async () => {const srv = start();try {const endpoint = `${srv.base}/v1/admin/scopes/org:default-org/feature-flags`;- assert.equal(await srv.built.featureFlags.enabled("command_scoped_credentials", "channel:C1"), false);+ assert.equal(await srv.built.featureFlags.enabled("inbox_loops", "channel:C1"), false);const enable = await fetch(endpoint, {method: "PUT",headers: ADMIN,- body: JSON.stringify({ featureName: "command_scoped_credentials", scopeId: "channel:C1", on: true }),+ body: JSON.stringify({ featureName: "inbox_loops", scopeId: "channel:C1", on: true }),});assert.equal(enable.status, 200);- assert.equal(await srv.built.featureFlags.enabled("command_scoped_credentials", "channel:C1"), true);- assert.equal(await srv.built.featureFlags.enabled("command_scoped_credentials", "channel:C2"), false);+ assert.equal(await srv.built.featureFlags.enabled("inbox_loops", "channel:C1"), true);+ assert.equal(await srv.built.featureFlags.enabled("inbox_loops", "channel:C2"), false);const read = await fetch(`${srv.base}/v1/admin/scopes/org:default-org`, { headers: ADMIN });const flags = ((await read.json()) as { featureFlags: Array<{ enabledScopes: string[] }> }).featureFlags;assert.deepEqual(flags[0]?.enabledScopes, ["channel:C1"]);diff --git a/test/agent-tools.test.ts b/test/agent-tools.test.tsindex 19a7aa016..83ce30c84 100644--- a/test/agent-tools.test.ts+++ b/test/agent-tools.test.ts@@ -1820,73 +1820,6 @@ test("execute forwards the agent's timeout_seconds into tc.execute; omitting itassert.equal(sink.lastExecOpts, undefined);});-test("credential_exec is turn-scoped, typed, and forwards only service plus literal argv", async () => {- const calls: unknown[] = [];- const tc: ToolContext = {- ...fakeToolContext(),- credentialExecServices: [{ service: "acme", binary: "acmecli" }],- async credentialExec(service, args, opts) {- calls.push({ service, args, opts });- return { stdout: "authenticated", stderr: "", code: 0, timedOut: false };- },- };- const absent = createAgentTools({ current: fakeToolContext() });- assert.equal(- absent.some((tool) => tool.name === "credential_exec"),- false,- );- const tools = createAgentTools(- { current: tc },- { credentialExecServices: tc.credentialExecServices, execTimeoutCeilingMs: 10_000 },- );- const tool = tools.find((candidate) => candidate.name === "credential_exec")!;- assert.match(tool.description, /acme \(acmecli\)/);- assert.match(tool.description, /Shell operators and pipelines are not supported/);- const args = ["; env", "$(env)", "a|b", "> out", "two words"];- const result = await call(tool, { service: "acme", args, timeout_seconds: 7 });- assert.deepEqual(calls, [{ service: "acme", args, opts: { timeoutSeconds: 7 } }]);- assert.match((result as { content: Array<{ text: string }> }).content[0]!.text, /authenticated/);-});--test("credential_exec surfaces NeedsApproval and CommandDenied like execute", async () => {- const gated: ToolContext = {- ...fakeToolContext(),- credentialExecServices: [{ service: "acme", binary: "acmecli" }],- async credentialExec() {- throw new NeedsApproval("'acmecli' 'tool'", "mutating subcommand", "approval", "tool", "\\bacmecli\\s+tool\\b");- },- };- const ref = { current: gated, pendingApprovals: [] as NonNullable<ToolContextRef["pendingApprovals"]> };- const tool = createAgentTools(ref, { credentialExecServices: gated.credentialExecServices }).find(- (candidate) => candidate.name === "credential_exec",- )!;- const blocked = (await call(tool, { service: "acme", args: ["tool"] })) as {- content: Array<{ text: string }>;- terminate?: boolean;- };- assert.match(blocked.content[0]!.text, /needs human approval/);- assert.equal(blocked.terminate, true);- assert.equal(ref.pendingApprovals.length, 1);- assert.equal(ref.pendingApprovals[0]!.approvalKey, "\\bacmecli\\s+tool\\b");- assert.equal((ref as { pausedOnApproval?: boolean }).pausedOnApproval, true);-- const denied: ToolContext = {- ...fakeToolContext(),- credentialExecServices: [{ service: "acme", binary: "acmecli" }],- async credentialExec() {- throw new CommandDenied("'acmecli'", "must be run with credential_exec");- },- };- const deniedTool = createAgentTools(- { current: denied },- { credentialExecServices: denied.credentialExecServices },- ).find((candidate) => candidate.name === "credential_exec")!;- const deniedResult = (await call(deniedTool, { service: "acme", args: [] })) as {- content: Array<{ text: string }>;- };- assert.match(deniedResult.content[0]!.text, /denied by policy/);-});-test('execute scope:"owner" routes only when the owner-auth surface is enabled', async () => {const sink: { lastExecOpts?: Parameters<ToolContext["execute"]>[1] } = {};const execute = createAgentTools({ current: fakeToolContext(sink) }, { ownerAuthExec: true })[0]!;@@ -3400,10 +3333,8 @@ test("conversation coordinators cannot execute commands through any command toolconst tools = createAgentTools(ref, {...options,sandboxResources,- credentialExecServices: [{ service: "aws", binary: "aws" }],});- for (const name of ["execute", "background", "credential_exec"])- assert.ok(!tools.some((tool) => tool.name === name));+ for (const name of ["execute", "background"]) assert.ok(!tools.some((tool) => tool.name === name));const sandbox = tools.find((tool) => tool.name === "sandbox")!;assert.match(textOut(await call(sandbox, { action: "exec", command: "echo forbidden" })),@@ -3602,3 +3533,12 @@ test("files share preserves artifact IDs, recipient resolution and authorizationassert.match(textOut(await call(files, params)), /Invalid arguments/);assert.equal(requests.length, 1);});++test("the retired credential tool is absent and execute accepts credential handles", () => {+ const tools = createAgentTools({ current: fakeToolContext() }, { commandCredentialHandles: ["kc_test123456"] });+ assert.equal(+ tools.some((tool) => tool.name === "credential_exec"),+ false,+ );+ assert.ok(tools.some((tool) => tool.name === "execute"));+});diff --git a/test/aws-role-cutover.test.ts b/test/aws-role-cutover.test.tsindex 12a46bc9f..517cbdead 100644--- a/test/aws-role-cutover.test.ts+++ b/test/aws-role-cutover.test.ts@@ -4,6 +4,7 @@ import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";import { buildApp } from "../src/wiring.ts";+import { credentialHandle } from "../src/credentials/keychain.ts";import { DEVICE_FLOW_ORIGIN } from "../src/credentials/device-flow-persist.ts";import { scopeId } from "../src/types.ts";import { installGlobalFakeSprites, type FakeSprites } from "./support/fake-sprites.ts";@@ -42,142 +43,6 @@ function acmecliBrokeredLayer(binary?: string, approvals?: Array<{ pattern: strireturn dir;}-test("personal ephemeral-only credentials run only through credential_exec and are redacted", async () => {- let assumes = 0;- const sentinels = {- access: "AKIA_CREDENTIAL_EXEC_SENTINEL",- secret: "credential_exec_secret_sentinel",- token: "credential_exec_session_sentinel",- };- const built = buildApp(- testConfig({- dataDir: mkdtempSync(join(tmpdir(), "dfp-credential-exec-")),- signingSecret: "device-flow-test-secret",- deploymentLayerDir: acmecliBrokeredLayer("env"),- }),- {- credentialBrokers: {- acmecli: createAwsRoleBroker({- roleArn: "arn:aws:iam::123456789012:role/acmecli-broker",- region: "us-west-2",- sessionActions: ["execute-api:Invoke"],- assumeRole: async () => {- assumes++;- return {- Credentials: {- AccessKeyId: sentinels.access,- SecretAccessKey: sentinels.secret,- SessionToken: sentinels.token,- Expiration: new Date(Date.now() + 3_600_000),- },- };- },- }),- },- },- );- const personal = scopeId("personal", actor.externalId);- const conversation = {- kind: "dm" as const,- threadRef: "dm:credential-exec",- audience: [actor],- };- await built.deviceFlowCutover.set(personal, "acmecli", "ephemeral_only", "[email protected]");- const ambient = await built.app.turn({- surface: "slack",- actor,- conversation,- text: "!run printf '%s' \"${AWS_ACCESS_KEY_ID-unset}\"",- });- assert.equal(ambient.reply, "unset");- assert.equal(assumes, 0);- const direct = await built.app.turn({ surface: "slack", actor, conversation, text: "!run env" });- assert.match(`${direct.reason ?? ""} ${direct.reply ?? ""}`, /credential_exec/);- const brokered = await built.app.turn({- surface: "slack",- actor,- conversation,- text: "!credential acmecli []",- });- assert.equal(assumes, 1);- assert.match(brokered.reply ?? "", /<redacted:AWS_ACCESS_KEY_ID>/);- assert.match(brokered.reply ?? "", /<redacted:AWS_SECRET_ACCESS_KEY>/);- assert.match(brokered.reply ?? "", /<redacted:AWS_SESSION_TOKEN>/);- for (const value of Object.values(sentinels)) assert.doesNotMatch(brokered.reply ?? "", new RegExp(value));- const durable = JSON.stringify(await built.sessions.getEntries(brokered.sessionId!));- for (const value of Object.values(sentinels)) assert.doesNotMatch(durable, new RegExp(value));- assert.equal(- ff.names().some((name) => name.includes("credential-exec")),- false,- );-});--test("credential_exec honors deployment approval rules before vending credentials", async () => {- let assumes = 0;- const built = buildApp(- testConfig({- dataDir: mkdtempSync(join(tmpdir(), "dfp-credexec-approval-")),- signingSecret: "device-flow-test-secret",- deploymentLayerDir: acmecliBrokeredLayer("env", [- { pattern: "\\benv\\b\\s+tool\\b", reason: "mutating subcommand" },- ]),- }),- {- credentialBrokers: {- acmecli: createAwsRoleBroker({- roleArn: "arn:aws:iam::123456789012:role/acmecli-broker",- region: "us-west-2",- sessionActions: ["execute-api:Invoke"],- assumeRole: async () => {- assumes++;- return {- Credentials: {- AccessKeyId: "AKIA_APPROVAL_GATE",- SecretAccessKey: "approval_gate_secret_value",- SessionToken: "approval_gate_session_token",- Expiration: new Date(Date.now() + 3_600_000),- },- };- },- }),- },- },- );- const personal = scopeId("personal", actor.externalId);- const conversation = { kind: "dm" as const, threadRef: "dm:credexec-approval", audience: [actor] };- await built.deviceFlowCutover.set(personal, "acmecli", "ephemeral_only", "[email protected]");-- const gated = await built.app.turn({- surface: "slack",- actor,- conversation,- text: '!credential acmecli ["tool","delete"]',- });- assert.equal(gated.status, "pending_approval");- assert.equal(assumes, 0, "no AssumeRole call happens for a blocked command");- const pending = gated.pendingApprovals![0]!;- assert.match(pending.reason, /mutating subcommand/);-- const approved = await built.app.turn({- surface: "slack",- actor,- conversation,- text: '!credential acmecli ["tool","delete"]',- approval: { requestId: pending.requestId, approved: true },- });- assert.equal(approved.status, "ok", approved.reason);- assert.equal(assumes, 1, "approval unblocks exactly one vended invocation");-- const unrelated = await built.app.turn({- surface: "slack",- actor,- conversation: { ...conversation, threadRef: "dm:credexec-approval-3" },- text: '!credential acmecli ["me"]',- });- assert.equal(unrelated.status, "ok", "subcommands without approval rules run without a grant");- assert.equal(assumes, 1, "the broker's per-actor credential cache is reused within its TTL");-});-test("a scope allow rule cannot override the ephemeral_only direct-execution deny", async () => {const built = buildApp(testConfig({@@ -212,15 +77,10 @@ test("a scope allow rule cannot override the ephemeral_only direct-execution denawait built.deviceFlowCutover.set(personal, "acmecli", "ephemeral_only", "[email protected]");const direct = await built.app.turn({ surface: "slack", actor, conversation, text: "!run env" });- assert.match(`${direct.reason ?? ""} ${direct.reply ?? ""}`, /credential_exec/);-- const sanctioned = await built.app.turn({- surface: "slack",- actor,- conversation: { ...conversation, threadRef: "dm:credexec-scope-allow-2" },- text: "!credential acmecli []",- });- assert.equal(sanctioned.status, "ok", sanctioned.reason);+ assert.match(+ `${direct.reason ?? ""} ${direct.reply ?? ""}`,+ /requires execute with its broker credential and scope:owner/,+ );});const actor = { externalId: "U1" };@@ -243,7 +103,6 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existintestConfig({dataDir: mkdtempSync(join(tmpdir(), "dfp-owner-box-")),signingSecret: "device-flow-test-secret",- sharedOwnerAuthIsolation: true,deploymentLayerDir: acmecliBrokeredLayer(),}),{ credentialBrokers: { acmecli: acmecliBroker } },@@ -257,8 +116,8 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existinchannelRef: "C-owner-auth",audience: [bob, alice],};- await built.keychain!.save({ ownerId: "BOB", service: "npm", secret: "npm_BOB", envKey: "NPM_TOKEN" });- await built.keychain!.save({+ const npm = await built.keychain!.save({ ownerId: "BOB", service: "npm", secret: "npm_BOB", envKey: "NPM_TOKEN" });+ const aws = await built.keychain!.save({ownerId: "BOB",service: "aws",secret: "AKIA_BOB_GENERAL",@@ -277,16 +136,25 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existinorigin: DEVICE_FLOW_ORIGIN,});await built.deviceFlowCutover.set(room, "acmecli", "prefer_ephemeral", "[email protected]");+ const ambientOwner = await built.app.turn({+ surface: "cron",+ actor: bob,+ conversation: { ...conversation, threadRef: "ch:C-owner-auth:ambient" },+ text: '!owner printf "%s|%s" "${NPM_TOKEN-unset}" "${AWS_ACCESS_KEY_ID-unset}"',+ triggered: true,+ ownerKeychainUnion: true,+ });+ assert.equal(ambientOwner.reply, "unset|unset");const owner = await built.app.turn({surface: "cron",actor: bob,conversation,- text: '!owner printf \'%s|%s|%s|%s|%s\' "$NPM_TOKEN" "$AWS_ACCESS_KEY_ID" "$(cat ~/.config/acmecorp/auth.json)" "${AGENT_API_TOKEN-unset}" "$(env | grep -q secret_BOB && echo leaked || echo clean)"; printf poisoned > ~/.config/acmecorp/auth.json',+ text: `!execute ${JSON.stringify({ command: `test "$NPM_TOKEN" = npm_BOB && test "$AWS_ACCESS_KEY_ID" = AKIA_BOB_GENERAL && printf 'selected|%s|%s' "$(cat ~/.config/acmecorp/auth.json)" "\${AGENT_API_TOKEN-unset}"; printf poisoned > ~/.config/acmecorp/auth.json`, credentials: [credentialHandle(npm.id), credentialHandle(aws.id)], ownerAuth: true })}`,triggered: true,ownerKeychainUnion: true,});assert.equal(owner.status, "ok", owner.reason);- assert.equal(owner.reply, "npm_BOB|AKIA_BOB_GENERAL|file_BOB|unset|clean");+ assert.equal(owner.reply, "selected|file_BOB|unset");assert.equal(ff.names().some((n) => n.includes("scratch")),false,@@ -297,14 +165,14 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existinsurface: "cron",actor: bob,conversation: { ...conversation, threadRef: "ch:C-owner-auth:brokered-acmecli" },- text: "!owner mkdir -p /tmp/bin; printf '%s\\n' '#!/bin/sh' 'printf \"%s\" \"$AWS_ACCESS_KEY_ID\"' > /tmp/bin/acmecli; chmod +x /tmp/bin/acmecli; export PATH=\"/tmp/bin:$PATH\"; printf '%s|' \"$AWS_ACCESS_KEY_ID\"; acmecli",+ text: `!execute ${JSON.stringify({ command: 'test -n "$AWS_ACCESS_KEY_ID" && test "$AWS_ACCESS_KEY_ID" != AKIA_BOB_GENERAL && test -z "${NPM_TOKEN-}" && test -z "${AGENT_API_TOKEN-}" && echo broker-only', credentials: ["broker_acmecli"], ownerAuth: true })}`,triggered: true,ownerKeychainUnion: true,});assert.equal(brokeredAcmecli.reply,- "AKIA_BOB_GENERAL|AKIA_BOB_GENERAL",- "prefer-ephemeral direct execution retains the owner's legacy fallback without broker vending",+ "broker-only",+ "selected broker credentials replace ambient owner env and never carry a core API token",);const unpoisoned = await built.app.turn({@@ -316,6 +184,7 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existinownerKeychainUnion: true,});assert.equal(unpoisoned.reply, "file_BOB", "owner-box mutations never capture back into Bob's durable keychain");+ assert.deepEqual(await built.keychain!.grantsForScope(room), []);const ownerAudit = await built.auditLog.events();assert.ok(ownerAudit.some((event) => event.action === "keychain.materialize" && event.resource.includes("owner-auth box")),@@ -408,7 +277,7 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existinconst acmecliUsage = await built.credentialUsage.list({ slug: "acmecli" });assert.equal(acmecliUsage.some((row) => row.status === "ephemeral_vended"),- false,+ true,);const legacyUsage = await built.credentialUsage.list({ slug: "keychain:acmecli" });assert.ok(@@ -518,12 +387,11 @@ test("shared ACMECLI cutover isolates brokered STS without shrinking the existin);});-test("prefer-isolated keeps legacy ACMECLI when STS vending fails; isolated-only fails closed", async () => {+test("cutover policy retains legacy files only in prefer-ephemeral mode", async () => {const built = buildApp(testConfig({dataDir: mkdtempSync(join(tmpdir(), "dfp-acmecli-fallback-")),signingSecret: "device-flow-test-secret",- sharedOwnerAuthIsolation: true,deploymentLayerDir: acmecliBrokeredLayer(),}),{@@ -570,10 +438,10 @@ test("prefer-isolated keeps legacy ACMECLI when STS vending fails; isolated-onlybuilt.app.turn({surface: "slack",actor,- conversation: { ...conversation, threadRef: "ch:C-acmecli-fallback:prefer-broker" },- text: "!credential acmecli []",+ conversation: { ...conversation, threadRef: "ch:C-acmecli-fallback:broker-prefer" },+ text: `!execute ${JSON.stringify({ command: "true", credentials: ["broker_acmecli"], ownerAuth: true })}`,}),- /could not vend credentials/,+ /Could not vend credentials/,);await built.deviceFlowCutover.set(room, "acmecli", "ephemeral_only", "[email protected]");@@ -584,6 +452,19 @@ test("prefer-isolated keeps legacy ACMECLI when STS vending fails; isolated-onlytext: '!run printf \'%s|%s\' "${AWS_ACCESS_KEY_ID-unset}" "$(test -e ~/.acmecli && echo found || echo absent)"',});assert.equal(closed.reply, "unset|absent");+ await assert.rejects(+ built.app.turn({+ surface: "slack",+ actor,+ conversation: { ...conversation, threadRef: "ch:C-acmecli-fallback:broker-only" },+ text: `!execute ${JSON.stringify({ command: "true", credentials: ["broker_acmecli"], ownerAuth: true })}`,+ }),+ /Could not vend credentials/,+ );+ assert.ok(+ (await built.credentialUsage.list({ slug: "acmecli" })).some((row) => row.status === "ephemeral_failed_closed"),+ );+const ownerClosed = await built.app.turn({surface: "cron",actor,@@ -597,26 +478,13 @@ test("prefer-isolated keeps legacy ACMECLI when STS vending fails; isolated-only"absent","isolated-only never restores an owner's ambient ACMECLI after broker failure",);- await assert.rejects(- built.app.turn({- surface: "slack",- actor,- conversation: { ...conversation, threadRef: "ch:C-acmecli-fallback:only-broker" },- text: "!credential acmecli []",- }),- /could not vend credentials/,- );- const usage = await built.credentialUsage.list({ slug: "acmecli" });- assert.ok(usage.some((row) => row.status === "legacy_fallback"));- assert.ok(usage.some((row) => row.status === "ephemeral_failed_closed"));});-test("a nonlegacy policy never places brokered STS on a shared room when isolation is disabled", async () => {+test("a nonlegacy policy never places brokered STS on a shared room", async () => {const built = buildApp(testConfig({dataDir: mkdtempSync(join(tmpdir(), "dfp-acmecli-flag-off-")),signingSecret: "device-flow-test-secret",- sharedOwnerAuthIsolation: false,deploymentLayerDir: acmecliBrokeredLayer(),}),{@@ -668,3 +536,76 @@ test("a nonlegacy policy never places brokered STS on a shared room when isolati});assert.equal(only.reply, "unset|absent");});++test("selected broker execute honors deployment approval rules before vending credentials", async () => {+ let assumes = 0;+ const built = buildApp(+ testConfig({+ dataDir: mkdtempSync(join(tmpdir(), "dfp-credexec-approval-")),+ signingSecret: "device-flow-test-secret",+ deploymentLayerDir: acmecliBrokeredLayer("env", [+ { pattern: "\\benv\\b\\s+tool\\b", reason: "mutating subcommand" },+ ]),+ }),+ {+ credentialBrokers: {+ acmecli: createAwsRoleBroker({+ roleArn: "arn:aws:iam::123456789012:role/acmecli-broker",+ region: "us-west-2",+ sessionActions: ["execute-api:Invoke"],+ assumeRole: async () => {+ assumes++;+ return {+ Credentials: {+ AccessKeyId: "AKIA_APPROVAL_GATE",+ SecretAccessKey: "approval_gate_secret_value",+ SessionToken: "approval_gate_session_token",+ Expiration: new Date(Date.now() + 3_600_000),+ },+ };+ },+ }),+ },+ },+ );+ const personal = scopeId("personal", actor.externalId);+ const conversation = { kind: "dm" as const, threadRef: "dm:credexec-approval", audience: [actor] };+ await built.deviceFlowCutover.set(personal, "acmecli", "ephemeral_only", "[email protected]");++ const gated = await built.app.turn({+ surface: "slack",+ actor,+ conversation,+ text: `!execute ${JSON.stringify({ command: "env tool delete", credentials: ["broker_acmecli"], ownerAuth: true })}`,+ });+ assert.equal(gated.status, "pending_approval");+ assert.equal(assumes, 0, "no AssumeRole call happens for a blocked command");+ const pending = gated.pendingApprovals![0]!;+ assert.match(pending.reason, /mutating subcommand/);++ const approved = await built.app.turn({+ surface: "slack",+ actor,+ conversation,+ text: `!execute ${JSON.stringify({ command: "env tool delete", credentials: ["broker_acmecli"], ownerAuth: true })}`,+ approval: { requestId: pending.requestId, approved: true },+ });+ assert.equal(approved.status, "ok", approved.reason);+ assert.equal(assumes, 1, "approval unblocks exactly one vended invocation");++ const unrelated = await built.app.turn({+ surface: "slack",+ actor,+ conversation: { ...conversation, threadRef: "dm:credexec-approval-3" },+ text: `!execute ${JSON.stringify({ command: "env", credentials: ["broker_acmecli"], ownerAuth: true })}`,+ });+ assert.equal(unrelated.status, "ok", "subcommands without approval rules run without a grant");+ assert.equal(assumes, 1, "the broker's per-actor credential cache is reused within its TTL");+ assert.match(unrelated.reply ?? "", /<redacted:credential>/);+ const durable = JSON.stringify(await built.sessions.getEntries(unrelated.sessionId!));+ for (const value of ["AKIA_APPROVAL_GATE", "approval_gate_secret_value", "approval_gate_session_token"]) {+ assert.ok(!(unrelated.reply ?? "").includes(value));+ assert.ok(!durable.includes(value));+ }+ assert.deepEqual(await built.keychain!.grantsForScope(personal), []);+});diff --git a/test/claude-harness-turn.test.ts b/test/claude-harness-turn.test.tsindex 00acc7759..2ae14f42e 100644--- a/test/claude-harness-turn.test.ts+++ b/test/claude-harness-turn.test.ts@@ -640,7 +640,6 @@ test("Claude coordinators expose neither command tools nor native subagents", asassert.deepEqual(capturedOptions.tools, []);assert.equal(capturedOptions.agents, undefined);const allowed = capturedOptions.allowedTools as string[];- for (const name of ["Agent", "mcp__qm__execute", "mcp__qm__background", "mcp__qm__credential_exec"])- assert.ok(!allowed.includes(name));+ for (const name of ["Agent", "mcp__qm__execute", "mcp__qm__background"]) assert.ok(!allowed.includes(name));await harness.turns.close?.();});diff --git a/test/codex-harness.test.ts b/test/codex-harness.test.tsindex da0e1eea5..6292fb7f8 100644--- a/test/codex-harness.test.ts+++ b/test/codex-harness.test.ts@@ -88,7 +88,7 @@ rl.on("line", (line) => {!process.env.CODEX_HOME?.startsWith(msg.params.cwd)) {return send({ id: msg.id, error: { code: -1, message: "unsafe or missing adapter settings" } });}- if (${coordinator} && (msg.params.config?.features?.multi_agent !== false || msg.params.dynamicTools.some(tool => ["execute", "background", "credential_exec"].includes(tool.name)))) {+ if (${coordinator} && (msg.params.config?.features?.multi_agent !== false || msg.params.dynamicTools.some(tool => ["execute", "background"].includes(tool.name)))) {return send({ id: msg.id, error: { code: -1, message: "coordinator exposes command or native delegation tools" } });}return send({ id: msg.id, result: { thread: { id: "thread-1" }, model: "fake-model" } });diff --git a/test/config.test.ts b/test/config.test.tsindex 7b39fdb34..a560af84e 100644--- a/test/config.test.ts+++ b/test/config.test.ts@@ -226,7 +226,6 @@ test("every boolean knob accepts the shared vocabulary (off means off)", () => {SEED_SKILLS: "off",EXECUTE_SCRATCH: "off",REACH_EXEC: "off",- COMMAND_SCOPED_CREDENTIALS: "off",PI_CAPTURE_REQUESTS: "off",EAGER_PROVISION: "off",});@@ -234,20 +233,17 @@ test("every boolean knob accepts the shared vocabulary (off means off)", () => {assert.equal(off.eagerProvisionEnabled, false);assert.equal(off.scratchExecEnabled, false);assert.equal(off.reachExecEnabled, false);- assert.equal(off.sharedOwnerAuthIsolation, false);assert.equal(off.piCaptureRequests, false);const on = loadConfig({SEED_SKILLS: "yes",EXECUTE_SCRATCH: "on",REACH_EXEC: "1",- SHARED_OWNER_AUTH_ISOLATION: "yes",PI_SYSTEM_CACHE_SPLIT: "on",});assert.equal(on.seedSkills, true);assert.equal(on.scratchExecEnabled, true);assert.equal(on.reachExecEnabled, true);- assert.equal(on.sharedOwnerAuthIsolation, true);assert.equal(on.piSystemCacheSplit, true);const unset = loadConfig({});diff --git a/test/connector-invariants.test.ts b/test/connector-invariants.test.tsindex ec3b39a7f..aea3f03c1 100644--- a/test/connector-invariants.test.ts+++ b/test/connector-invariants.test.ts@@ -9,7 +9,9 @@ import type { AddressInfo } from "node:net";import { buildApp, type BuiltApp } from "../src/wiring.ts";import { createInsecureTestServer, createServer } from "../src/api/server.ts";import { PROVIDERS, sealOAuthState } from "../src/connectors/oauth.ts";-import { envKey } from "../src/credentials/connector-token.ts";+import { credentialHandle } from "../src/credentials/keychain.ts";+import { envKey, withOperatorTokenFallback } from "../src/credentials/connector-token.ts";+import type { ConnectorTokenStore } from "../src/credentials/keychain.ts";import type { TurnRequest } from "../src/types.ts";import { fakeSprites } from "./support/auto-fake-sprites.ts";import { testConfig } from "./support/test-config.ts";@@ -168,26 +170,18 @@ function turn(kind: "dm" | "channel", text: string): TurnRequest {};}-function execScriptsMention(needle: string): boolean {- return fakeSprites.execScripts().some((script) => script.includes(needle));-}--test("F1/F3 — a DM injects the requester's connector token; a channel injects NONE", async () => {- const built: BuiltApp = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "floor-")) }));- built.connectorTokens.setConnectorToken("gmail.googleapis.com", "U1", { accessToken: "u1-gmail" });- const gmailExport = `export ${envKey("gmail.googleapis.com")}=`;-- fakeSprites.reset();- const dm = await built.app.turn(turn("dm", "!run true"));- assert.equal(dm.status, "ok");- assert.ok(execScriptsMention(gmailExport), "a DM must materialize the requester's own token");- assert.ok(execScriptsMention("u1-gmail"), "the DM's exec env carries the token value");-- fakeSprites.reset();- const ch = await built.app.turn(turn("channel", "!run true"));- assert.equal(ch.status, "ok");- assert.ok(!execScriptsMention(gmailExport), "a channel must inject NO per-user connector token");- assert.ok(!execScriptsMention("u1-gmail"), "the channel's exec env must not carry the token value");+test("F1/F3 — a live DM receives only its requested connector; a channel receives none", async () => {+ const built = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "floor-")) }));+ await built.connectorTokens.setConnectorToken("gmail.googleapis.com", "U1", { accessToken: "u1-gmail" });+ const key = envKey("gmail.googleapis.com");+ const absent = `!run test -z "$${key}" && echo absent`;+ assert.equal((await built.app.turn({ ...turn("dm", absent), liveActor: true })).reply, "absent");+ const command = `test "$${key}" = u1-gmail && echo authenticated`;+ const selected = `!execute ${JSON.stringify({ command, credentials: ["connector_gmail_googleapis_com_default"] })}`;+ assert.equal((await built.app.turn({ ...turn("dm", selected), liveActor: true })).reply, "authenticated");+ assert.equal((await built.app.turn({ ...turn("dm", absent), liveActor: true })).reply, "absent");+ assert.equal((await built.app.turn(turn("channel", absent))).reply, "absent");+ await assert.rejects(built.app.turn(turn("channel", selected)), /not available/);});function wake(text: string, readOnly: boolean): TurnRequest {@@ -201,16 +195,23 @@ function wake(text: string, readOnly: boolean): TurnRequest {};}-test("a full-toolset triggered wake materializes the owner's connector token into the exec env", async () => {- const built: BuiltApp = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "wake-conn-")) }));- built.connectorTokens.setConnectorToken("gmail.googleapis.com", "U1", { accessToken: "u1-gmail" });- const gmailExport = `export ${envKey("gmail.googleapis.com")}=`;-- fakeSprites.reset();- const res = await built.app.turn(wake("!run true", false));- assert.equal(res.status, "ok");- assert.ok(execScriptsMention(gmailExport), "a full-toolset wake materializes the owner's connector token");- assert.ok(execScriptsMention("u1-gmail"), "the wake's exec env carries the token value");+test("a triggered wake needs a grant and an explicit request for a connector", async () => {+ const built = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "wake-conn-")) }));+ await built.connectorTokens.setConnectorToken("gmail.googleapis.com", "U1", { accessToken: "u1-gmail" });+ const key = envKey("gmail.googleapis.com");+ const absent = `!run test -z "$${key}" && echo absent`;+ assert.equal((await built.app.turn(wake(absent, false))).reply, "absent");+ const connector = (await built.keychain!.listConnectorsByOwners(["U1"])).get("U1")![0]!;+ const selected = `!execute ${JSON.stringify({ command: `test "$${key}" = u1-gmail && echo authenticated`, credentials: [credentialHandle(connector.credentialId)] })}`;+ await assert.rejects(built.app.turn(wake(selected, false)), /not available/);+ await built.keychain!.grantConnectorToScope({+ host: "gmail.googleapis.com",+ principalId: "U1",+ audienceScopeId: "personal:U1",+ purpose: "approved scheduled task",+ });+ assert.equal((await built.app.turn(wake(selected, false))).reply, "authenticated");+ assert.equal((await built.app.turn(wake(absent, false))).reply, "absent");});test("a read-only wake never reaches the sandbox (execute stripped), so no exec env at all", async () => {@@ -225,3 +226,126 @@ test("a read-only wake never reaches the sandbox (execute stripped), so no exec"a read-only wake spins no sandbox exec",);});++for (const bulkInventory of [false, true])+ for (const expiredPersonal of [false, true]) {+ test(`connector catalog (${bulkInventory ? "bulk" : "independent store"}) exposes company and ${expiredPersonal ? "expired" : "live"} personal accounts without eager access`, async () => {+ const built = buildApp(+ testConfig({ dataDir: mkdtempSync(join(tmpdir(), "connector-accounts-")), maxAttempts: 1 }),+ );+ if (!bulkInventory) delete built.connectorTokens.listConnectorsByOwners;+ const host = "gmail.googleapis.com";+ await built.connectorTokens.setConnectorToken(+ host,+ "U1",+ { accessToken: "personal-token", expiresAt: Date.now() + (expiredPersonal ? -1000 : 3600000) },+ "personal",+ );+ await built.connectorTokens.setConnectorToken(+ host,+ "U1",+ { accessToken: "company-token", expiresAt: Date.now() + 3600000 },+ "company",+ );+ const accesses: Array<string | undefined> = [];+ const original = built.connectorTokens.connectorAccessToken.bind(built.connectorTokens);+ built.connectorTokens.connectorAccessToken = async (...args) => {+ accesses.push(args[2]);+ return original(...args);+ };+ const prompt = await built.app.turn({ ...turn("dm", "!sysprompt"), liveActor: true });+ assert.deepEqual(accesses, []);+ assert.match(prompt.reply ?? "", /connector_gmail_googleapis_com_company/);+ if (expiredPersonal) assert.doesNotMatch(prompt.reply ?? "", /connector_gmail_googleapis_com_personal/);+ else assert.match(prompt.reply ?? "", /connector_gmail_googleapis_com_personal/);+ for (const account of expiredPersonal ? ["company"] : ["personal", "company"]) {+ const text = `!execute ${JSON.stringify({ command: `test "$${envKey(host)}" = ${account}-token && echo selected`, credentials: [`connector_gmail_googleapis_com_${account}`] })}`;+ assert.equal((await built.app.turn({ ...turn("dm", text), liveActor: true })).reply, "selected");+ }+ assert.deepEqual(accesses, expiredPersonal ? ["company"] : ["personal", "company"]);+ });+ }++test("operator fallback forwards metadata without reading secret values", async () => {+ let reads = 0;+ const inventory = new Map([+ [+ "U1",+ [{ credentialId: "oauth", ownerId: "U1", host: "api.example.com", connected: true, accountType: "company" }],+ ],+ ]);+ const store = {+ listConnectorsByOwners: async () => inventory,+ connectorTokenStatus: async () => ({ connected: false }),+ connectorAccessToken: async () => null,+ } as unknown as ConnectorTokenStore;+ const wrapped = withOperatorTokenFallback(store, ["api.example.com"], {+ get: async () => {+ reads++;+ return "operator-fallback";+ },+ });+ assert.equal(await wrapped.listConnectorsByOwners!(["U1"]), inventory);+ assert.deepEqual(await wrapped.connectorTokenStatus("api.example.com", "U1"), { connected: false });+ assert.equal(reads, 0);+ assert.equal(await wrapped.connectorAccessToken("api.example.com", "U1"), "operator-fallback");+ assert.equal(reads, 1);+});++test("explicit default OAuth accounts remain discoverable through bulk metadata", async () => {+ const built = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "default-account-")), maxAttempts: 1 }));+ const host = "gmail.googleapis.com";+ await built.connectorTokens.setConnectorToken(+ host,+ "U1",+ { accessToken: "explicit-default-token", accountType: "default" },+ "default",+ );+ Object.assign(+ built.connectorTokens,+ withOperatorTokenFallback(built.keychain!, [host], {+ get: async () => {+ throw new Error("healthy OAuth must not read an operator fallback");+ },+ }),+ );+ const prompt = await built.app.turn({ ...turn("dm", "!sysprompt"), liveActor: true });+ assert.match(prompt.reply ?? "", /connector_gmail_googleapis_com_default/);+ const text = `!execute ${JSON.stringify({ command: `test "$${envKey(host)}" = explicit-default-token && echo selected`, credentials: ["connector_gmail_googleapis_com_default"] })}`;+ assert.equal((await built.app.turn({ ...turn("dm", text), liveActor: true })).reply, "selected");+});++for (const mixedOAuth of [false, true, "expired-default"] as const)+ for (const value of [undefined, "operator-fallback-token"]) {+ test(`configured operator fallback is lazy with mixedOAuth=${mixedOAuth} and available=${value !== undefined}`, async () => {+ const built = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "fallback-catalog-")), maxAttempts: 1 }));+ const host = "gmail.googleapis.com";+ if (mixedOAuth === true)+ await built.connectorTokens.setConnectorToken(host, "U1", { accessToken: "personal-token" }, "personal");+ if (mixedOAuth === "expired-default")+ await built.connectorTokens.setConnectorToken(+ host,+ "U1",+ { accessToken: "expired-token", expiresAt: Date.now() - 1000, accountType: "default" },+ "default",+ );+ let reads = 0;+ Object.assign(+ built.connectorTokens,+ withOperatorTokenFallback(built.keychain!, ["googleapis.com"], {+ get: async () => {+ reads++;+ return value;+ },+ }),+ );+ const prompt = await built.app.turn({ ...turn("dm", "!sysprompt"), liveActor: true });+ assert.match(prompt.reply ?? "", /connector_gmail_googleapis_com_default.*configured operator fallback/);+ if (mixedOAuth === true) assert.match(prompt.reply ?? "", /connector_gmail_googleapis_com_personal/);+ assert.equal(reads, 0);+ const text = `!execute ${JSON.stringify({ command: `test "$${envKey(host)}" = operator-fallback-token && echo selected`, credentials: ["connector_gmail_googleapis_com_default"] })}`;+ if (value) assert.equal((await built.app.turn({ ...turn("dm", text), liveActor: true })).reply, "selected");+ else await assert.rejects(built.app.turn({ ...turn("dm", text), liveActor: true }), /no longer available/);+ assert.equal(reads, value ? 1 : 2);+ });+ }diff --git a/test/execute-credential-preparation.test.ts b/test/execute-credential-preparation.test.tsnew file mode 100644index 000000000..ea830d5c9--- /dev/null+++ b/test/execute-credential-preparation.test.ts@@ -0,0 +1,243 @@+import assert from "node:assert/strict";+import test from "node:test";+import { createToolContext, type CommandCredential, type ToolContextDeps } from "../src/tools/primitives.ts";+import type { ExecOptions, Sandbox, SandboxHandle } from "../src/sandbox/sandbox.ts";+import { scopeId } from "../src/types.ts";++const handle: SandboxHandle = { id: "credential-preparation", rootDir: "/workspace" };+type Materialized = Awaited<ReturnType<NonNullable<CommandCredential["resolve"]>>>;++function context(events: string[], credentials: CommandCredential[], extra: Partial<ToolContextDeps> = {}) {+ const runs: Array<SandboxHandle> = [];+ const sandbox = {+ async run(_handle: SandboxHandle, _command: string, _options?: ExecOptions) {+ events.push("run");+ runs.push(_handle);+ return { code: 0, stdout: "ok", stderr: "", timedOut: false };+ },+ } as unknown as Sandbox;+ const ctx = createToolContext({+ sandbox,+ async provision() {+ events.push("provision");+ return handle;+ },+ layers: [{ scopeId: scopeId("personal", "credential-tester"), mountPath: "", mode: "rw" }],+ commandPolicy() {+ events.push("policy");+ return { mode: "denylist", rules: [] };+ },+ authorizeCommand: () => false,+ commandCredentials: credentials,+ grantedHandles: [],+ workspace: {} as never,+ deploy: {} as never,+ acl: {} as never,+ createdBy: "credential-tester",+ ...extra,+ });+ return { ctx, runs };+}++function credential(events: string[], name: string, value: Partial<Materialized> = {}): CommandCredential {+ return {+ handle: name,+ async resolve() {+ events.push(`resolve:${name}`);+ return {+ env: [],+ async commit() {+ events.push(`commit:${name}`);+ },+ ...value,+ };+ },+ };+}++test("credential resolution follows command policy and successful provisioning", async () => {+ const events: string[] = [];+ const { ctx, runs } = context(events, [+ credential(events, "selected", { env: [{ key: "TOKEN", value: "synthetic" }] }),+ credential(events, "unused"),+ ]);+ await ctx.execute("echo ready", { credentials: ["selected"] });+ assert.deepEqual(events, ["policy", "provision", "resolve:selected", "commit:selected", "run"]);+ assert.deepEqual(runs[0]?.env, { TOKEN: "synthetic" });+});++for (const stop of ["policy", "provision"] as const) {+ test(`${stop} rejection never resolves or commits requested credentials`, async () => {+ const events: string[] = [];+ const extra: Partial<ToolContextDeps> =+ stop === "policy"+ ? {+ commandPolicy() {+ events.push("policy");+ return { mode: "denylist", rules: [{ pattern: "echo", decision: "deny" }] };+ },+ }+ : {+ async provision() {+ events.push("provision");+ throw new Error("provision rejected");+ },+ };+ const { ctx, runs } = context(events, [credential(events, "selected")], extra);+ await assert.rejects(ctx.execute("echo ready", { credentials: ["selected"] }));+ assert.deepEqual(events, stop === "policy" ? ["policy"] : ["policy", "provision"]);+ assert.equal(runs.length, 0);+ });+}++test("conflicting env credentials fail before grant consumption", async () => {+ const events: string[] = [];+ const credentials = ["a", "b"].map((name) => credential(events, name, { env: [{ key: "TOKEN", value: name }] }));+ const { ctx, runs } = context(events, credentials);+ await assert.rejects(ctx.execute("true", { credentials: ["a", "b"] }), /conflicting/);+ assert.deepEqual(events, ["policy", "provision", "resolve:a", "resolve:b"]);+ assert.equal(runs.length, 0);+});++test("cancellation during resolution never commits a prepared grant", async () => {+ const events: string[] = [];+ const abort = new AbortController();+ const selected = credential(events, "selected");+ const resolve = selected.resolve!;+ selected.resolve = async () => {+ const prepared = await resolve();+ abort.abort();+ return prepared;+ };+ const { ctx, runs } = context(events, [selected]);+ await assert.rejects(ctx.execute("echo ready", { credentials: ["selected"], signal: abort.signal }), {+ name: "AbortError",+ });+ assert.deepEqual(events, ["policy", "provision", "resolve:selected"]);+ assert.equal(runs.length, 0);+});++test("multiple single-use grants are rejected before any grant is committed", async () => {+ const events: string[] = [];+ const credentials = [+ credential(events, "standing"),+ credential(events, "once-a", { singleUse: true }),+ credential(events, "once-b", { singleUse: true }),+ ];+ const { ctx, runs } = context(events, credentials);+ await assert.rejects(+ ctx.execute("echo ready", { credentials: credentials.map((entry) => entry.handle) }),+ /at most one single-use/,+ );+ assert.deepEqual(events, ["policy", "provision", "resolve:standing", "resolve:once-a", "resolve:once-b"]);+ assert.equal(runs.length, 0);+});++test("single-use consumption follows all standing grant revalidation regardless of request order", async () => {+ const events: string[] = [];+ const credentials = [+ credential(events, "once", { singleUse: true }),+ credential(events, "standing-a"),+ credential(events, "standing-b"),+ ];+ const { ctx } = context(events, credentials);+ await ctx.execute("echo ready", { credentials: credentials.map((entry) => entry.handle) });+ assert.deepEqual(events, [+ "policy",+ "provision",+ "resolve:once",+ "resolve:standing-a",+ "resolve:standing-b",+ "commit:standing-a",+ "commit:standing-b",+ "commit:once",+ "run",+ ]);+});++test("failed standing revalidation preserves the single-use grant and prevents execution", async () => {+ const events: string[] = [];+ const credentials = [+ credential(events, "once", { singleUse: true }),+ credential(events, "revoked", {+ async commit() {+ events.push("revalidate:revoked");+ throw new Error("standing grant revoked");+ },+ }),+ ];+ const { ctx, runs } = context(events, credentials);+ await assert.rejects(ctx.execute("echo ready", { credentials: ["once", "revoked"] }), /standing grant revoked/);+ assert.deepEqual(events, ["policy", "provision", "resolve:once", "resolve:revoked", "revalidate:revoked"]);+ assert.equal(runs.length, 0);+});++test("newly available handles are resolved from the current catalog and revocation fails closed", async () => {+ const events: string[] = [];+ let available: CommandCredential[] = [];+ const { ctx, runs } = context(events, [], { resolveCommandCredentials: async () => available });+ await ctx.execute("true");+ available = [credential(events, "new"), credential(events, "unselected")];+ await ctx.execute("true", { credentials: ["new"] });+ assert.equal(events.filter((event) => event === "resolve:new").length, 1);+ assert.ok(!events.includes("resolve:unselected"));+ available = [];+ await assert.rejects(ctx.execute("true", { credentials: ["new"] }), /not available/);+ assert.equal(runs.length, 2);+});++test("owner credentials cannot be requested on scoped or scratch workspaces", async () => {+ const events: string[] = [];+ const selected = { ...credential(events, "owner"), scope: "owner" as const };+ const { ctx, runs } = context(events, [selected], { provisionOwnerAuth: async () => handle });+ await assert.rejects(ctx.execute("true", { credentials: ["owner"] }), /requires scope:owner/);+ await assert.rejects(ctx.execute("true", { credentials: ["owner"], scratch: true }), /only on the scoped/);+ assert.deepEqual(events, []);+ await ctx.execute("true", { credentials: ["owner"], ownerAuth: true });+ assert.equal(runs.length, 1);+});++test("replay returns cached masked bytes without resolving a consumed single-use credential", async () => {+ let stored: string | undefined;+ let available = true;+ let resolutions = 0;+ const events: string[] = [];+ const extra: Partial<ToolContextDeps> = {+ runId: "once-replay",+ attempt: 1,+ ledger: {+ begin: async () => (stored === undefined ? { cached: false } : { cached: true, output: stored }),+ record: async (_run, _attempt, _index, output) => {+ stored = output;+ },+ } as ToolContextDeps["ledger"],+ resolveCommandCredentials: async () => {+ resolutions++;+ return available+ ? [+ {+ handle: "single",+ resolve: async () => ({+ env: [{ key: "TOKEN", value: "synthetic-secret" }],+ singleUse: true,+ commit: async () => {+ available = false;+ },+ }),+ },+ ]+ : [];+ },+ sandbox: {+ run: async () => ({ stdout: "value=synthetic-secret", stderr: "", code: 0, timedOut: false }),+ } as unknown as Sandbox,+ };+ const first = await context(events, [], extra).ctx.execute("print token", { credentials: ["single"] });+ assert.equal(first.stdout, "value=<redacted:credential>");+ assert.ok(!stored?.includes("synthetic-secret"));+ events.length = 0;+ const replay = await context(events, [], extra).ctx.execute("print token", { credentials: ["single"] });+ assert.deepEqual(replay, first);+ assert.equal(resolutions, 1);+ assert.deepEqual(events, []);+});diff --git a/test/execute-env-credentials.test.ts b/test/execute-env-credentials.test.tsnew file mode 100644index 000000000..0c1d043de--- /dev/null+++ b/test/execute-env-credentials.test.ts@@ -0,0 +1,149 @@+import { test, before, after, beforeEach } from "node:test";+import assert from "node:assert/strict";+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { buildApp } from "../src/wiring.ts";+import { scopeId } from "../src/types.ts";+import { installGlobalFakeSprites, type FakeSprites } from "./support/fake-sprites.ts";+import { testConfig } from "./support/test-config.ts";+import { createAwsRoleBroker } from "../src/auth/aws-role-broker.ts";++let ff: FakeSprites;+before(() => {+ ff = installGlobalFakeSprites();+});+beforeEach(() => ff.reset());+after(() => ff.cleanup());++function acmecliBrokeredLayer(binary?: string, approvals?: Array<{ pattern: string; reason?: string }>): string {+ const dir = mkdtempSync(join(tmpdir(), "dfp-layer-"));+ mkdirSync(join(dir, "tools/acmecli"), { recursive: true });+ writeFileSync(+ join(dir, "tools/acmecli/tool.json"),+ JSON.stringify({+ id: "acmecli",+ ...(binary ? { install: { binary } } : {}),+ ...(approvals ? { approvals } : {}),+ auth: {+ check: "acmecli me",+ reauth: "acmecli login --use-device-code",+ credentialPaths: [{ path: ".acmecli", kind: "directory" }],+ broker: {+ kind: "aws-role",+ roleArnEnv: "TEST_BROKER_ROLE_ARN",+ region: "us-west-2",+ sessionActions: ["execute-api:Invoke"],+ },+ },+ }),+ );+ return dir;+}++const actor = { externalId: "U_ENV_BROKER" };+test("selected broker credential uses isolated execute with policy before vending", async () => {+ let assumes = 0;+ const sentinels = {+ access: "AKIA_CREDENTIAL_EXEC_SENTINEL",+ secret: "credential_exec_secret_sentinel",+ token: "credential_exec_session_sentinel",+ };+ const built = buildApp(+ testConfig({+ dataDir: mkdtempSync(join(tmpdir(), "dfp-credential-exec-")),+ maxAttempts: 1,+ signingSecret: "device-flow-test-secret",+ deploymentLayerDir: acmecliBrokeredLayer("env"),+ }),+ {+ credentialBrokers: {+ acmecli: createAwsRoleBroker({+ roleArn: "arn:aws:iam::123456789012:role/acmecli-broker",+ region: "us-west-2",+ sessionActions: ["execute-api:Invoke"],+ assumeRole: async () => {+ assumes++;+ return {+ Credentials: {+ AccessKeyId: sentinels.access,+ SecretAccessKey: sentinels.secret,+ SessionToken: sentinels.token,+ Expiration: new Date(Date.now() + 3_600_000),+ },+ };+ },+ }),+ },+ },+ );++ const personal = scopeId("personal", actor.externalId);+ const conversation = { kind: "dm" as const, threadRef: "dm:env-broker", audience: [actor] };+ await built.deviceFlowCutover.set(personal, "acmecli", "ephemeral_only", "[email protected]");+ const run = (params: object) =>+ built.app.turn({ surface: "slack", actor, conversation, text: `!execute ${JSON.stringify(params)}` });+ await assert.rejects(run({ command: "env", credentials: ["broker_acmecli"] }), /requires scope:owner/);+ assert.equal(assumes, 0);+ const selected = await run({+ command:+ 'test "$AWS_ACCESS_KEY_ID" = AKIA_CREDENTIAL_EXEC_SENTINEL && test -z "${AGENT_API_TOKEN-}" && echo selected',+ credentials: ["broker_acmecli"],+ ownerAuth: true,+ });+ assert.equal(selected.reply, "selected");+ assert.equal(assumes, 1);+ assert.ok(ff.names().every((name) => !name.includes("credential-exec")));+});++test("legacy role broker vends only for explicitly selected scoped execution", async () => {+ let assumes = 0;+ const built = buildApp(+ testConfig({+ dataDir: mkdtempSync(join(tmpdir(), "legacy-selected-broker-")),+ signingSecret: "legacy-selected-signing",+ deploymentLayerDir: acmecliBrokeredLayer(),+ maxAttempts: 1,+ }),+ {+ credentialBrokers: {+ acmecli: createAwsRoleBroker({+ roleArn: "arn:aws:iam::123456789012:role/acmecli-broker",+ region: "us-west-2",+ sessionActions: ["execute-api:Invoke"],+ assumeRole: async () => {+ assumes++;+ return {+ Credentials: {+ AccessKeyId: "AKIA_LEGACY_SELECTED",+ SecretAccessKey: "legacy-selected-secret",+ SessionToken: "legacy-selected-session",+ Expiration: new Date(Date.now() + 3600000),+ },+ };+ },+ }),+ },+ },+ );+ const conversation = { kind: "dm" as const, threadRef: "dm:legacy-selected", audience: [actor] };+ const run = (text: string) => built.app.turn({ surface: "slack", actor, conversation, text });+ assert.equal((await run('!run test -z "${AWS_ACCESS_KEY_ID-}" && echo absent')).reply, "absent");+ assert.equal(assumes, 0);+ await assert.rejects(+ run(`!execute ${JSON.stringify({ command: "true", credentials: ["broker_acmecli"], ownerAuth: true })}`),+ /requires scope:scoped/,+ );+ assert.equal(assumes, 0);+ assert.equal(+ (+ await run(+ `!execute ${JSON.stringify({ command: 'test "$AWS_ACCESS_KEY_ID" = AKIA_LEGACY_SELECTED && echo selected', credentials: ["broker_acmecli"] })}`,+ )+ ).reply,+ "selected",+ );+ assert.equal(assumes, 1);+ assert.equal((await run('!run test -z "${AWS_ACCESS_KEY_ID-}" && echo absent')).reply, "absent");+ assert.equal(assumes, 1);+});diff --git a/test/execute-scratch.test.ts b/test/execute-scratch.test.tsindex 04124fd5b..91b8f50c1 100644--- a/test/execute-scratch.test.ts+++ b/test/execute-scratch.test.ts@@ -1,3 +1,5 @@+import { execFileSync } from "node:child_process";+import { createTurnSandboxes, type TurnSandboxContext } from "../src/core/orchestrator/sandboxes.ts";import { fakeSprites } from "./support/auto-fake-sprites.ts";import { test } from "node:test";import assert from "node:assert/strict";@@ -84,7 +86,7 @@ const schemaRequired = (tool: ReturnType<typeof createAgentTools>[number]): stritest("flag OFF: the execute surface is exactly the legacy one (no scope/durable, scoped box)", async () => {const { tc, seen } = sinkToolContext();const [execute] = createAgentTools({ current: tc });- assert.deepEqual(schemaProps(execute!), ["command", "sandbox_id", "purpose", "timeout_seconds"]);+ assert.deepEqual(schemaProps(execute!), ["command", "sandbox_id", "purpose", "timeout_seconds", "credentials"]);assert.deepEqual(schemaRequired(execute!), ["command", "purpose"]);await call(execute, { command: "echo hi" });assert.deepEqual(seen, [{ command: "echo hi", opts: undefined }]);@@ -94,7 +96,15 @@ test("flag ON: scope defaults to the durable scoped box; scratch is an explicitconst { tc, seen } = sinkToolContext();const ref: ToolContextRef = { current: tc };const [execute] = createAgentTools(ref, { scratchExec: true });- assert.deepEqual(schemaProps(execute!), ["command", "sandbox_id", "purpose", "timeout_seconds", "scope", "durable"]);+ assert.deepEqual(schemaProps(execute!), [+ "command",+ "sandbox_id",+ "purpose",+ "timeout_seconds",+ "credentials",+ "scope",+ "durable",+ ]);await call(execute, { command: "echo hi" });assert.deepEqual(@@ -268,7 +278,10 @@ test("execute rejects unavailable, conflicting, and scratch credential requests"ctx.execute("true", { credentials: ["kc_one12345678", "kc_two12345678"] }),/conflicting environment key/,);- await assert.rejects(ctx.execute("true", { scratch: true, credentials: ["kc_one12345678"] }), /scoped computer/);+ await assert.rejects(+ ctx.execute("true", { scratch: true, credentials: ["kc_one12345678"] }),+ /scoped or owner computer/,+ );});test("execute schema lists exact command credential handles", async () => {@@ -350,3 +363,169 @@ test("migrateComputer without a wired runner fails loudly", async () => {const { ctx } = routingCtx({ authorizeCommand: () => true });await assert.rejects(ctx.migrateComputer("modal"), /not available on this deployment/);});++test("execute masks credential output before model delivery, screening, and transcript logging", async () => {+ const secret = "execution-secret-123456";+ const emitted: unknown[] = [];+ const screened: unknown[] = [];+ const { ctx } = routingCtx({+ sandbox: {+ async run() {+ return { stdout: `safe prefix ${secret} safe suffix`, stderr: "useful diagnostics", code: 0, timedOut: false };+ },+ } as unknown as Sandbox,+ commandCredentials: [{ handle: "kc_test123456", env: [{ key: "TOKEN", value: secret }] }],+ });+ const [execute] = createAgentTools(+ {+ current: ctx,+ scopeLabel: scopeId("personal", "U1"),+ emit: async (entry) => {+ emitted.push(entry);+ },+ screenToolResult: async (input) => {+ screened.push(input);+ return { outcome: "allow" };+ },+ },+ { commandCredentialHandles: ["kc_test123456"] },+ );+ const result = await call(execute, { command: "diagnose", credentials: ["kc_test123456"] });+ const all = JSON.stringify({ result, emitted, screened });+ assert.ok(!all.includes(secret));+ assert.ok(all.includes("useful diagnostics"));+ assert.match(textOf(result), /<redacted:credential>/);+ assert.match(textOf(result), /exit 0/);+ assert.equal(screened.length, 1);+ assert.ok(+ emitted.some((entry) => {+ const e = entry as { type?: string; payload?: { isError?: boolean; code?: number } };+ return e.type === "tool_result" && e.payload?.isError === false && e.payload?.code === 0;+ }),+ );+});++test("execute checks only the current execution environment, including inherited credentials", async () => {+ const inherited = "inherited-secret-1234";+ const unselected = "unselected-secret-5678";+ let output = unselected;+ const { ctx } = routingCtx({+ provision: async () => ({ ...scopedHandle, env: { TOKEN: inherited, AWS_REGION: "us-west-2" } }),+ sandbox: {+ async run() {+ return { stdout: output, stderr: "", code: 0, timedOut: false };+ },+ } as unknown as Sandbox,+ commandCredentials: [{ handle: "kc_unused1234", env: [{ key: "OTHER_TOKEN", value: unselected }] }],+ });+ assert.equal((await ctx.execute("diagnose")).stdout, unselected);+ output = "us-west-2";+ assert.equal((await ctx.execute("diagnose")).stdout, output);+ output = inherited;+ assert.equal((await ctx.execute("diagnose")).stdout, "<redacted:credential>");+});++test("execute replaces credential-bearing provider errors without retaining the original cause", async () => {+ const secret = "provider-secret-12345";+ const { ctx } = routingCtx({+ provision: async () => ({ ...scopedHandle, env: { TOKEN: secret } }),+ sandbox: {+ async run() {+ throw new Error(`provider returned ${secret}`);+ },+ } as unknown as Sandbox,+ });+ await assert.rejects(ctx.execute("diagnose"), (error: Error) => {+ assert.equal(error.message, "provider returned <redacted:credential>");+ assert.ok(!error.stack?.includes(secret));+ assert.equal(error.cause, undefined);+ return true;+ });+});++test("execute records a safe provider-error result for native replay", async () => {+ const secret = "provider-secret-12345";+ const entries: unknown[] = [];+ const { ctx } = routingCtx({+ provision: async () => ({ ...scopedHandle, env: { TOKEN: secret } }),+ sandbox: {+ async run() {+ throw new Error(`provider returned ${secret}`);+ },+ } as unknown as Sandbox,+ });+ const [execute] = createAgentTools({+ current: ctx,+ scopeLabel: scopeId("personal", "U1"),+ emit: async (entry) => {+ entries.push(entry);+ },+ });+ const result = await call(execute, { command: "diagnose" });+ assert.match(textOf(result), /<redacted:credential>/);+ assert.ok(!JSON.stringify({ result, entries }).includes(secret));+ assert.ok(entries.some((entry) => (entry as { type?: string }).type === "tool_result"));+});++test("execute respects secret metadata even for configuration-named credentials", async () => {+ const { ctx } = routingCtx({+ sandbox: {+ async run() {+ return { stdout: "credential", stderr: "", code: 0, timedOut: false };+ },+ } as unknown as Sandbox,+ commandCredentials: [+ {+ handle: "kc_config1234",+ env: [+ { key: "AWS_REGION", value: "credential", secret: true },+ { key: "USERNAME", value: "a", secret: false },+ ],+ },+ ],+ });+ assert.equal((await ctx.execute("diagnose", { credentials: ["kc_config1234"] })).stdout, "<redacted:credential>");+});++test("owner execute masks selected credentials and inherited proxy credentials", async () => {+ const { ctx } = routingCtx({+ provisionOwnerAuth: async () => ({ ...scopedHandle, env: { HTTPS_PROXY: "https://user:[email protected]" } }),+ commandCredentials: [{ handle: "owner-token", scope: "owner", env: [{ key: "TOKEN", value: "owner-secret" }] }],+ sandbox: {+ async run() {+ return { stdout: "owner-secret https://user:[email protected]", stderr: "", code: 0, timedOut: false };+ },+ } as unknown as Sandbox,+ });+ assert.equal(+ (await ctx.execute("diagnose", { ownerAuth: true, credentials: ["owner-token"] })).stdout,+ "<redacted:credential> <redacted:credential>",+ );+});++test("scoped command wrappers preserve selected AWS credentials and clear unselected ambient keys", async () => {+ const boxes = createTurnSandboxes({+ deps: {},+ input: {},+ connectorEnv: {},+ credentialCutoverServices: ["role-service"],+ } as unknown as TurnSandboxContext);+ const { ctx } = routingCtx({+ scopedCommand: boxes.scopedCommand,+ commandCredentials: [{ handle: "selected-aws", env: [{ key: "AWS_ACCESS_KEY_ID", value: "selected-key" }] }],+ sandbox: {+ async run(handle: SandboxHandle, command: string) {+ const stdout = execFileSync("/bin/sh", ["-c", command], {+ env: { AWS_SECRET_ACCESS_KEY: "stale", ...handle.env },+ encoding: "utf8",+ });+ return { stdout, stderr: "", code: 0, timedOut: false };+ },+ } as unknown as Sandbox,+ });+ const result = await ctx.execute(+ 'test "$AWS_ACCESS_KEY_ID" = selected-key && test "${AWS_SECRET_ACCESS_KEY-unset}" = unset && printf passed',+ { credentials: ["selected-aws"] },+ );+ assert.equal(result.stdout, "passed");+});diff --git a/test/feature-flags.test.ts b/test/feature-flags.test.tsindex 11aef50de..76ab5647e 100644--- a/test/feature-flags.test.ts+++ b/test/feature-flags.test.ts@@ -5,20 +5,20 @@ import { createFeatureFlagStore, type FeatureFlagRecord } from "../src/feature-ftest("feature flags map each feature to enabled scopes", async () => {const store = createFeatureFlagStore(createMemoryMap<FeatureFlagRecord>());- assert.equal(await store.enabled("command_scoped_credentials", "channel:C1"), false);- await store.setEnabled("command_scoped_credentials", "channel:C1", true, "admin");- await store.setEnabled("command_scoped_credentials", "personal:U1", true, "admin");- assert.equal(await store.enabled("command_scoped_credentials", "channel:C1"), true);- assert.equal(await store.enabled("command_scoped_credentials", "channel:C2"), false);- assert.deepEqual((await store.get("command_scoped_credentials"))?.enabledScopes, ["channel:C1", "personal:U1"]);- await store.setEnabled("command_scoped_credentials", "channel:C1", false, "admin");- assert.equal(await store.enabled("command_scoped_credentials", "channel:C1"), false);+ assert.equal(await store.enabled("inbox_loops", "channel:C1"), false);+ await store.setEnabled("inbox_loops", "channel:C1", true, "admin");+ await store.setEnabled("inbox_loops", "personal:U1", true, "admin");+ assert.equal(await store.enabled("inbox_loops", "channel:C1"), true);+ assert.equal(await store.enabled("inbox_loops", "channel:C2"), false);+ assert.deepEqual((await store.get("inbox_loops"))?.enabledScopes, ["channel:C1", "personal:U1"]);+ await store.setEnabled("inbox_loops", "channel:C1", false, "admin");+ assert.equal(await store.enabled("inbox_loops", "channel:C1"), false);});test("the org scope enables a feature everywhere", async () => {const store = createFeatureFlagStore(createMemoryMap<FeatureFlagRecord>());- await store.setEnabled("command_scoped_credentials", "org:default-org", true, "admin");- assert.equal(await store.enabled("command_scoped_credentials", "channel:C1"), true);+ await store.setEnabled("inbox_loops", "org:default-org", true, "admin");+ assert.equal(await store.enabled("inbox_loops", "channel:C1"), true);});test("persistent subagents default off and can be enabled for individual people", async () => {@@ -41,3 +41,19 @@ test("responsive spine defaults off and its cohort is independent of subagent acawait store.setEnabled("responsive_spine", "personal:U1", false, "admin");assert.equal(await store.enabled("responsive_spine", "personal:U1"), false);});++test("retired feature records are not offered as configurable flags", async () => {+ const backing = createMemoryMap<FeatureFlagRecord>();+ await backing.put("command_scoped_credentials", {+ featureName: "command_scoped_credentials",+ enabledScopes: ["channel:C1"],+ updatedAt: 1,+ updatedBy: "admin",+ } as unknown as FeatureFlagRecord);+ const store = createFeatureFlagStore(backing);+ await store.setEnabled("inbox_loops", "channel:C1", true, "admin");+ assert.deepEqual(+ (await store.list()).map((row) => row.featureName),+ ["inbox_loops"],+ );+});diff --git a/test/keychain.test.ts b/test/keychain.test.tsindex bac0128c1..20c31baea 100644--- a/test/keychain.test.ts+++ b/test/keychain.test.ts@@ -12,6 +12,7 @@ import { buildApp, type BuiltApp } from "../src/wiring.ts";import { createServer } from "../src/api/server.ts";import {createKeychain,+ credentialHandle,renderKeychainManifest,renderUseScript,KeychainError,@@ -804,8 +805,8 @@ test("multi-input login: each field becomes its own env var, values never in metconst [own] = await k.materializeOwn("U1");assert.deepEqual(own!.env, [- { key: "DOORDASH_EMAIL", value: "[email protected]" },- { key: "DOORDASH_PASSWORD", value: "hunter2" },+ { key: "DOORDASH_EMAIL", value: "[email protected]", secret: false },+ { key: "DOORDASH_PASSWORD", value: "hunter2", secret: true },]);const script = renderUseScript({ kind: "env", ...own! });assert.match(script, /export DOORDASH_EMAIL='[email protected]'\nexport DOORDASH_PASSWORD='hunter2'/);@@ -880,7 +881,7 @@ test("back-compat: a legacy record carrying a plaintext username still materialiconst [own] = await k.materializeOwn("U1");assert.deepEqual(own!.env, [{ key: "ACME_PORTAL_PASSWORD", value: "hunter2" },- { key: "ACME_PORTAL_USERNAME", value: "[email protected]" },+ { key: "ACME_PORTAL_USERNAME", value: "[email protected]", secret: false },]);});@@ -1098,14 +1099,81 @@ describe("/v1/keychain routes (capability-authed)", () => {assert.equal(res.status, 200);const { credential } = (await res.json()) as any;assert.equal(credential.ownerId, "U1");+ assert.equal(credential.credentialHandle, credentialHandle(credential.id));assert.ok(!JSON.stringify(credential).includes("ghp_u1"));const mine = (await (await get("/v1/keychain/credentials", await capFor("U1"))).json()) as any;assert.equal(mine.credentials.length, 1);+ assert.equal(mine.credentials[0].credentialHandle, credential.credentialHandle);+ assert.ok(!JSON.stringify(mine).includes("ghp_u1"));const other = (await (await get("/v1/keychain/credentials", await capFor("U2"))).json()) as any;assert.deepEqual(other.credentials, []);});+ it("backend-only grants offer backend guidance while file grants retain shell commands", async () => {+ const owner = "BACKEND_HANDLE_OWNER";+ const cap = await capFor(owner, scopeId("personal", owner), { liveActor: true });+ for (const backend of [true, false]) {+ const input = backend+ ? { service: "composio", envKey: "COMPOSIO_API_KEY", secret: "backend-project-sentinel" }+ : {+ service: "test-files",+ files: [{ path: ".test/token", contentBase64: Buffer.from("file-sentinel").toString("base64") }],+ };+ const saved = (await (await post("/v1/keychain/credentials", input, cap)).json()) as any;+ const response = await post(+ "/v1/keychain/grants",+ { credential: saved.credential.id, mode: "once", purpose: "authorized access" },+ cap,+ );+ assert.equal(response.status, 200);+ const granted = (await response.json()) as any;+ assert.equal(granted.use.credentialHandle, undefined);+ assert.equal(granted.use.credentials, undefined);+ if (backend) {+ assert.equal(granted.use.command, undefined);+ assert.match(granted.use.note, /\/v1\/composio/);+ } else {+ assert.match(granted.use.command, /keychain\/use/);+ assert.match(granted.use.note, /same shell/);+ }+ assert.ok(!JSON.stringify([saved, granted]).includes("backend-project-sentinel"));+ }+ });++ it("new env grants return immediately usable execution handles without secrets", async () => {+ const owner = "HANDLE_OWNER";+ const cap = await capFor(owner, scopeId("personal", owner), { liveActor: true });+ const saved = (await (+ await post(+ "/v1/keychain/credentials",+ { service: "handle-test", envKey: "HANDLE_TOKEN", secret: "synthetic-handle-secret" },+ cap,+ )+ ).json()) as any;+ const metadata = (await (await get("/v1/keychain/credentials", cap)).json()) as any;+ const response = await post(+ "/v1/keychain/grants",+ { credential: saved.credential.id, mode: "once", purpose: "use the new execution handle" },+ cap,+ );+ assert.equal(response.status, 200);+ const granted = (await response.json()) as any;+ assert.equal(saved.credential.credentialHandle, metadata.credentials[0].credentialHandle);+ assert.equal(granted.use.credentialHandle, saved.credential.credentialHandle);+ assert.deepEqual(granted.use.credentials, [saved.credential.credentialHandle]);+ assert.match(granted.use.note, /available immediately/);+ assert.ok(!JSON.stringify([saved, metadata, granted]).includes("synthetic-handle-secret"));+ const current = (await built.keychain!.grantsForScope(scopeId("personal", owner))).find(+ ({ credential }) => credential.credentialHandle === granted.use.credentialHandle,+ );+ assert.ok(current);+ const prepared = await built.keychain!.prepareMaterialize(current.grant.id, scopeId("personal", owner), owner);+ assert.equal(prepared.materialized.kind, "env");+ await prepared.commit();+ assert.equal((await built.keychain!.getGrant(current.grant.id))?.status, "used");+ });+it("a participant's connector is grantable by its owner, then materialized under the host env var", async () => {const GROUP = scopeId("group", "G_CONN");await built.keychain!.setConnectorToken("gmail.googleapis.com", "alex@conn", {@@ -1552,7 +1620,18 @@ test("turn e2e: prompt lists exact handles and keychain env credentials are neve}),);assert.ok(built.keychain, "buildApp with a signing secret wires the keychain");- await built.featureFlags.setEnabled("command_scoped_credentials", "channel:C1", true, "test");+ built.keychain.materializeOwn = async () => {+ throw new Error("eager owner materialization is forbidden");+ };+ built.keychain.materializeStanding = async () => {+ throw new Error("eager standing materialization is forbidden");+ };+ const resolved: string[] = [];+ const materializeOwnById = built.keychain.materializeOwnById.bind(built.keychain);+ built.keychain.materializeOwnById = async (...args) => {+ resolved.push(args[1]);+ return materializeOwnById(...args);+ };const cred = await built.keychain!.save({ownerId: "U_OWNER",service: "github",@@ -1593,11 +1672,75 @@ test("turn e2e: prompt lists exact handles and keychain env credentials are neveconst dm: TurnRequest = {surface: "test",actor: { externalId: "U_OWNER" },- conversation: { kind: "dm", threadRef: "dm:U_OWNER" },+ conversation: { kind: "dm", threadRef: "dm:U_OWNER", audience: [{ externalId: "U_OWNER" }] },+ origin: { kind: "human" },text: "!run true",} as TurnRequest;assert.equal((await built.app.turn(dm)).status, "ok");- assert.ok(execScriptsMention("ghp_e2e", mark), "an unlisted scope keeps legacy behavior");+ assert.ok(!execScriptsMention("ghp_e2e", mark), "unrequested secrets are never materialized");+ const selected = await built.app.turn({+ ...dm,+ text: `!execute ${JSON.stringify({ command: 'test "$GITHUB_TOKEN" = ghp_e2e && echo selected', credentials: [credentialHandle(cred.id)] })}`,+ });+ assert.equal(selected.reply, "selected");+ assert.deepEqual(resolved, [cred.id]);+});++test("prepared grants reject credential rotation without consuming a single use", async () => {+ const k = kc();+ const credential = await k.save(GH);+ const grant = await k.createGrant({+ credentialId: credential.id,+ ownerId: GH.ownerId,+ audienceScopeId: "channel:C1",+ mode: "once",+ purpose: "rotation regression",+ });+ const prepared = await k.prepareMaterialize(grant.id, "channel:C1", "U2");+ await k.save({ ...GH, secret: "rotated-execution-token" });+ await assert.rejects(prepared.commit(), /credential changed/);+ assert.equal((await k.getGrant(grant.id))?.status, "active");+ const fresh = await k.prepareMaterialize(grant.id, "channel:C1", "U2");+ assert.equal(fresh.materialized.kind, "env");+ if (fresh.materialized.kind === "env") assert.equal(fresh.materialized.env[0]?.value, "rotated-execution-token");+ await fresh.commit();+ assert.equal((await k.getGrant(grant.id))?.status, "used");+});++test("connector refresh during preparation binds the refreshed version and later rotation invalidates it", async () => {+ let refreshes = 0;+ const k = createKeychain({+ creds: createMemoryMap(),+ grants: createMemoryMap(),+ asks: createMemoryMap(),+ key: KEY,+ refreshConnector: async () => {+ refreshes++;+ return { accessToken: "refreshed-token", expiresAt: Date.now() + 3600000 };+ },+ });+ await k.setConnectorToken("gmail.googleapis.com", "U1", {+ accessToken: "expired-token",+ refreshToken: "refresh",+ expiresAt: Date.now() - 1000,+ });+ const connector = (await k.listConnectorsByOwners(["U1"])).get("U1")![0]!;+ const grant = await k.createGrant({+ credentialId: connector.credentialId,+ ownerId: "U1",+ audienceScopeId: "channel:C1",+ mode: "standing",+ purpose: "refresh regression",+ });+ const prepared = await k.prepareMaterialize(grant.id, "channel:C1", "U2");+ assert.equal(refreshes, 1);+ await prepared.commit();+ await k.setConnectorToken("gmail.googleapis.com", "U1", {+ accessToken: "replacement-token",+ expiresAt: Date.now() + 3600000,+ });+ await assert.rejects(prepared.commit(), /credential changed/);+ await (await k.prepareMaterialize(grant.id, "channel:C1", "U2")).commit();});test("Composio keys remain backend-only across all materialization paths including multi-field records", async () => {@@ -1612,6 +1755,8 @@ test("Composio keys remain backend-only across all materialization paths includi]) {const k = kc();const c = await k.save({ ownerId: "U1", service: "composio", ...input });+ assert.equal(c.credentialHandle, undefined);+ assert.equal((await k.getCredential(c.id))?.credentialHandle, undefined);const grant = await k.createGrant({credentialId: c.id,ownerId: "U1",diff --git a/test/loop-execution.test.ts b/test/loop-execution.test.tsindex b6a7b1a45..b1d56332b 100644--- a/test/loop-execution.test.ts+++ b/test/loop-execution.test.ts@@ -51,7 +51,13 @@ for (const checkResult of ["passed", "failed", "missing"] as const) {else if (stage === "work") command = "printf 'RCA and proposed fix' > loop-proposal.txt && printf prepared";else if (stage === "judge") command = `${check} && printf verified`;else command = "printf shipped";- const result = await built.app.turn({ ...req, text: `!run ${command}` });+ const result = await built.app.turn({+ ...req,+ text:+ stage === "intake"+ ? `!execute ${JSON.stringify({ command, credentials: ["service_error-source"] })}`+ : `!run ${command}`,+ });assert.equal(result.status, "ok");if (stage === "intake") {assert.equal(result.reply, "source-readable");diff --git a/test/open-speaker-keychain.test.ts b/test/open-speaker-keychain.test.tsindex fcfc279e8..3e074bf32 100644--- a/test/open-speaker-keychain.test.ts+++ b/test/open-speaker-keychain.test.ts@@ -4,9 +4,8 @@ import { createTurnSandboxes, type TurnSandboxContext } from "../src/core/orchesimport { coreToolOptions } from "../src/harness/agent-tools.ts";import { loadConfig } from "../src/config.ts";-test("Open owner execution is discoverable even when automation isolation defaults off", () => {+test("Open owner execution is discoverable without an isolation flag", () => {const config = loadConfig({});- assert.equal(config.sharedOwnerAuthIsolation, false);assert.equal(coreToolOptions(config).ownerAuthExec, true);});@@ -43,8 +42,6 @@ test("Open owner computer rechecks revocation before reuse and is destroyed, nevisolateOwnerKeychain: true,openSpeakerKeychain: true,ownerAuthAvailable: true,- ownerAuthEnv: { TEST_TOKEN: "synthetic-secret" },- ownerEnvCredentialIds: ["synthetic-id"],connectorEnv: {},credentialTools: [],credentialServices: [],diff --git a/test/orchestrator.test.ts b/test/orchestrator.test.tsindex 08f83261c..8abb0454b 100644--- a/test/orchestrator.test.ts+++ b/test/orchestrator.test.ts@@ -9,7 +9,7 @@ import { scopeId, type TurnRequest } from "../src/types.ts";import { TEST_CAPABILITY_SECRET, testConfig } from "./support/test-config.ts";import { runNowSettled } from "./support/settle.ts";import { loadConfig, type Config } from "../src/config.ts";-import type { ProvisionOptions, Sandbox } from "../src/sandbox/sandbox.ts";+import type { SandboxHandle, ProvisionOptions, Sandbox } from "../src/sandbox/sandbox.ts";import {verifyCapabilityToken,EGRESS_PROXY_AUD,@@ -36,6 +36,7 @@ function freshApp(overrides: Partial<Config> = {}, securityScreener?: SecurityScdataDir: mkdtempSync(join(tmpdir(), "ap-")),...overrides,});+ config.spritesSandbox.namePrefix ??= `test-${hashId([config.dataDir]).slice(0, 10)}`;return buildApp(config, securityScreener ? { securityScreener } : {});}@@ -312,9 +313,10 @@ test(async (t) => {t.mock.timers.enable({ apis: ["Date"], now: Date.now() });const built = freshApp();- const { app, connectorTokens } = built;+ const { app, keychain } = built;+ assert.ok(keychain);- const realConnectorAccessToken = connectorTokens.connectorAccessToken.bind(connectorTokens);+ const realGrantsForScope = keychain.grantsForScope.bind(keychain);const attempted: string[] = [];const claimForSession = built.runs.claimForSession.bind(built.runs);built.runs.claimForSession = async (...args) => {@@ -323,12 +325,12 @@ test(return run;};let injectFailure = true;- connectorTokens.connectorAccessToken = async (...args: Parameters<typeof realConnectorAccessToken>) => {+ keychain.grantsForScope = async (...args: Parameters<typeof realGrantsForScope>) => {if (injectFailure) {injectFailure = false;throw new Error("injected setup failure");}- return realConnectorAccessToken(...args);+ return realGrantsForScope(...args);};await assert.rejects(app.turn(dm("hi")), /injected setup failure/);@@ -567,6 +569,15 @@ test("Composio backend access is announced without delivering the project key",const granted = await prompt("granted");assert.match(granted, /## Connected app access/);assert.match(granted, /Composio is configured in the backend/);+ assert.doesNotMatch(granted, /service_composio/);+ await assert.rejects(+ app.turn(+ dm(`!execute ${JSON.stringify({ command: "true", credentials: ["service_composio"] })}`, {+ conversation: { kind: "dm", threadRef: "dm:U1:composio-explicit" },+ }),+ ),+ /not available/,+ );assert.doesNotMatch(granted, /COMPOSIO_API_KEY/);assert.doesNotMatch(granted, /Do not suggest or offer any app connection/);const result = await app.turn(@@ -576,6 +587,15 @@ test("Composio backend access is announced without delivering the project key",assert.equal(captured?.env?.COMPOSIO_API_KEY, undefined);const claims = await verifyCapabilityToken(captured!.env!.AGENT_API_TOKEN!, TEST_CAPABILITY_SECRET);assert.equal(claims?.ownerConnections, true);+ const listServiceCredentials = serviceCreds.listServiceCredentials.bind(serviceCreds);+ serviceCreds.listServiceCredentials = async (...args) =>+ (await listServiceCredentials(...args)).map((record) =>+ record.slug === "composio" ? { ...record, delivery: "broker" } : record,+ );+ const brokerDelivery = await prompt("backend-broker-delivery");+ assert.match(brokerDelivery, /Composio is configured in the backend/);+ assert.doesNotMatch(brokerDelivery, /service_composio|Shared org credentials available to you/);+ serviceCreds.listServiceCredentials = listServiceCredentials;await acl.revoke(org, encodeRef(serviceCredRef("composio")), org, "admin@default-org");assert.doesNotMatch(await prompt("revoked"), /COMPOSIO_API_KEY/);await grantCred(acl, org, "composio");@@ -591,7 +611,7 @@ test("Composio backend access is announced without delivering the project key",assert.doesNotMatch(await prompt("disabled"), /COMPOSIO_API_KEY/);});-test("org env-delivery credentials ride provision env under their envKey — read live, so a rotation applies next turn", async () => {+test("org credentials are delivered only when requested and read live after rotation", async () => {const config = testConfig({dataDir: mkdtempSync(join(tmpdir(), "ap-")),signingSecret: "test-secret",@@ -618,16 +638,27 @@ test("org env-delivery credentials ride provision env under their envKey — reahost: "",});const captures: ProvisionOptions[] = [];+ const executions: SandboxHandle[] = [];+ const realRun = sandbox.run.bind(sandbox);+ sandbox.run = (handle, command, opts) => {+ executions.push(handle);+ return realRun(handle, command, opts);+ };const realProvision = sandbox.provision.bind(sandbox);sandbox.provision = (layers, opts) => {if (opts) captures.push(opts);return realProvision(layers, opts);};- let res = await app.turn(dm("!run echo keys", { conversation: { kind: "dm", threadRef: "dm:U1:env1" } }));+ const request = `!execute ${JSON.stringify({ command: "echo keys", credentials: ["service_browse-steel", "service_browse-model-key"] })}`;+ let res = await app.turn(dm(request, { conversation: { kind: "dm", threadRef: "dm:U1:env1" } }));assert.equal(res.status, "ok");- assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, "steel-org-key");- assert.equal(captures.at(-1)?.env?.BROWSE_LAB_ANTHROPIC_KEY, "model-org-key");+ assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined);+ assert.equal(executions.findLast((handle) => handle.env?.STEEL_API_KEY)?.env?.STEEL_API_KEY, "steel-org-key");+ assert.equal(+ executions.findLast((handle) => handle.env?.BROWSE_LAB_ANTHROPIC_KEY)?.env?.BROWSE_LAB_ANTHROPIC_KEY,+ "model-org-key",+ );await serviceCreds.setServiceCredential(org, {slug: "browse-steel",@@ -637,9 +668,13 @@ test("org env-delivery credentials ride provision env under their envKey — reasecret: "steel-rotated",host: "",});- res = await app.turn(dm("!run echo keys", { conversation: { kind: "dm", threadRef: "dm:U1:env2" } }));+ res = await app.turn(dm(request, { conversation: { kind: "dm", threadRef: "dm:U1:env2" } }));assert.equal(res.status, "ok");- assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, "steel-rotated", "keychain is read at provision time, not boot");+ assert.equal(+ executions.findLast((handle) => handle.env?.STEEL_API_KEY)?.env?.STEEL_API_KEY,+ "steel-rotated",+ "secret is read for each execution",+ );});test("a disabled or broker-delivery credential never rides provision env", async () => {@@ -676,7 +711,7 @@ test("a disabled or broker-delivery credential never rides provision env", asyncconst res = await app.turn(dm("!sysprompt", { conversation: { kind: "dm", threadRef: "dm:U1:env3" } }));assert.equal(res.status, "ok");- assert.doesNotMatch(res.reply ?? "", /## Org credentials on your computer/);+ assert.doesNotMatch(res.reply ?? "", /service_browse-steel/g);const env = captures.at(-1)?.env ?? {};assert.equal(env.STEEL_API_KEY, undefined, "disabled env credential stays home");assert.ok(@@ -714,13 +749,18 @@ test("a credential flipped away from env between the metadata read and the secrereturn realProvision(layers, opts);};- const res = await app.turn(dm("!sysprompt", { conversation: { kind: "dm", threadRef: "dm:U1:env4" } }));- assert.equal(res.status, "ok");- assert.doesNotMatch(res.reply ?? "", /## Org credentials on your computer/);- assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined, "a mid-flight env→broker flip never rides the env");+ await assert.rejects(+ app.turn(+ dm(`!execute ${JSON.stringify({ command: "echo keys", credentials: ["service_browse-steel"] })}`, {+ conversation: { kind: "dm", threadRef: "dm:U1:env4" },+ }),+ ),+ /Service credential is no longer available/,+ );+ assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined);});-test("env-delivery injection is all-internal only, and an existing env key (keychain grant) is never overwritten", async () => {+test("env-delivery credentials are not offered to an external audience", async () => {const config = testConfig({dataDir: mkdtempSync(join(tmpdir(), "ap-")),signingSecret: "test-secret",@@ -756,7 +796,7 @@ test("env-delivery injection is all-internal only, and an existing env key (keyc}),);assert.equal(externalRoom.status, "ok");- assert.doesNotMatch(externalRoom.reply ?? "", /## Org credentials on your computer/);+ assert.doesNotMatch(externalRoom.reply ?? "", /service_browse-steel/g);assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined, "a room with externals gets no org env credentials");});@@ -778,6 +818,12 @@ test("a channel cron receives env credentials only when the directory proves an});await grantCred(acl, org, "browse-steel");const captures: ProvisionOptions[] = [];+ const executions: SandboxHandle[] = [];+ const realRun = sandbox.run.bind(sandbox);+ sandbox.run = (handle, command, opts) => {+ executions.push(handle);+ return realRun(handle, command, opts);+ };const realProvision = sandbox.provision.bind(sandbox);sandbox.provision = (layers, opts) => {if (opts) captures.push(opts);@@ -818,13 +864,21 @@ test("a channel cron receives env credentials only when the directory proves an{owner: "U1",ownerScopeId: scopeId("channel", channelId),- input: "!run echo keys",+ input:+ channelId === "C-internal"+ ? `!execute ${JSON.stringify({ command: "echo keys", credentials: ["service_browse-steel"] })}`+ : "!sysprompt",fireKey: `cron:${channelId}:1`,surface: "cron",},);assert.equal(out.status, "ok", `the ${channelId} cron turn runs`);- return captures.at(-1)?.env?.STEEL_API_KEY;+ assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined);+ if (channelId !== "C-internal") {+ assert.doesNotMatch(out.reply ?? "", /service_browse-steel/);+ return undefined;+ }+ return executions.findLast((handle) => handle.env?.STEEL_API_KEY)?.env?.STEEL_API_KEY;};assert.equal(await fire("C-internal"), "steel-org-key", "an all-internal synced roster admits the env credential");assert.equal(await fire("C-unsynced"), undefined, "a channel with no synced roster stays fail-closed");@@ -849,6 +903,12 @@ test("env-delivery credentials are gated by service-cred grants — no grant, nohost: "",});const captures: ProvisionOptions[] = [];+ const executions: SandboxHandle[] = [];+ const realRun = sandbox.run.bind(sandbox);+ sandbox.run = (handle, command, opts) => {+ executions.push(handle);+ return realRun(handle, command, opts);+ };const realProvision = sandbox.provision.bind(sandbox);sandbox.provision = (layers, opts) => {if (opts) captures.push(opts);@@ -857,20 +917,24 @@ test("env-delivery credentials are gated by service-cred grants — no grant, nolet res = await app.turn(dm("!sysprompt", { conversation: { kind: "dm", threadRef: "dm:U1:gate1" } }));assert.equal(res.status, "ok");- assert.doesNotMatch(res.reply ?? "", /## Org credentials on your computer/);+ assert.doesNotMatch(res.reply ?? "", /service_browse-steel/g);assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined, "ungranted env credential stays home");await grantCred(acl, org, "browse-steel", scopeId("personal", "somebody-else"));res = await app.turn(dm("!sysprompt", { conversation: { kind: "dm", threadRef: "dm:U1:gate2" } }));assert.equal(res.status, "ok");- assert.doesNotMatch(res.reply ?? "", /## Org credentials on your computer/);+ assert.doesNotMatch(res.reply ?? "", /service_browse-steel/g);assert.equal(captures.at(-1)?.env?.STEEL_API_KEY, undefined, "a grant to someone else does not admit this actor");await grantCred(acl, org, "browse-steel", scopeId("personal", "U1"));- res = await app.turn(dm("!run echo keys", { conversation: { kind: "dm", threadRef: "dm:U1:gate3" } }));+ res = await app.turn(+ dm(`!execute ${JSON.stringify({ command: "echo keys", credentials: ["service_browse-steel"] })}`, {+ conversation: { kind: "dm", threadRef: "dm:U1:gate3" },+ }),+ );assert.equal(res.status, "ok");assert.equal(- captures.at(-1)?.env?.STEEL_API_KEY,+ executions.findLast((handle) => handle.env?.STEEL_API_KEY)?.env?.STEEL_API_KEY,"steel-org-key","a personal grant to the actor admits the env var",);diff --git a/test/pi-harness-oneshot.test.ts b/test/pi-harness-oneshot.test.tsindex 72cf5deb1..dd41004f5 100644--- a/test/pi-harness-oneshot.test.ts+++ b/test/pi-harness-oneshot.test.ts@@ -129,7 +129,6 @@ test("piHarnessConfigOptions maps every Config knob the harness consumes, fieldpiSystemCacheSplit: true,sandboxResourcesEnabled: true,scratchExecEnabled: true,- sharedOwnerAuthIsolation: true,reachExecEnabled: true,signingSecret: "sek",apiBaseUrl: "https://core.test",diff --git a/test/sandbox-resources.test.ts b/test/sandbox-resources.test.tsindex 619d984c2..8bcc5ae84 100644--- a/test/sandbox-resources.test.ts+++ b/test/sandbox-resources.test.ts@@ -199,7 +199,6 @@ test("turn default changes invalidate cached provisioning while explicit calls dturnFilesDir: "turn/s/t",connectorEnv: { AGENT_API_TOKEN: "scope-token" },ownerAuthAvailable: false,- ownerEnvCredentialIds: [],credentialCutoverServices: [],visibleSkills: [],visibleSkillsForTurn: async () => [],@@ -428,7 +427,6 @@ for (const shared of [false, true])connectorEnv: {},isolateOwnerKeychain: shared,ownerAuthAvailable: false,- ownerEnvCredentialIds: [],credentialTools: [{ service: "aws", roots: [".aws"] },{ service: "gh", roots: [".config/gh"] },diff --git a/test/scope-reach.test.ts b/test/scope-reach.test.tsindex 200f35e46..93f4a4c68 100644--- a/test/scope-reach.test.ts+++ b/test/scope-reach.test.ts@@ -242,7 +242,14 @@ test("reachExec OFF: the execute scope never accepts a room", () => {test("reachExec ON (no scratch): scope is a free string; a room routes to reachTarget; default is scoped", async () => {const { tc, seen } = sinkToolContext();const [execute] = createAgentTools({ current: tc }, { reachExec: true });- assert.deepEqual(schemaProps(execute!), ["command", "sandbox_id", "purpose", "timeout_seconds", "scope"]);+ assert.deepEqual(schemaProps(execute!), [+ "command",+ "sandbox_id",+ "purpose",+ "timeout_seconds",+ "credentials",+ "scope",+ ]);await call(execute, { command: "cat x", scope: "#project-alpha" });assert.deepEqual(seen.at(-1)!.opts, { reachTarget: "#project-alpha" });await call(execute, { command: "echo hi" });@@ -256,7 +263,15 @@ test("reachExec ON (no scratch): scope is a free string; a room routes to reachTtest("reachExec ON + scratchExec ON: scope accepts scoped, scratch, AND a room", async () => {const { tc, seen } = sinkToolContext();const [execute] = createAgentTools({ current: tc }, { reachExec: true, scratchExec: true });- assert.deepEqual(schemaProps(execute!), ["command", "sandbox_id", "purpose", "timeout_seconds", "scope", "durable"]);+ assert.deepEqual(schemaProps(execute!), [+ "command",+ "sandbox_id",+ "purpose",+ "timeout_seconds",+ "credentials",+ "scope",+ "durable",+ ]);await call(execute, { command: "x", scope: "scratch" });assert.deepEqual(seen.at(-1)!.opts, { scratch: true });await call(execute, { command: "x", scope: "#ops" });diff --git a/test/secret-drop.test.ts b/test/secret-drop.test.tsindex b6fb5158e..e337fe019 100644--- a/test/secret-drop.test.ts+++ b/test/secret-drop.test.ts@@ -434,8 +434,8 @@ describe("/v1/keychain/drops — mint, form, redeem", async () => {const m = await built.keychain!.materialize(g!.grant.id, scopeId("channel", "C1"), "U_A");assert.ok(m.kind === "env");assert.deepEqual(m.kind === "env" ? m.env : [], [- { key: "DOORDASH_EMAIL", value: "[email protected]" },- { key: "DOORDASH_PASSWORD", value: "hunter2" },+ { key: "DOORDASH_EMAIL", value: "[email protected]", secret: false },+ { key: "DOORDASH_PASSWORD", value: "hunter2", secret: true },]);});diff --git a/test/secret-masking.test.ts b/test/secret-masking.test.tsindex bc6b5bcac..ce3c95cd3 100644--- a/test/secret-masking.test.ts+++ b/test/secret-masking.test.ts@@ -1,6 +1,10 @@import { test } from "node:test";import assert from "node:assert/strict";-import { createSecretValueMasker } from "../src/security/secret-masking.ts";+import {+ createSecretValueMasker,+ createExactSecretValueMasker,+ executionSecretEnv,+} from "../src/security/secret-masking.ts";const SECRET = "ghp_secretvalue12345";@@ -64,3 +68,34 @@ test("a JWT-shaped (base64url) form of a secret is masked", () => {'curl -H "authorization: Bearer <redacted:VAULT_PASS>"',);});++test("exact masking preserves surrounding output, handles overlapping values and short secrets once", () => {+ const mask = createExactSecretValueMasker(["a+b", "a", "", "a+b", "<redacted:credential>"]);+ assert.equal(mask("prefix a+b a suffix"), "prefix <redacted:credential> <redacted:credential> suffix");+ assert.equal(createExactSecretValueMasker([])("safe"), "safe");+ assert.equal(createExactSecretValueMasker(["secret"])("c2VjcmV0"), "c2VjcmV0");+});++test("explicit secret fields override configuration names while public fields stay public", () => {+ const env = { AWS_REGION: "credential", USERNAME: "a", PASSWORD: "short", TOKEN: "" };+ const secrets = executionSecretEnv(env, [+ { key: "AWS_REGION", value: "credential", secret: true },+ { key: "USERNAME", value: "a", secret: false },+ { key: "UNRELATED", value: "other", secret: true },+ ]);+ assert.deepEqual(secrets, { AWS_REGION: "credential", PASSWORD: "short", TOKEN: "" });+ assert.equal(createExactSecretValueMasker(Object.values(secrets))("safe unrelated data"), "safe unrelated data");+ assert.equal(createExactSecretValueMasker(Object.values(secrets))("credential"), "<redacted:credential>");+ const mask = createExactSecretValueMasker(Object.values(executionSecretEnv({ AWS_REGION: "us-west-2", TOKEN: "" })));+ assert.equal(mask("us-west-2"), "us-west-2");+});++test("conflicting public metadata cannot exempt an explicitly secret value", () => {+ assert.deepEqual(+ executionSecretEnv({ TOKEN: "protected" }, [+ { key: "TOKEN", value: "protected", secret: true },+ { key: "TOKEN", value: "protected", secret: false },+ ]),+ { TOKEN: "protected" },+ );+});diff --git a/test/security-posture.test.ts b/test/security-posture.test.tsindex 83e73b61e..2e74a58b6 100644--- a/test/security-posture.test.ts+++ b/test/security-posture.test.ts@@ -244,7 +244,7 @@ test("tool results carry a provenance class and only external content reaches thassert.equal(toolResultProvenance(tool), "internal", `${tool} echoes the agent's own state`);}assert.equal(toolResultProvenance("read"), "workspace", "read serves the agent's own workspace");- for (const tool of ["slack", "credential_exec", "some_mcp_tool", "execute", "memory", "history"]) {+ for (const tool of ["slack", "some_mcp_tool", "execute", "memory", "history"]) {assert.equal(toolResultProvenance(tool), "external", `${tool} can carry content from outside`);}});diff --git a/test/service-credential-route.test.ts b/test/service-credential-route.test.tsindex 7e0287df8..6a3c2aed4 100644--- a/test/service-credential-route.test.ts+++ b/test/service-credential-route.test.ts@@ -1002,6 +1002,7 @@ function buildWithCapture() {const built = buildApp(testConfig({dataDir: mkdtempSync(join(tmpdir(), "svc-cred-stamp-")),+ maxAttempts: 1,signingSecret: SECRET,apiBaseUrl: "http://core.internal",}),@@ -1012,11 +1013,17 @@ function buildWithCapture() {captured = opts?.env;return realProvision(layers, opts);};- return { built, env: () => captured };+ let executed: Record<string, string> | undefined;+ const realRun = built.sandbox.run.bind(built.sandbox);+ built.sandbox.run = (handle, command, opts) => {+ if (command === "echo hi" || command === "echo bot") executed = handle.env;+ return realRun(handle, command, opts);+ };+ return { built, env: () => captured, executionEnv: () => executed };}-test("orchestrator stamps AGENT_CREDENTIAL_TOKEN with an org-wide credential's slug", async () => {- const { built, env } = buildWithCapture();+test("orchestrator vends a capability for only the requested org credential", async () => {+ const { built, env, executionEnv } = buildWithCapture();await built.serviceCreds.setServiceCredential("org:default-org", {slug: "x-firehose",name: "X",@@ -1031,9 +1038,27 @@ test("orchestrator stamps AGENT_CREDENTIAL_TOKEN with an org-wide credential's sgrantedBy: "admin",});- const res = await built.app.turn(dm("!run echo hi"));+ await built.serviceCreds.setServiceCredential("org:default-org", {+ slug: "unselected",+ name: "Unselected",+ secret: "synthetic-unused",+ host: "other.example.com",+ });+ await built.acl.grant({+ ownerScopeId: "org:default-org",+ ref: "service-cred:unselected",+ granteeScopeId: "org:default-org",+ permission: "read",+ grantedBy: "admin",+ });+ await built.app.turn(dm("!run echo hi"));+ assert.equal(executionEnv()?.AGENT_CREDENTIAL_TOKEN, undefined);+ const res = await built.app.turn(+ dm(`!execute ${JSON.stringify({ command: "echo hi", credentials: ["service_x-firehose"] })}`),+ );assert.equal(res.status, "ok", res.reason);- const token = env()?.AGENT_CREDENTIAL_TOKEN;+ assert.equal(env()?.AGENT_CREDENTIAL_TOKEN, undefined);+ const token = executionEnv()?.AGENT_CREDENTIAL_TOKEN;assert.ok(token, "expected a credential-broker token in the sandbox env");const claims = await verifyCapabilityToken(token!, TEST_CAPABILITY_SECRET);assert.equal(claims?.aud, CREDENTIAL_BROKER_AUD);@@ -1053,9 +1078,9 @@ test("orchestrator stamps AGENT_CREDENTIAL_TOKEN with an org-wide credential's saudience: [actor],publishMembers: [actor],},- text: "!run echo bot",+ text: `!execute ${JSON.stringify({ command: "echo bot", credentials: ["service_x-firehose"] })}`,});- const botClaims = await verifyCapabilityToken(env()!.AGENT_CREDENTIAL_TOKEN!, TEST_CAPABILITY_SECRET);+ const botClaims = await verifyCapabilityToken(executionEnv()!.AGENT_CREDENTIAL_TOKEN!, TEST_CAPABILITY_SECRET);assert.equal(botClaims?.botActor, true);assert.equal(botClaims?.liveActor, true);assert.deepEqual(botClaims?.members, [{ id: "B-LEGACY", type: "internal" }]);@@ -1077,13 +1102,17 @@ test("orchestrator does NOT stamp a credential granted only to someone else", asgrantedBy: "admin",});+ await assert.rejects(+ built.app.turn(dm(`!execute ${JSON.stringify({ command: "echo hi", credentials: ["service_x-firehose"] })}`)),+ /not available/,+ );const res = await built.app.turn(dm("!run echo hi"));assert.equal(res.status, "ok", res.reason);assert.equal(env()?.AGENT_CREDENTIAL_TOKEN, undefined, "an unentitled session must get no credential token");});test("a channel grantee stamps the credential in that channel's conversations and nowhere else", async () => {- const { built, env } = buildWithCapture();+ const { built, env, executionEnv } = buildWithCapture();await built.serviceCreds.setServiceCredential("org:default-org", {slug: "x-firehose",name: "X",@@ -1111,17 +1140,34 @@ test("a channel grantee stamps the credential in that channel's conversations antext: "!run echo hi",});- let res = await built.app.turn(channelTurn("C1"));+ await built.app.turn(channelTurn("C1"));+ assert.equal(executionEnv()?.AGENT_CREDENTIAL_TOKEN, undefined);+ let res = await built.app.turn({+ ...channelTurn("C1"),+ text: `!execute ${JSON.stringify({ command: "echo hi", credentials: ["service_x-firehose"] })}`,+ });assert.equal(res.status, "ok", res.reason);- const token = env()?.AGENT_CREDENTIAL_TOKEN;+ assert.equal(env()?.AGENT_CREDENTIAL_TOKEN, undefined);+ const token = executionEnv()?.AGENT_CREDENTIAL_TOKEN;assert.ok(token, "the granted channel's conversation should get a credential token");const claims = await verifyCapabilityToken(token!, TEST_CAPABILITY_SECRET);assert.deepEqual(claims?.credentials, ["x-firehose"]);+ await assert.rejects(+ built.app.turn({+ ...channelTurn("C2"),+ text: `!execute ${JSON.stringify({ command: "echo hi", credentials: ["service_x-firehose"] })}`,+ }),+ /not available/,+ );res = await built.app.turn(channelTurn("C2"));assert.equal(res.status, "ok", res.reason);assert.equal(env()?.AGENT_CREDENTIAL_TOKEN, undefined, "another channel must not get the credential");+ await assert.rejects(+ built.app.turn(dm(`!execute ${JSON.stringify({ command: "echo hi", credentials: ["service_x-firehose"] })}`)),+ /not available/,+ );res = await built.app.turn(dm("!run echo hi"));assert.equal(res.status, "ok", res.reason);assert.equal(env()?.AGENT_CREDENTIAL_TOKEN, undefined, "a member's DM must not get a channel-granted credential");diff --git a/test/sharing-context-e2e.test.ts b/test/sharing-context-e2e.test.tsindex e3787e2c3..f5cc5feef 100644--- a/test/sharing-context-e2e.test.ts+++ b/test/sharing-context-e2e.test.ts@@ -1,3 +1,4 @@+import { credentialHandle } from "../src/credentials/keychain.ts";import "./support/auto-fake-sprites.ts";import { test, type TestContext } from "node:test";import assert from "node:assert/strict";@@ -425,11 +426,12 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, andsigningSecret: "open-keychain-test-signing-key",apiBaseUrl: "http://core.test",maxAttempts: 1,- sharedOwnerAuthIsolation: false,});assert.ok(b.keychain);+ const handles = new Map<string, string>();for (const id of ["U1", "U2"]) {- await b.keychain.save({ ownerId: id, service: "npm", secret: `npm_${id}`, envKey: "NPM_TOKEN" });+ const credential = await b.keychain.save({ ownerId: id, service: "npm", secret: `npm_${id}`, envKey: "NPM_TOKEN" });+ handles.set(id, credentialHandle(credential.id));await b.keychain.save({ownerId: id,service: "custom-cli",@@ -447,12 +449,14 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, andassert.ok(!prompt.includes("npm_U1"));await b.workspace.write("channel:C1", "room-only.txt", "room_data");const probe = `python3 -c 'import os,pathlib; p=pathlib.Path.home()/".custom-cli/auth"; print("|".join([os.getenv("NPM_TOKEN","unset"),os.getenv("VAULT_TOKEN_GMAIL_GOOGLEAPIS_COM","unset"),p.read_text() if p.exists() else "absent",os.getenv("AGENT_API_TOKEN","unset"),"room" if pathlib.Path("room-only.txt").exists() else "isolated"]))'`;- assert.equal(await b.turn(`!owner ${probe}`, true), "npm_U1|gmail_U1|file_U1|unset|isolated");- assert.equal(await b.turn(`!owner ${probe}`, true, "U2"), "npm_U2|gmail_U2|file_U2|unset|isolated");+ const selected = (id = "U1") =>+ `!execute ${JSON.stringify({ command: probe.replace('os.getenv("NPM_TOKEN","unset")', `str(os.getenv("NPM_TOKEN") == "npm_${id}")`).replace('os.getenv("VAULT_TOKEN_GMAIL_GOOGLEAPIS_COM","unset")', `str(os.getenv("VAULT_TOKEN_GMAIL_GOOGLEAPIS_COM") == "gmail_${id}")`), ownerAuth: true, credentials: [handles.get(id), "connector_gmail_googleapis_com_default"] })}`;+ assert.equal(await b.turn(selected(), true), "True|True|file_U1|unset|isolated");+ assert.equal(await b.turn(selected("U2"), true, "U2"), "True|True|file_U2|unset|isolated");for (const id of ["U1", "U2", "U1"]) {assert.equal(- await b.turn(`!owner ${probe}`, true, id, { origin: { kind: "ambient", live: true } }),- `npm_${id}|gmail_${id}|file_${id}|unset|isolated`,+ await b.turn(selected(id), true, id, { origin: { kind: "ambient", live: true } }),+ `True|True|file_${id}|unset|isolated`,);}const ambientPrompt = await b.turn("!sysprompt", true, "U2", { origin: { kind: "ambient", live: true } });@@ -465,7 +469,7 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, and]);for (const origin of [{ kind: "human" }, { kind: "ambient", live: true }] as const) {assert.equal(- await b.turn(`!owner ${probe}`, true, "U1", {+ await b.turn(selected(), true, "U1", {origin,conversation: {kind: "group",@@ -475,7 +479,7 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, andpublishMembers: [{ externalId: "U1" }, { externalId: "U2" }],},}),- "npm_U1|gmail_U1|file_U1|unset|isolated",+ "True|True|file_U1|unset|isolated",);}assert.deepEqual(await b.keychain.grantsForScope("group:G1"), []);@@ -515,7 +519,7 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, andawait assert.rejects(denied({ kind: "ambient" }), /owner-auth box is not available/);await assert.rejects(denied({ kind: "ambient", live: false }), /owner-auth box is not available/);const firstTurn = (channelRef: string, origin: TurnRequest["origin"] = { kind: "human" }) =>- b.turn(`!owner ${probe}`, true, "U1", {+ b.turn(selected(), true, "U1", {origin,conversation: {kind: "channel",@@ -525,11 +529,8 @@ test("Open speaker keychain uses a disposable computer, follows the speaker, andpublishMembers: [{ externalId: "U1" }, { externalId: "U2" }],},});- assert.equal(await firstTurn("C-unsynced"), "npm_U1|gmail_U1|file_U1|unset|isolated");- assert.equal(- await firstTurn("C-unsynced", { kind: "ambient", live: true }),- "npm_U1|gmail_U1|file_U1|unset|isolated",- );+ assert.equal(await firstTurn("C-unsynced"), "True|True|file_U1|unset|isolated");+ assert.equal(await firstTurn("C-unsynced", { kind: "ambient", live: true }), "True|True|file_U1|unset|isolated");await b.remove("U1");const removed = (origin: TurnRequest["origin"] = { kind: "human" }) =>b.turn("!owner true", true, "U1", {diff --git a/test/skills-source-read.test.ts b/test/skills-source-read.test.tsindex 90c7a847d..9003aa014 100644--- a/test/skills-source-read.test.ts+++ b/test/skills-source-read.test.ts@@ -160,7 +160,6 @@ test("a body read avoids sandbox work and a file request materializes that skillturnSessionDir: "turn/s",turnFilesDir: "turn/s/t",connectorEnv: {},- ownerEnvCredentialIds: [],credentialCutoverServices: [],visibleSkillsForTurn: async () => visible,emitGapWork: () => {},diff --git a/test/swarm-orchestrator.test.ts b/test/swarm-orchestrator.test.tsindex bb8fef2b4..d267a318f 100644--- a/test/swarm-orchestrator.test.ts+++ b/test/swarm-orchestrator.test.ts@@ -228,6 +228,23 @@ for (const storage of ["memory", "postgres"] as const) {}}let built = buildApp(config);+ const tokenCommand = "printf '%s' \"$AGENT_API_TOKEN\"";+ const issuedTokens = new Map<string, string>();+ const captureIssuedTokens = () => {+ const run = built.sandbox.run.bind(built.sandbox);+ built.sandbox.run = async (handle, command, opts) => {+ if (command === tokenCommand) {+ const token = handle.env?.AGENT_API_TOKEN;+ assert.ok(token, "the orchestrator supplies a capability to the sandbox");+ const claims = await verifyCapabilityToken(token, config.capabilitySecret!);+ assert.ok(claims?.sessionId);+ assert.ok(claims?.runId);+ issuedTokens.set(`${claims.sessionId}:${claims.runId}`, token);+ }+ return run(handle, command, opts);+ };+ };+ captureIssuedTokens();const { serverDeps } = await import("../src/wiring.ts");let server = createServer(built.app, serverDeps(config, built));await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));@@ -237,9 +254,11 @@ for (const storage of ["memory", "postgres"] as const) {const issued: Array<{ sessionId: string; attempt: number }> = [];exerciseTurn = async (turn) => {if (turn.input !== "http-swarm-root" && !turn.input.includes("http-swarm-worker")) return;- const result = await turn.tools.execute("printf '%s' \"$AGENT_API_TOKEN\"");+ const result = await turn.tools.execute(tokenCommand);assert.equal(result.code, 0, result.stderr);- const token = result.stdout.trim();+ assert.equal(result.stdout, "<redacted:credential>");+ const token = issuedTokens.get(`${turn.session.id}:${turn.runId}`);+ assert.ok(token, "the HTTP fixture uses the actual issued capability, outside tool output");const claims = await verifyCapabilityToken(token, config.capabilitySecret!);assert.equal(claims?.sessionId, turn.session.id);assert.equal(claims?.runId, turn.runId);@@ -328,6 +347,7 @@ for (const storage of ["memory", "postgres"] as const) {await new Promise<void>((resolve) => server.close(() => resolve()));await built.runtime.stop();built = buildApp(config);+ captureIssuedTokens();server = createServer(built.app, serverDeps(config, built));await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;diff --git a/test/swarms.test.ts b/test/swarms.test.tsindex 9df6b191d..48aeb5f2b 100644--- a/test/swarms.test.ts+++ b/test/swarms.test.ts@@ -883,8 +883,6 @@ test("the orchestrator sandbox path selects worker storage without changing authconnectorEnv: {},isolateOwnerKeychain: false,ownerAuthAvailable: false,- ownerAuthEnv: {},- ownerEnvCredentialIds: [],credentialTools: [],credentialServices: [],credentialCutoverServices: [],diff --git a/test/system-prompt-order.test.ts b/test/system-prompt-order.test.tsindex 9feef1fbc..b57716316 100644--- a/test/system-prompt-order.test.ts+++ b/test/system-prompt-order.test.ts@@ -80,6 +80,7 @@ const connectorStatusCache: ConnectorStatusCache = {put: async () => {},};const connectorTokens = {+ listConnectorsByOwners: async () => new Map(),connectorAccessToken: async () => null,connectorTokenStatus: () => {throw new Error("connector tokens must not be swept when the status cache is fresh");