diff --git a/docs/agent-orchestration.md b/docs/agent-orchestration.md index 08114b621..0ec03eaa1 100644 --- a/docs/agent-orchestration.md +++ b/docs/agent-orchestration.md @@ -48,6 +48,7 @@ The core applies these to every way an agent can start another one: `spawn_agent | Plugin launch options | `launchOptions` from an orchestrator reach only plugins that declared `launch.delegable: true`; everything a plugin contributes still passes the core-owned flag and configuration checks (no permission, sandbox, hook or bypass flags, no OpenCode/Kimi configuration that sets approvals). | | YOLO | Enforced in the main process: only for a CLI the person acknowledged YOLO for in the launcher, never for a subagent, never from an orchestrator's control connection; a plugin with `sessions:launch` needs the same acknowledgement. | | Isolation | Every subagent and every agent a plugin starts runs inside agent isolation (below) when it is on; where there is no layer, a subagent runs in normal (it asks) and its card says why. | +| Provider keys | A subagent and every card a plugin starts (a plain terminal card included) inherit only an allowlist of the person's environment (path, home, locale, terminal, temporary and XDG base folders, proxy and certificate variables, the CLIs' home folders): no provider API key (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, …), token (`GH_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN`, …), cloud credential, admin key, CanvasTTY credential (`CANVASTTY_GITHUB_TOKEN`) or OpenCode inline config, also not through the configuration CanvasTTY adds for the launch. A key it needs comes from a launch contribution's `secretEnv`, or the person lists the variable in `CANVASTTY_AGENT_PASS_ENV`. Orchestrators cannot start plain terminal cards. See [installing-and-security.md](installing-and-security.md#agent-protection-layers). | | No settings | The `canvastty_agents` tools and an orchestrator's control connection cannot change settings, base protection, profiles, plugin trust or isolation. | ## Agent isolation diff --git a/docs/installing-and-security.md b/docs/installing-and-security.md index 7772f6871..23b0671c5 100644 --- a/docs/installing-and-security.md +++ b/docs/installing-and-security.md @@ -95,6 +95,8 @@ Agents work in their own mode; CanvasTTY's layers sit outside it as a quiet safe Isolation keeps approval configuration read-only, including OpenCode's project and custom config files and its `agent`/`agents` directories. CLI state and caches remain writable. A moved CLI home is refused if its real path overlaps host credentials or private CanvasTTY data; a selected account folder below `account-homes` remains available. Credential exclusions use the host environment captured before launch contributions, even if the launch changes `HOME`. +**Provider keys in the environment.** A plain terminal card you start keeps your whole environment, except CanvasTTY's own credentials (`CANVASTTY_GITHUB_TOKEN`, any `CANVASTTY_*TOKEN`/`*KEY`/`*SECRET`/`*PASSWORD`), which only the app uses. An agent card never inherits those nor organization-level admin credentials (`OPENAI_ADMIN_KEY`, `ANTHROPIC_ADMIN_KEY`, any `*_ADMIN_*KEY` or `*_ADMIN_*TOKEN`), whoever starts it. An agent you start yourself otherwise keeps your environment, ordinary provider keys such as `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` included, in every profile, so a CLI signed in by API key keeps working (an exported `ANTHROPIC_API_KEY` still takes precedence over Claude Code's subscription sign-in). Subagents and every card a plugin starts (a plain terminal card included, since the plugin drives it) inherit only what a process needs: `PATH`, `HOME`, user, shell, locale and terminal variables, temporary folders, the XDG base folders and desktop type (`XDG_CONFIG_HOME`, `XDG_RUNTIME_DIR`, `XDG_CURRENT_DESKTOP`, …; other `XDG_` and `LC_` variables are not inherited, so a session cookie such as `XDG_SESSION_COOKIE` is not), the Windows system folders, proxy variables (`HTTP(S)_PROXY`, `ALL_PROXY`, `NO_PROXY`), certificate settings (`SSL_CERT_FILE`, `SSL_CERT_DIR`, `NODE_EXTRA_CA_CERTS`, `REQUESTS_CA_BUNDLE`, `CURL_CA_BUNDLE`), `EDITOR`/`VISUAL`/`PAGER` and the CLIs' own home folders (`CODEX_HOME`, `CLAUDE_CONFIG_DIR`, …). No provider key, token, cloud credential, `SSH_AUTH_SOCK` or OpenCode inline config (`OPENCODE_CONFIG_CONTENT`, which can hold keys) reaches them, also not through the configuration CanvasTTY adds for the launch; a key they need comes explicitly, through a launch contribution's `secretEnv`. To pass a variable anyway, list it in `CANVASTTY_AGENT_PASS_ENV` (comma-separated, e.g. `CANVASTTY_AGENT_PASS_ENV=OPENAI_ADMIN_KEY`) in the environment CanvasTTY starts with. This is about inherited variables only: without the isolation layer an agent runs as you and can still read a key from your shell profile file, and a plain terminal card runs your login shell, which reads that file. + OpenCode Auto inspects only regular local config files of at most 1 MiB. An existing source that cannot be inspected adds no Auto allowances. A launch contributor's uninspectable config is refused; only absent optional directory candidates are skipped. JSONC comments and trailing commas are parsed without changing quoted strings. **Git audit.** When an isolated agent session ends, is closed or is restored after a quit, CanvasTTY checks the repositories under its folder whose git folder changed. If git would now run something outside isolation (a `core.hooksPath`, a filter or diff driver, `fsmonitor`, a hook file, `info/attributes`), a notice lists exactly what changed; **Neutralize** removes those keys and disables those files, **Keep as is** leaves them. It does not undo other file changes inside the project. diff --git a/docs/installing-and-security.ru.md b/docs/installing-and-security.ru.md index 91e9598c8..091c668e4 100644 --- a/docs/installing-and-security.ru.md +++ b/docs/installing-and-security.ru.md @@ -91,6 +91,8 @@ gh variable set SPARKLE_PUBLIC_ED_KEY --repo howdeploy/CanvasTTY \ **Аудит git.** Когда изолированная сессия агента заканчивается, закрывается или восстанавливается после выхода, CanvasTTY проверяет репозитории в её папке, у которых изменилась папка git. Если git теперь запустит что-то вне изоляции (`core.hooksPath`, фильтр или diff-драйвер, `fsmonitor`, файл хука, `info/attributes`), появляется уведомление со списком изменений; **Обезвредить** удаляет эти ключи и отключает файлы, **Оставить как есть** ничего не трогает. Другие изменения файлов в проекте аудит не откатывает. +**Ключи провайдеров в окружении.** Обычный терминал, запущенный вами, получает всё ваше окружение, кроме собственных учётных данных CanvasTTY (`CANVASTTY_GITHUB_TOKEN`, любые `CANVASTTY_*TOKEN`/`*KEY`/`*SECRET`/`*PASSWORD`), которые нужны только приложению. Карточка агента никогда не наследует ни их, ни админ-ключи и админ-токены организации (`OPENAI_ADMIN_KEY`, `ANTHROPIC_ADMIN_KEY`, любые `*_ADMIN_*KEY` и `*_ADMIN_*TOKEN`). В остальном агент, запущенный вами, получает ваше окружение, включая обычные ключи вроде `OPENAI_API_KEY` и `ANTHROPIC_API_KEY`, в любом режиме, так что CLI со входом по API-ключу работает как раньше. Субагенты и любые карточки, запущенные плагинами (включая обычный терминал, ведь им управляет плагин), наследуют только то, что нужно процессу: `PATH`, `HOME`, переменные пользователя, оболочки, локали и терминала, временные папки, базовые XDG-папки и тип рабочего стола (`XDG_CONFIG_HOME`, `XDG_RUNTIME_DIR`, `XDG_CURRENT_DESKTOP`, …; прочие переменные `XDG_` и `LC_` не наследуются, а значит, и cookie сеанса вроде `XDG_SESSION_COOKIE`), системные папки Windows, прокси (`HTTP(S)_PROXY`, `ALL_PROXY`, `NO_PROXY`), настройки сертификатов (`SSL_CERT_FILE`, `SSL_CERT_DIR`, `NODE_EXTRA_CA_CERTS`, `REQUESTS_CA_BUNDLE`, `CURL_CA_BUNDLE`), `EDITOR`/`VISUAL`/`PAGER` и домашние папки CLI (`CODEX_HOME`, `CLAUDE_CONFIG_DIR`, …). Ни ключей провайдеров, ни токенов, ни облачных учётных данных, ни `SSH_AUTH_SOCK`, ни встроенной конфигурации OpenCode (`OPENCODE_CONFIG_CONTENT`, в ней бывают ключи) они не получают, в том числе через конфигурацию, которую CanvasTTY добавляет к запуску; нужный ключ передаётся явно, через `secretEnv` вклада в запуск. Чтобы всё же передать переменную, перечислите её в `CANVASTTY_AGENT_PASS_ENV` (через запятую) в окружении, с которым запускается CanvasTTY. Речь только о наследуемых переменных: без слоя изоляции агент работает от вашего имени и может прочитать ключ из файла профиля оболочки, а обычный терминал запускает вашу login-оболочку, которая этот файл читает. + ### Linux: если bubblewrap не запускается Ubuntu 24.04 и новее (и другие дистрибутивы с `kernel.apparmor_restrict_unprivileged_userns=1`) разрешают создавать непривилегированные пространства имён пользователя только программам с профилем AppArmor, а bubblewrap без них не работает. CanvasTTY проверяет это один раз (после неудачи — снова через минуту) и при включённой изоляции, если `bwrap` установлен, но не запускается, ведёт себя как на компьютере без слоя изоляции: субагенты и агенты от плагинов работают вручную, а карточка объясняет почему. Чтобы разрешить, дайте bubblewrap собственный профиль (рекомендуется, касается только `bwrap`): diff --git a/docs/installing-and-security.zh-CN.md b/docs/installing-and-security.zh-CN.md index 802bfc603..0f32579f7 100644 --- a/docs/installing-and-security.zh-CN.md +++ b/docs/installing-and-security.zh-CN.md @@ -91,6 +91,8 @@ gh variable set SPARKLE_PUBLIC_ED_KEY --repo howdeploy/CanvasTTY \ **Git 审计。** 隔离的智能体会话结束、被关闭或在退出后恢复时,CanvasTTY 会检查其文件夹下 git 目录发生变化的仓库。如果 git 现在会在隔离外运行某些东西(`core.hooksPath`、filter 或 diff 驱动、`fsmonitor`、hook 文件、`info/attributes`),会出现一条列出具体变化的通知;**Neutralize** 删除这些键并停用这些文件,**Keep as is** 保持不变。它不会撤销项目内的其他文件改动。 +**环境中的服务商密钥。** 你自己启动的普通终端卡片保留你的全部环境,但不包括 CanvasTTY 自己的凭据(`CANVASTTY_GITHUB_TOKEN`,以及任何 `CANVASTTY_*TOKEN`/`*KEY`/`*SECRET`/`*PASSWORD`),它们只供应用本身使用。智能体卡片永远不会继承这些凭据,也不会继承组织级管理员凭据(`OPENAI_ADMIN_KEY`、`ANTHROPIC_ADMIN_KEY`,以及任何 `*_ADMIN_*KEY` 或 `*_ADMIN_*TOKEN`)。除此之外,你自己启动的智能体在任何模式下都保留你的环境,包括 `OPENAI_API_KEY`、`ANTHROPIC_API_KEY` 等普通密钥,因此用 API 密钥登录的 CLI 照常工作。子智能体以及插件启动的任何卡片(包括普通终端卡片,因为由插件操控)只继承进程所需的变量:`PATH`、`HOME`、用户、shell、语言区域和终端变量、临时目录、XDG 基础目录和桌面类型(`XDG_CONFIG_HOME`、`XDG_RUNTIME_DIR`、`XDG_CURRENT_DESKTOP` 等;其他 `XDG_` 和 `LC_` 变量不会继承,因此 `XDG_SESSION_COOKIE` 这类会话 cookie 也不会)、Windows 系统目录、代理变量(`HTTP(S)_PROXY`、`ALL_PROXY`、`NO_PROXY`)、证书设置(`SSL_CERT_FILE`、`SSL_CERT_DIR`、`NODE_EXTRA_CA_CERTS`、`REQUESTS_CA_BUNDLE`、`CURL_CA_BUNDLE`)、`EDITOR`/`VISUAL`/`PAGER` 以及各 CLI 自己的主目录(`CODEX_HOME`、`CLAUDE_CONFIG_DIR` 等)。它们拿不到任何服务商密钥、令牌、云凭据、`SSH_AUTH_SOCK` 或 OpenCode 内联配置(`OPENCODE_CONFIG_CONTENT`,其中可能含有密钥),通过 CanvasTTY 为启动添加的配置也不会;需要的密钥通过启动贡献的 `secretEnv` 显式传入。如仍要传递某个变量,请在 CanvasTTY 启动时的环境中把它列入 `CANVASTTY_AGENT_PASS_ENV`(逗号分隔)。这里只涉及继承的变量:没有隔离层时,智能体以你的身份运行,仍可从 shell 配置文件中读取密钥;普通终端卡片运行你的登录 shell,也会读取该文件。 + ### Linux:bubblewrap 无法启动时 Ubuntu 24.04 及更新版本(以及其他设置了 `kernel.apparmor_restrict_unprivileged_userns=1` 的发行版)只允许带 AppArmor 配置文件的程序创建非特权用户命名空间,而 bubblewrap 需要它。CanvasTTY 会检查一次(失败后一分钟再查),启用隔离时,如果 `bwrap` 已安装却无法启动,就按没有隔离层的电脑处理:子智能体和插件启动的智能体以手动模式运行,卡片会说明原因。要允许它,可以为 bubblewrap 单独添加配置文件(推荐,只影响 `bwrap`): diff --git a/src/main/services/TerminalManager.ts b/src/main/services/TerminalManager.ts index 03d2417e8..c7da4e768 100644 --- a/src/main/services/TerminalManager.ts +++ b/src/main/services/TerminalManager.ts @@ -82,6 +82,7 @@ import { LaunchRefusal } from "./launchRefusal.ts"; import { configuredMode } from "./configuredMode.ts"; import { envKey, RESERVED_ENV, type LaunchPipeline, type PreparedLaunch } from "./LaunchPipeline.ts"; import type { EnvironmentRegistry } from "./EnvironmentRegistry.ts"; +import { agentEnvironment, shellEnvironment } from "./ambientProviderKeys.ts"; import { persistedTerminalSession, normalizeNestedCodex, @@ -2061,19 +2062,27 @@ export class TerminalManager { ): PlannedSpawn | { failure: LaunchFailure } { const providerCli = provider === "terminal" ? undefined : this.providerClis.get(provider); if (providerCli?.state === "unavailable") return { failure: providerCli }; + // The person's environment: a plain shell the person starts keeps all of it but CanvasTTY's own credentials; their + // own agent cards also lose admin keys; a delegated card (a subagent, or any card a plugin started, plain shell + // included, since its owner drives it) gets only an allowlist (ambientProviderKeys.ts). Every launch builder below + // reads this, never process.env; what a launch sets explicitly is added on top. + const delegated = this.isDelegated(id, role); + const baseEnvironment = provider === "terminal" && !delegated + ? shellEnvironment(terminalEnvironment()) + : agentEnvironment(terminalEnvironment(), { delegated }); // What decides whether Claude's lifecycle hooks may go over HTTP (ClaudeHttpHooks.ts): where and how it runs. const claudeHttp = provider === "claude" && providerCli?.state === "available" ? { executable: providerCli.executable, profile, environmentWrapped, - env: { ...terminalEnvironment(), ...providerCli.environment, ...(contribution?.env ?? {}) }, + env: { ...baseEnvironment, ...providerCli.environment, ...(contribution?.env ?? {}) }, args: contribution?.args ?? [], cwd } : undefined; const shellCli = provider === "terminal" && !environmentWrapped ? this.providerClis.get("codex") : undefined; const agentRuntime = provider === "terminal" - ? shellCli?.state === "available" ? this.agentRuntime?.prepareShellLaunch?.({ terminalSessionId: id, cli: shellCli, environment: terminalEnvironment() }) ?? null : null - : this.agentRuntime?.prepareLaunch({ terminalSessionId: id, provider, cwd, + ? shellCli?.state === "available" ? this.agentRuntime?.prepareShellLaunch?.({ terminalSessionId: id, cli: shellCli, environment: baseEnvironment }) ?? null : null + : this.agentRuntime?.prepareLaunch({ terminalSessionId: id, provider, cwd, environment: baseEnvironment, ...(captureResult ? { captureResult: true } : {}), ...(claudeHttp ? { claudeHttp } : {}), ...(answerCaptureGrantExpiresAt === undefined ? {} : { answerCaptureGrantExpiresAt }) }) ?? null; @@ -2106,12 +2115,12 @@ export class TerminalManager { terminalSessionId: id, provider, cwd, + environment: baseEnvironment, ...(bridged ? { includeOrchestration: true, orchestrationTools: [...(role === "orchestrator" ? ORCHESTRATION_TOOL_NAMES : []), ...pluginTools] } : {}) }) ?? null; - const baseEnvironment = terminalEnvironment(); const browserEnvironment = agentBrowser?.environment ?? {}; const runtimeEnvironment = agentRuntime?.environment ?? {}; const orchestrationEnvironment = agentOrchestration?.environment ?? {}; diff --git a/src/main/services/agent-browser/AgentBrowserBridge.ts b/src/main/services/agent-browser/AgentBrowserBridge.ts index 06fa4f53b..ec06f58de 100644 --- a/src/main/services/agent-browser/AgentBrowserBridge.ts +++ b/src/main/services/agent-browser/AgentBrowserBridge.ts @@ -14,6 +14,8 @@ export interface PrepareAgentBrowserLaunchInput { includeOrchestration?: boolean; /** The canvastty_agents tools this session may use (default: the core tools). */ orchestrationTools?: readonly string[]; + /** The card's own (already filtered) environment, which the launch builds from instead of the app's. */ + environment?: Readonly>; } export interface PreparedAgentBrowserPtyLaunch { @@ -66,12 +68,14 @@ export class AgentBrowserBridge implements AgentBrowserLaunchCoordinator { // Browser access off: no canvastty_browser and no browser capability, but a session that gets canvastty_agents // (orchestrators, plugin tools) still gets it; that server has its own capability and gateway. if (!this.gateway.isEnabled) return input.includeOrchestration ? this.prepareOrchestrationOnly(input) : null; - const capability = this.gateway.registerAgent(input); + const { environment, ...agent } = input; + const capability = this.gateway.registerAgent(agent); let providerLaunch; try { providerLaunch = this.providers.prepare(input.provider, capability.connectionId, { ...(input.includeOrchestration ? { orchestration: true } : {}), - ...(input.orchestrationTools ? { orchestrationTools: input.orchestrationTools } : {}) + ...(input.orchestrationTools ? { orchestrationTools: input.orchestrationTools } : {}), + ...(environment ? { environment } : {}) }); } catch (error) { this.gateway.revokeTerminalSession(input.terminalSessionId); @@ -93,7 +97,8 @@ export class AgentBrowserBridge implements AgentBrowserLaunchCoordinator { const providerLaunch = this.providers.prepare(input.provider, connectionId, { orchestration: true, browser: false, - ...(input.orchestrationTools ? { orchestrationTools: input.orchestrationTools } : {}) + ...(input.orchestrationTools ? { orchestrationTools: input.orchestrationTools } : {}), + ...(input.environment ? { environment: input.environment } : {}) }); return this.launchWith(providerLaunch, "", connectionId, () => undefined, {}); } diff --git a/src/main/services/agent-browser/ProviderLaunch.ts b/src/main/services/agent-browser/ProviderLaunch.ts index f59cbe12c..c2815f005 100644 --- a/src/main/services/agent-browser/ProviderLaunch.ts +++ b/src/main/services/agent-browser/ProviderLaunch.ts @@ -150,7 +150,13 @@ export class ProviderLaunchAdapters { * `orchestrationTools`: the canvastty_agents tools this session may use (default: the core tools). `browser: false` * (browser access off) leaves canvastty_browser out, so only canvastty_agents is attached. */ - prepare(provider: AgentProvider, connectionId: string, options?: { orchestration?: boolean; orchestrationTools?: readonly string[]; browser?: boolean }): PreparedProviderLaunch { + prepare(provider: AgentProvider, connectionId: string, options?: { + orchestration?: boolean; + orchestrationTools?: readonly string[]; + browser?: boolean; + /** The card's own (already filtered) environment; the launch reads the person's OpenCode inline config from it. */ + environment?: Readonly>; + }): PreparedProviderLaunch { const providerCli = this.providerClis.get(provider); if (providerCli.state === "unavailable") throw new Error(providerCli.diagnostic); const orchestrationHelper = orchestrationHelperFor(this.options, options); @@ -181,7 +187,7 @@ export class ProviderLaunchAdapters { if (provider === "opencode") { return { args: [], - environment: openCodeBrowserEnvironment(browserHelper, this.environment, orchestrationHelper), + environment: openCodeBrowserEnvironment(browserHelper, options?.environment ?? this.environment, orchestrationHelper), releaseConfiguration() {} }; } diff --git a/src/main/services/agent-runtime/AgentRuntimeBridge.ts b/src/main/services/agent-runtime/AgentRuntimeBridge.ts index f74824685..81b520865 100644 --- a/src/main/services/agent-runtime/AgentRuntimeBridge.ts +++ b/src/main/services/agent-runtime/AgentRuntimeBridge.ts @@ -28,6 +28,8 @@ export interface PrepareAgentRuntimeLaunchInput { decisions?: boolean; /** Claude Code: what decides whether its lifecycle hooks may go over HTTP (see ClaudeHttpHooks.ts). */ claudeHttp?: ClaudeHttpLaunchFacts; + /** The card's own (already filtered) environment, which the launch builds from instead of the app's. */ + environment?: Readonly>; } export interface PreparedAgentRuntimePtyLaunch { @@ -143,7 +145,7 @@ export class AgentRuntimeBridge implements AgentRuntimeLaunchCoordinator { let prepared; try { prepared = this.providers.prepare(input.provider, input.terminalSessionId, this.coreHooksEnabled, decisions, budgetMs, - httpHookBase ?? undefined); + httpHookBase ?? undefined, input.environment); } catch (error) { if (capability) this.gateway.revokeTerminalSession(input.terminalSessionId, capability.capabilityToken); throw error; diff --git a/src/main/services/agent-runtime/ProviderRuntimeLaunch.ts b/src/main/services/agent-runtime/ProviderRuntimeLaunch.ts index 426ab424b..d679b7939 100644 --- a/src/main/services/agent-runtime/ProviderRuntimeLaunch.ts +++ b/src/main/services/agent-runtime/ProviderRuntimeLaunch.ts @@ -182,7 +182,9 @@ export class ProviderRuntimeLaunchAdapters { coreHooksEnabled = true, decisions = false, decisionBudgetMs?: number, - claudeHttpHookBase?: string + claudeHttpHookBase?: string, + /** The card's own (already filtered) environment; the launch reads the person's OpenCode inline config from it. */ + environment: Readonly> = this.environment ): PreparedProviderRuntimeLaunch { const pluginRegistrations = this.options.pluginHooks?.list(provider) ?? []; const gate = decisions && this.decisionsSupported(provider); @@ -195,7 +197,7 @@ export class ProviderRuntimeLaunchAdapters { // MiniMax, Devin and Antigravity must never reach Grok's shared hook overlay. const hasHooks = HOOK_PROVIDERS.has(provider) && (coreHooksEnabled || pluginCommands.length > 0 || (provider === "opencode" && (pluginRegistrations.length > 0 || openCodeDecisions))); - const environment = hasHooks + const hookEnvironment = hasHooks ? { ...(pluginRegistrations.length > 0 ? { [PLUGIN_HOOK_TERMINAL_SESSION_ENV]: terminalSessionId @@ -204,13 +206,13 @@ export class ProviderRuntimeLaunchAdapters { : {}; if (!hasHooks) { this.clearSharedOverlay(provider); - return prepared([], environment); + return prepared([], hookEnvironment); } if (provider === "claude") { - return prepared(claudeHookArgs(this.options.helper, this.platform, coreHooksEnabled, pluginCommands, claudeHttpHookBase), environment); + return prepared(claudeHookArgs(this.options.helper, this.platform, coreHooksEnabled, pluginCommands, claudeHttpHookBase), hookEnvironment); } if (provider === "codex") { - return prepared(codexHookArgs(this.options.helper, this.platform, coreHooksEnabled, pluginCommands), environment); + return prepared(codexHookArgs(this.options.helper, this.platform, coreHooksEnabled, pluginCommands), hookEnvironment); } if (provider === "qwen") { const path = createQwenHookSettings({ @@ -222,7 +224,7 @@ export class ProviderRuntimeLaunchAdapters { coreHooksEnabled, pluginCommands }); - return prepared([], { ...environment, [QWEN_SYSTEM_SETTINGS]: path }, () => unlinkIfExists(path)); + return prepared([], { ...hookEnvironment, [QWEN_SYSTEM_SETTINGS]: path }, () => unlinkIfExists(path)); } if (provider === "opencode") { const pluginEnvironment = this.openCodePluginEnvironment( @@ -230,11 +232,11 @@ export class ProviderRuntimeLaunchAdapters { coreHooksEnabled ); return prepared([], { - ...environment, + ...hookEnvironment, ...pluginEnvironment, ...(openCodeDecisions ? { [OPENCODE_DECISIONS_ENV]: "1", ...budgetEnvironment(decisionBudgetMs) } : {}), [OPENCODE_CONFIG_CONTENT]: openCodeLifecycleConfig( - this.environment[OPENCODE_CONFIG_CONTENT], + environment[OPENCODE_CONFIG_CONTENT], this.options.openCodePluginPath ) }); @@ -242,16 +244,16 @@ export class ProviderRuntimeLaunchAdapters { if (provider === "omp" || provider === "pi") { return prepared(coreHooksEnabled ? ["--extension", join(dirname(this.options.openCodePluginPath), "omp-extension.mjs")] - : [], environment); + : [], hookEnvironment); } if (provider === "kimi") { - return prepared([], environment, this.acquireKimi(coreHooksEnabled, pluginCommands)); + return prepared([], hookEnvironment, this.acquireKimi(coreHooksEnabled, pluginCommands)); } if (provider === "hermes") { - return prepared([], environment, this.acquireHermes(coreHooksEnabled, pluginCommands)); + return prepared([], hookEnvironment, this.acquireHermes(coreHooksEnabled, pluginCommands)); } - if (provider === "grok") return prepared([], environment, this.acquireGrok(coreHooksEnabled, pluginCommands)); - return prepared([], environment); + if (provider === "grok") return prepared([], hookEnvironment, this.acquireGrok(coreHooksEnabled, pluginCommands)); + return prepared([], hookEnvironment); } recoverConfigurations(): void { diff --git a/src/main/services/ambientProviderKeys.ts b/src/main/services/ambientProviderKeys.ts new file mode 100644 index 000000000..41d304417 --- /dev/null +++ b/src/main/services/ambientProviderKeys.ts @@ -0,0 +1,92 @@ +/** + * The person's opt-in: a comma- or space-separated list of variable names that agent cards keep from CanvasTTY's + * own environment although this module would leave them out (e.g. `OPENAI_ADMIN_KEY`). Read from the app's + * environment only, so an agent cannot widen it for itself. + */ +export const AGENT_PASS_ENV = "CANVASTTY_AGENT_PASS_ENV"; + +/** + * Organization-level credentials (OPENAI_ADMIN_KEY, ANTHROPIC_ADMIN_KEY, XAI_ADMIN_API_KEY, GITLAB_ADMIN_TOKEN, …): + * projects, members, usage, billing. No agent CLI signs in with them. + */ +const ADMIN_CREDENTIAL = /(?:^|_)ADMIN_[A-Z0-9_]*(?:KEY|TOKEN)$/u; + +/** + * CanvasTTY's own credentials in its environment (CANVASTTY_GITHUB_TOKEN, which the plugin catalog uses, and any + * CANVASTTY_*TOKEN / *KEY / *SECRET / *PASSWORD): the app's, read by the main process, never needed by a card. + * "KEY" counts only as a whole word part (CANVASTTY_CODEX_KEYBOARD is not one). + */ +const APP_CREDENTIAL = /^CANVASTTY_(?:[A-Z0-9]+_)*[A-Z0-9]*(?:TOKEN|KEY|SECRET|PASSWORD|PASSWD)(?:_|$)/u; + +/** + * What a delegated card inherits from the person's environment: what a process needs to run, find its tools, reach + * the network and find its CLI's own state, and nothing that signs in anywhere. Proxy variables are kept on purpose + * (without them nothing reaches the network behind a corporate proxy), although a proxy URL may carry its own + * user:password. SSH_AUTH_SOCK, GH_TOKEN, AWS_*, cloud and provider credentials are left out; the person lists one in + * AGENT_PASS_ENV, or a launch contribution passes it explicitly (secretEnv). Names only, no prefix: a prefix also + * admits whatever else someone names with it. No CANVASTTY_* variable is inherited: what a card needs of CanvasTTY's + * own (its runtime, browser and orchestration addresses and capabilities, the Codex keyboard) the launch sets itself, + * and the rest (CANVASTTY_HELPERS, CANVASTTY_USER_DATA_DIR, CANVASTTY_GITHUB_TOKEN, …) is read by the main process. + */ +const DELEGATED_NAMES = new Set([ + // Process basics + "PATH", "HOME", "USER", "LOGNAME", "SHELL", "PWD", "SHLVL", "TZ", "LANG", "LANGUAGE", + // Locale categories by name (POSIX and glibc). Not the LC_ prefix: ssh's usual `AcceptEnv LC_*` makes it a common + // way to pass arbitrary values, tokens included, into a session. + "LC_ALL", "LC_CTYPE", "LC_COLLATE", "LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME", "LC_ADDRESS", + "LC_IDENTIFICATION", "LC_MEASUREMENT", "LC_NAME", "LC_PAPER", "LC_TELEPHONE", + "TERM", "COLORTERM", "TERM_PROGRAM", "TERM_PROGRAM_VERSION", "COLORFGBG", "NO_COLOR", "FORCE_COLOR", + "TMPDIR", "TEMP", "TMP", "EDITOR", "VISUAL", "PAGER", "__CF_USER_TEXT_ENCODING", + // XDG base directories by name, and which desktop is running (xdg-open, clipboard and browser tools pick their backend + // by it). Not the XDG_ prefix: XDG_SESSION_COOKIE (ConsoleKit) and XDG_ACTIVATION_TOKEN (Wayland) are secrets. + "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME", "XDG_RUNTIME_DIR", "XDG_CONFIG_DIRS", + "XDG_DATA_DIRS", "XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP", "XDG_SESSION_TYPE", + // Linux desktop session (addresses only) + "DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "DBUS_SESSION_BUS_ADDRESS", + // Windows + "SYSTEMROOT", "SYSTEMDRIVE", "WINDIR", "COMSPEC", "PATHEXT", "APPDATA", "LOCALAPPDATA", "USERPROFILE", "USERNAME", + "HOMEDRIVE", "HOMEPATH", "PROGRAMDATA", "PROGRAMFILES", "PROGRAMFILES(X86)", "PROGRAMW6432", "COMMONPROGRAMFILES", + "COMMONPROGRAMFILES(X86)", "PUBLIC", "ALLUSERSPROFILE", "OS", "PROCESSOR_ARCHITECTURE", "NUMBER_OF_PROCESSORS", + // Network: proxies and the person's own certificate authorities + "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", + "SSL_CERT_FILE", "SSL_CERT_DIR", "NODE_EXTRA_CA_CERTS", "REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE", + // Where each CLI keeps its own state (a moved home is where the CLI's sign-in lives, not a credential) + "CLAUDE_CONFIG_DIR", "CLAUDE_SECURESTORAGE_CONFIG_DIR", "CODEX_HOME", "GROK_HOME", "KIMI_CODE_HOME", "KIMI_SHARE_DIR", + "KIMI_HOME", "QWEN_HOME", "QWEN_RUNTIME_DIR", "HERMES_HOME", "PI_CODING_AGENT_DIR", "PI_CODING_AGENT_SESSION_DIR", + "PI_CONFIG_DIR", "OPENCODE_CONFIG", "OPENCODE_CONFIG_DIR", "MINIMAX_DATA_DIR", "MAVIS_DATA_DIR", "CURSOR_CONFIG_DIR" +]); + +/** A plain shell card the person starts: their whole environment, without CanvasTTY's own credentials. */ +export function shellEnvironment(source: Readonly>): Record { + return Object.fromEntries(Object.entries(source).filter(([key]) => !APP_CREDENTIAL.test(key.toUpperCase()))); +} + +export interface AgentEnvironmentInput { + /** Not started by the person: a subagent, or any card (agent or plain shell) a plugin started. */ + delegated: boolean; +} + +/** + * The environment a card inherits from CanvasTTY's own (terminalEnvironment), before what the core and launch + * contributions set for the launch. A plain shell card the person starts goes through shellEnvironment instead. + * Every launch builder (agent runtime, browser bridge, OpenCode inline config) reads this result, not process.env. + * - The person's own top-level agent cards keep everything but admin and CanvasTTY credentials: a CLI signed in by + * API key keeps working, in any profile. + * - A delegated card gets only DELEGATED_NAMES (an allowlist, so no provider, cloud or git + * credential, whatever its name); what it needs beyond that it gets explicitly, through a launch contribution's + * secretEnv. + * Names in AGENT_PASS_ENV are kept. Names compare case-insensitively (Windows). + */ +export function agentEnvironment( + source: Readonly>, + input: AgentEnvironmentInput +): Record { + const passKey = Object.keys(source).find((key) => key.toUpperCase() === AGENT_PASS_ENV); + const pass = new Set((passKey ? source[passKey] : "").split(/[\s,]+/u).filter(Boolean).map((name) => name.toUpperCase())); + return Object.fromEntries(Object.entries(source).filter(([key]) => { + const name = key.toUpperCase(); + if (pass.has(name)) return true; + if (ADMIN_CREDENTIAL.test(name) || APP_CREDENTIAL.test(name)) return false; + return !input.delegated || DELEGATED_NAMES.has(name); + })); +} diff --git a/tests/agent-ambient-keys.test.mjs b/tests/agent-ambient-keys.test.mjs new file mode 100644 index 000000000..5038fc3fb --- /dev/null +++ b/tests/agent-ambient-keys.test.mjs @@ -0,0 +1,322 @@ +import assert from "node:assert/strict"; +import { mkdtemp, realpath, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import test from "node:test"; +import { AgentControlService } from "../src/main/services/AgentControlService.ts"; +import { AgentBrowserBridge } from "../src/main/services/agent-browser/AgentBrowserBridge.ts"; +import { AgentRuntimeBridge } from "../src/main/services/agent-runtime/AgentRuntimeBridge.ts"; +import { isControlProvider } from "../src/main/services/agent-control/controlCapabilities.ts"; +import { PluginSessions } from "../src/main/services/PluginSessions.ts"; +import { AgentIsolation } from "../src/main/services/isolation/AgentIsolation.ts"; +import { AGENT_PASS_ENV, agentEnvironment, shellEnvironment } from "../src/main/services/ambientProviderKeys.ts"; +import { TerminalManager } from "../src/main/services/TerminalManager.ts"; +import { availableRegistry, fakeSpawner } from "./helpers/terminal.mjs"; + +const at = { x: 0, y: 0 }; +// Fake values only: the test sets them on its own process, never reads the person's environment. +const FAKE = { + OPENAI_API_KEY: "fake-oa", + OPENAI_ADMIN_KEY: "fake-oa-adm", + ANTHROPIC_API_KEY: "fake-an", + ANTHROPIC_ADMIN_KEY: "fake-an-adm", + OPENROUTER_API_KEY: "fake-or", + GEMINI_API_KEY: "fake-gemini", + GITLAB_ADMIN_TOKEN: "fake-gl-adm", + ANTHROPIC_AUTH_TOKEN: "fake-at", + CLAUDE_CODE_OAUTH_TOKEN: "fake-oauth", + AWS_BEARER_TOKEN_BEDROCK: "fake-bedrock", + AWS_ACCESS_KEY_ID: "fake-akid", + AWS_SECRET_ACCESS_KEY: "fake-sak", + AWS_SESSION_TOKEN: "fake-st", + GITHUB_TOKEN: "fake-gh", + GH_TOKEN: "fake-gh2", + SSH_AUTH_SOCK: "/fake/agent", + XAI_API_KEY: "fake-xai", + HF_TOKEN: "fake-hf", + NPM_TOKEN: "fake-npm", + // Not every XDG_ / LC_ variable is a folder or a locale: a ConsoleKit session cookie, a Wayland activation token, + // and a value smuggled through ssh's usual `AcceptEnv LC_*`. + XDG_SESSION_COOKIE: "fake-ck-cookie", + XDG_ACTIVATION_TOKEN: "fake-activation", + LC_FAKE_SMUGGLED_TOKEN: "fake-lc-token", + XDG_DATA_DIRS: "/fake/share", + HTTPS_PROXY: "http://proxy:3128", + no_proxy: "localhost", + NODE_EXTRA_CA_CERTS: "/fake/ca.pem", + LC_ALL: "C.UTF-8", + EDITOR: "vi", + CANVASTTY_GITHUB_TOKEN: "fake-ctgh" +}; +const ADMIN = ["OPENAI_ADMIN_KEY", "ANTHROPIC_ADMIN_KEY", "GITLAB_ADMIN_TOKEN"]; +const ORDINARY = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "OPENROUTER_API_KEY", "GEMINI_API_KEY"]; +/** Credentials that are not provider API keys by name; a delegated card gets none of them (allowlist). */ +const OTHER_CREDENTIALS = ["ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "AWS_BEARER_TOKEN_BEDROCK", "AWS_ACCESS_KEY_ID", + "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "GITHUB_TOKEN", "GH_TOKEN", "SSH_AUTH_SOCK", "XAI_API_KEY", "HF_TOKEN", "NPM_TOKEN", + "XDG_SESSION_COOKIE", "XDG_ACTIVATION_TOKEN", "LC_FAKE_SMUGGLED_TOKEN"]; +/** What a delegated card still needs to run and reach the network. */ +const KEPT = ["PATH", "HTTPS_PROXY", "no_proxy", "NODE_EXTRA_CA_CERTS", "LC_ALL", "EDITOR", "XDG_DATA_DIRS"]; +const SECRETS = [...ADMIN, ...ORDINARY, ...OTHER_CREDENTIALS]; +const SECRET_VALUES = [...SECRETS, "CANVASTTY_GITHUB_TOKEN"].map((name) => FAKE[name]); + +/** Sets fake keys (and optionally the opt-in) on this process for the test, restoring what was there. */ +function withFakeKeys(t, extra = {}) { + const names = [...Object.keys(FAKE), AGENT_PASS_ENV]; + const saved = Object.fromEntries(names.map((name) => [name, process.env[name]])); + t.after(() => { + for (const [name, value] of Object.entries(saved)) { + if (value === undefined) delete process.env[name]; + else process.env[name] = value; + } + }); + delete process.env[AGENT_PASS_ENV]; + Object.assign(process.env, FAKE, extra); +} + +async function project(t) { + const base = await realpath(await mkdtemp(join(tmpdir(), "ctty-keys-"))); + t.after(() => rm(base, { recursive: true, force: true })); + return base; +} + +/** Windows keeps an inherited variable under its own spelling (`Path`), and names there are case-insensitive. */ +function lookup(env, name) { + if (env[name] !== undefined || process.platform !== "win32") return env[name]; + const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name.toUpperCase()); + return key === undefined ? undefined : env[key]; +} + +function present(env, names) { + return names.filter((name) => lookup(env, name) !== undefined); +} + +function manager(t, calls, isolation) { + const terminals = new TerminalManager(() => undefined, availableRegistry(), undefined, undefined, true, fakeSpawner(calls)); + t.after(() => terminals.shutdown()); + if (isolation) terminals.configureIsolation(isolation); + return terminals; +} + +/** A layer that always applies and records the environment it wraps. */ +function recordingLayer(userData, wrapped) { + return { + containment: () => true, + decide: (input) => new AgentIsolation({ userDataPath: userData, enabled: () => true, platform: "darwin", exists: () => true }).decide(input), + wrap: (launch) => { + wrapped.push(launch.env); + return { command: "/usr/bin/sandbox-exec", args: ["-f", "/p.sb", launch.command, ...launch.args], env: { ...launch.env, TMPDIR: "/s/" }, cleanup: () => undefined }; + } + }; +} + +test("(a) a plain shell card the person starts keeps their environment, provider and admin keys included", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + const calls = []; + manager(t, calls).create({ provider: "terminal", profile: "normal", cwd, position: at }); + const env = calls.at(-1).options.env; + assert.deepEqual(present(env, SECRETS), SECRETS); + assert.equal(env.CANVASTTY_GITHUB_TOKEN, undefined, "CanvasTTY's own token is the app's, not the shell's"); +}); + +test("a plain shell card a plugin starts is delegated: its owner drives it, so it gets only the allowlist", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + const calls = []; + const terminals = manager(t, calls); + const sessions = new PluginSessions({ terminals, notify: () => true }); + await sessions.handle("p.shell", "svc", "sessions.create", { provider: "terminal", cwd }, ["sessions:launch"]); + assert.equal(calls.length, 1); + const env = calls.at(-1).options.env; + assert.deepEqual(present(env, SECRETS), [], "no admin key, provider key or other credential"); + assert.deepEqual(present(env, KEPT), KEPT, "what it needs to run and reach the network stays"); + // Directly through the manager too (whatever the caller), keyed on the owning plugin. + terminals.create({ provider: "terminal", profile: "normal", cwd, position: at }, { origin: "plugin", ownerPluginId: "p.shell" }); + assert.deepEqual(present(calls.at(-1).options.env, SECRETS), []); +}); + +test("an orchestrator cannot start a plain shell card, neither through spawn_agent nor its control connection", async (t) => { + const cwd = await project(t); + const calls = []; + const terminals = manager(t, calls); + const control = new AgentControlService(terminals, { containment: () => terminals.containment() }); + const orchestrator = terminals.create({ provider: "codex", profile: "normal", cwd, position: at, role: "orchestrator" }); + const before = calls.length; + assert.throws(() => control.spawn({ parentSessionId: orchestrator.id, provider: "terminal", cwd }), /Unknown agent provider/u); + assert.equal(calls.length, before); + assert.equal(isControlProvider("terminal"), false); +}); + +test("(b) an agent card the person starts keeps ordinary provider keys but never admin keys", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + const calls = []; + const terminals = manager(t, calls); + for (const provider of ["claude", "codex", "opencode", "qwen"]) { + terminals.create({ provider, profile: "normal", cwd, position: at }); + const env = calls.at(-1).options.env; + assert.deepEqual(present(env, ADMIN), [], `${provider}: no admin key`); + assert.equal(env.CANVASTTY_GITHUB_TOKEN, undefined, `${provider}: no CanvasTTY credential`); + assert.deepEqual(present(env, ORDINARY), ORDINARY, `${provider}: its sign-in by API key keeps working`); + assert.deepEqual(present(env, OTHER_CREDENTIALS), OTHER_CREDENTIALS, `${provider}: otherwise unchanged for the person's own card`); + assert.equal(env.OPENAI_API_KEY, FAKE.OPENAI_API_KEY); + } +}); + +test("(c) an agent card under isolation: no admin keys reach the layer or the process; the person's own card keeps ordinary keys", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + const calls = []; + const wrapped = []; + const terminals = manager(t, calls, recordingLayer(join(cwd, "u"), wrapped)); + const card = terminals.create({ provider: "claude", profile: "auto", cwd, position: at }); + assert.deepEqual(card.isolation, { state: "on", layer: "seatbelt" }); + assert.equal(calls.at(-1).command, "/usr/bin/sandbox-exec"); + for (const env of [wrapped.at(-1), calls.at(-1).options.env]) { + assert.deepEqual(present(env, ADMIN), []); + assert.deepEqual(present(env, ORDINARY), ORDINARY); + } +}); + +test("(d) a subagent gets no ambient provider key, admin key or other credential, isolated or not", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + for (const layer of ["isolated", "no layer"]) { + const calls = []; + const wrapped = []; + const isolation = layer === "isolated" + ? recordingLayer(join(cwd, "u"), wrapped) + : new AgentIsolation({ userDataPath: join(cwd, "u"), enabled: () => true, platform: "win32" }); + const terminals = manager(t, calls, isolation); + const control = new AgentControlService(terminals, { containment: () => terminals.containment() }); + const orchestrator = terminals.create({ provider: "codex", profile: "auto", cwd, position: at, role: "orchestrator" }); + assert.deepEqual(present(calls.at(-1).options.env, ORDINARY), ORDINARY, `${layer}: the person's orchestrator keeps them`); + const child = await control.spawn({ parentSessionId: orchestrator.id, provider: "claude", cwd }); + assert.equal(child.role, "subagent"); + const env = calls.at(-1).options.env; + assert.deepEqual(present(env, SECRETS), [], `${layer}: the subagent`); + if (layer === "isolated") assert.deepEqual(present(wrapped.at(-1), SECRETS), []); + assert.deepEqual(present(env, KEPT), KEPT, "what it needs to run and reach the network stays"); + } +}); + +test("the person's explicit opt-in passes named keys to every agent card, subagents included", async (t) => { + withFakeKeys(t, { [AGENT_PASS_ENV]: "OPENAI_ADMIN_KEY, ANTHROPIC_API_KEY" }); + const cwd = await project(t); + const calls = []; + const terminals = manager(t, calls, new AgentIsolation({ userDataPath: join(cwd, "u"), enabled: () => true, platform: "win32" })); + const control = new AgentControlService(terminals, { containment: () => terminals.containment() }); + const top = terminals.create({ provider: "codex", profile: "normal", cwd, position: at, role: "orchestrator" }); + assert.deepEqual(present(calls.at(-1).options.env, ADMIN), ["OPENAI_ADMIN_KEY"]); + await control.spawn({ parentSessionId: top.id, provider: "claude", cwd }); + assert.deepEqual(present(calls.at(-1).options.env, SECRETS), ["OPENAI_ADMIN_KEY", "ANTHROPIC_API_KEY"]); +}); + +test("agentEnvironment: names compare case-insensitively (Windows); admin credentials of any provider; delegated is an allowlist", () => { + const base = { Path: "C:\\bin", openai_api_key: "x", Openai_Admin_Key: "y", GITHUB_TOKEN: "g", AZURE_OPENAI_API_KEY: "z", + XAI_ADMIN_API_KEY: "w", ADMIN_TOKEN: "a", SOME_ADMIN_ACCESS_TOKEN: "b", HOME: "/h", SystemRoot: "C:\\Windows", + https_proxy: "http://p", Lc_Ctype: "UTF-8", XDG_CONFIG_HOME: "/h/.config", CODEX_HOME: "/h/.codex", MY_SERVICE_PASSWORD: "p", + XDG_SESSION_COOKIE: "c", xdg_activation_token: "a", LC_MY_TOKEN: "l", XDG_RUNTIME_DIR: "/run/u", XDG_CURRENT_DESKTOP: "GNOME" }; + assert.deepEqual(agentEnvironment(base, { delegated: false }), { Path: "C:\\bin", openai_api_key: "x", GITHUB_TOKEN: "g", + AZURE_OPENAI_API_KEY: "z", HOME: "/h", SystemRoot: "C:\\Windows", https_proxy: "http://p", Lc_Ctype: "UTF-8", + XDG_CONFIG_HOME: "/h/.config", CODEX_HOME: "/h/.codex", MY_SERVICE_PASSWORD: "p", XDG_SESSION_COOKIE: "c", + xdg_activation_token: "a", LC_MY_TOKEN: "l", XDG_RUNTIME_DIR: "/run/u", XDG_CURRENT_DESKTOP: "GNOME" }); + const delegated = { Path: "C:\\bin", HOME: "/h", SystemRoot: "C:\\Windows", https_proxy: "http://p", Lc_Ctype: "UTF-8", + XDG_CONFIG_HOME: "/h/.config", CODEX_HOME: "/h/.codex", XDG_RUNTIME_DIR: "/run/u", XDG_CURRENT_DESKTOP: "GNOME" }; + // XDG and locale variables by name: folders and locale categories, never a session cookie or token that shares the prefix. + assert.deepEqual(agentEnvironment(base, { delegated: true }), delegated); + assert.deepEqual(agentEnvironment({ ...base, [AGENT_PASS_ENV]: "XDG_SESSION_COOKIE" }, { delegated: true }), + { ...delegated, XDG_SESSION_COOKIE: "c" }, "the person can still opt in"); + assert.deepEqual(agentEnvironment({ ...base, [AGENT_PASS_ENV]: "openai_admin_key GITHUB_TOKEN" }, { delegated: true }), + { ...delegated, Openai_Admin_Key: "y", GITHUB_TOKEN: "g" }); + // CanvasTTY's own credentials reach no agent card, the person's own included; its other variables are not inherited + // by a delegated card (the launch sets what a card needs). + const app = { CANVASTTY_GITHUB_TOKEN: "t", CANVASTTY_API_KEY: "k", CANVASTTY_CODEX_KEYBOARD: "{}", CANVASTTY_HELPERS: "node" }; + assert.deepEqual(agentEnvironment(app, { delegated: false }), { CANVASTTY_CODEX_KEYBOARD: "{}", CANVASTTY_HELPERS: "node" }); + assert.deepEqual(agentEnvironment(app, { delegated: true }), {}); + assert.deepEqual(shellEnvironment({ ...app, GITHUB_TOKEN: "g" }), { CANVASTTY_CODEX_KEYBOARD: "{}", CANVASTTY_HELPERS: "node", GITHUB_TOKEN: "g" }); +}); + +/** The real launch builders (agent runtime hooks, browser/orchestration MCP bridge), both built over process.env. */ +function builders(root) { + const helper = { command: "/app/CanvasTTY", args: ["/app/helper.mjs"], env: { ELECTRON_RUN_AS_NODE: "1" } }; + const browserGateway = { + isEnabled: true, + setEnabled() {}, + registerAgent: (input) => ({ agentId: "a", connectionId: "c", terminalSessionId: input.terminalSessionId, provider: input.provider, + capabilityToken: "b".repeat(40), address: "/tmp/b.sock" }), + revokeTerminalSession() {}, + holdPendingForTerminal() {} + }; + const runtimeGateway = { + registerSession: (id, provider) => ({ address: "/tmp/r.sock", terminalSessionId: id, provider, capabilityToken: "r".repeat(40) }), + revokeTerminalSession() {}, + currentStatus: () => null + }; + const browser = new AgentBrowserBridge(browserGateway, { helper, orchestrationHelper: helper, providerClis: availableRegistry(), + runtimeDirectory: join(root, "rt-b"), hermesHomeDirectory: join(root, "hermes"), kimiHomeDirectory: join(root, "kimi"), + probeKimiPerRunConfig: () => true }); + const runtime = new AgentRuntimeBridge(runtimeGateway, { helper, runtimeDirectory: join(root, "rt-r"), + openCodePluginPath: "/app/opencode-plugin.mjs", kimiHomeDirectory: join(root, "kimi"), hermesHomeDirectory: join(root, "hermes"), + grokHomeDirectory: join(root, "grok"), coreHooksEnabled: true }); + return { browser, runtime }; +} + +test("no launch builder re-injects what the filter removed: the env handed to the PTY of a delegated card holds no ambient credential", async (t) => { + // The person's OpenCode inline config carries a provider key; the builders read it from the app's environment. + withFakeKeys(t, { OPENCODE_CONFIG_CONTENT: JSON.stringify({ provider: { x: { options: { apiKey: "fake-oc" } } } }) }); + t.after(() => { delete process.env.OPENCODE_CONFIG_CONTENT; }); + const cwd = await project(t); + const calls = []; + const { browser, runtime } = builders(cwd); + const terminals = new TerminalManager(() => undefined, availableRegistry(), browser, runtime, true, fakeSpawner(calls)); + t.after(() => terminals.shutdown()); + const control = new AgentControlService(terminals, { containment: () => terminals.containment() }); + const orchestrator = terminals.create({ provider: "opencode", profile: "normal", cwd, position: at, role: "orchestrator" }); + const own = calls.at(-1).options.env; + assert.match(own.OPENCODE_CONFIG_CONTENT, /fake-oc/u, "the person's own card keeps their OpenCode config"); + assert.match(own.OPENCODE_CONFIG_CONTENT, /opencode-plugin\.mjs/u); + assert.equal(own.CANVASTTY_GITHUB_TOKEN, undefined); + assert.deepEqual(present(own, ADMIN), []); + for (const provider of ["opencode", "claude", "codex", "qwen"]) { + await control.spawn({ parentSessionId: orchestrator.id, provider, cwd }); + const env = calls.at(-1).options.env; + const text = JSON.stringify(env); + for (const value of [...SECRET_VALUES, "fake-oc"]) assert.ok(!text.includes(value), `${provider} subagent: ${value} is not in its env`); + assert.deepEqual(present(env, [...SECRETS, "CANVASTTY_GITHUB_TOKEN"]), [], provider); + if (provider === "opencode") { + const config = JSON.parse(env.OPENCODE_CONFIG_CONTENT); + assert.ok(config.plugin.some((entry) => entry.endsWith("/opencode-plugin.mjs")), "its lifecycle plugin is still there"); + assert.ok(config.mcp.canvastty_browser, "its browser server is still there"); + assert.equal(config.provider, undefined, "the person's inline config is not handed to a delegated agent"); + } + } + // A plugin-started plain shell, through the same manager. + const sessions = new PluginSessions({ terminals, notify: () => true }); + await sessions.handle("p.shell", "svc", "sessions.create", { provider: "terminal", cwd }, ["sessions:launch"]); + const shell = JSON.stringify(calls.at(-1).options.env); + for (const value of [...SECRET_VALUES, "fake-oc"]) assert.ok(!shell.includes(value), `plugin shell: ${value}`); +}); + +test("a plain shell card's Codex observer is built from the card's filtered environment, not the app's", async (t) => { + withFakeKeys(t); + const cwd = await project(t); + const calls = []; + const { browser, runtime } = builders(cwd); + const seen = []; + runtime.prepareShellLaunch = (input) => { + seen.push(input.environment); + return { args: [], environment: {}, cleanup() {} }; + }; + const terminals = new TerminalManager(() => undefined, availableRegistry(), browser, runtime, true, fakeSpawner(calls)); + t.after(() => terminals.shutdown()); + terminals.create({ provider: "terminal", profile: "normal", cwd, position: at }); + assert.equal(seen.length, 1, "the person's shell card gets the observer"); + assert.equal(seen[0].CANVASTTY_GITHUB_TOKEN, undefined, "the person's shell: no CanvasTTY credential"); + assert.deepEqual(present(seen[0], SECRETS), SECRETS, "the person's shell keeps the rest"); + const sessions = new PluginSessions({ terminals, notify: () => true }); + await sessions.handle("p.shell", "svc", "sessions.create", { provider: "terminal", cwd }, ["sessions:launch"]); + assert.equal(seen.length, 2); + assert.deepEqual(present(seen[1], [...SECRETS, "CANVASTTY_GITHUB_TOKEN"]), [], "a plugin-started shell: only the allowlist"); + assert.deepEqual(present(seen[1], KEPT), KEPT); +}); diff --git a/tests/launch-contributors.test.mjs b/tests/launch-contributors.test.mjs index 8a53e7ee8..8e47ab77f 100644 --- a/tests/launch-contributors.test.mjs +++ b/tests/launch-contributors.test.mjs @@ -430,3 +430,22 @@ test("end to end: the example service prepares a launch over JSON-RPC", async (t const empty = await pipeline.prepare(context({ greeting: "" })); assert.match(empty.reason, /Launch Env: Value is empty/u); }); + +test("a plugin-started agent drops ambient provider keys, yet the key its launch contribution names explicitly arrives", async (t) => { + // Fake values only, set on this test process. + const saved = { OPENAI_API_KEY: process.env.OPENAI_API_KEY, OPENAI_ADMIN_KEY: process.env.OPENAI_ADMIN_KEY, ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY }; + t.after(() => { for (const [key, value] of Object.entries(saved)) { if (value === undefined) delete process.env[key]; else process.env[key] = value; } }); + Object.assign(process.env, { OPENAI_API_KEY: "fake-oa", OPENAI_ADMIN_KEY: "fake-oa-adm", ANTHROPIC_API_KEY: "fake-an" }); + const { pipeline } = await pipelineFixture(t, { + contributors: [contributor("p.keys", { secrets: true })], + answers: { "p.keys": { secretEnv: { OPENAI_API_KEY: "api-key" } } }, + secrets: { "p.keys/api-key": SECRET } + }); + const { manager, calls } = await managerFixture(t, pipeline); + manager.create({ provider: "codex", profile: "normal", cwd, position: at, launchOptions: { "p.keys": {} } }, { ownerPluginId: "p.keys" }); + await waitFor(() => calls.length === 1); + const env = calls[0].options.env; + assert.equal(env.OPENAI_API_KEY, SECRET, "the contribution's own key"); + assert.equal(env.ANTHROPIC_API_KEY, undefined, "no ambient provider key for a delegated agent"); + assert.equal(env.OPENAI_ADMIN_KEY, undefined, "never an admin key"); +});