@steerable/agent-shell 0.6.52 → 0.6.55

package/dist/runtime.js

@@ -1,56 +1,24 @@
 /**
- * 宿主运行时抽象：Electron 主进程与 BS 独立 Node server 共用的环境探测。
+ * 宿主运行时抽象：Tauri 监督的 Node 宿主与 BS 独立 Node server 共用的环境探测。
  *
- * CS 模式（Electron）下路径来自 `app.getPath('userData')`（按 productName
- * 分目录）；BS 模式（`node dist/server/index.js`）没有 Electron，落到
- * `DEEPPATH_USER_DATA_DIR` 或产品注入的 `~/<dataDirName>`（3.1）。两种模式共用
- * 同一份 SQLite / JSON 存储代码，差异只在这一层。
+ * 数据目录优先取 `DEEPPATH_USER_DATA_DIR`（Tauri 宿主总是注入），否则落到
+ * 产品注入的 `~/<dataDirName>`（3.1）。两种模式共用同一份 SQLite / JSON
+ * 存储代码，差异只在这一层。
  *
  * 本模块只允许依赖 node 内置模块（与 brand.ts 同约束）：storage 会被
- * vitest 直接 import，不能碰 electron 包。
+ * vitest 直接 import。
  */
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
-import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getProductConfig } from './product-config.js';
-/** Electron 主进程里 `process.versions.electron` 有值；普通 Node（BS server、vitest）没有。 */
-export function isElectronRuntime() {
-    return Boolean(process.versions.electron);
-}
-let cachedApp;
-/**
- * 同步拿 Electron app。普通 Node 下 `require('electron')` 返回二进制路径
- * 字符串（没有 app），必须拒绝；Electron 主进程里才是真正的 API 对象。
- */
-function tryElectronApp() {
-    if (cachedApp !== undefined)
-        return cachedApp;
-    if (!isElectronRuntime()) {
-        cachedApp = null;
-        return null;
-    }
-    try {
-        const require = createRequire(import.meta.url);
-        const mod = require('electron');
-        cachedApp = mod && typeof mod.app?.getPath === 'function' ? mod.app : null;
-    }
-    catch {
-        cachedApp = null;
-    }
-    return cachedApp;
-}
 /** 应用数据目录（SQLite、JSON store、用户技能目录的根）。 */
 export function getUserDataDir() {
     if (process.env.DEEPPATH_USER_DATA_DIR)
         return process.env.DEEPPATH_USER_DATA_DIR;
-    const app = tryElectronApp();
-    if (app)
-        return app.getPath('userData');
-    // BS：目录名是产品注入配置（3.1，product.json dataDirName），与 Electron
-    // 下 productName 分目录的共存语义对齐；中性 shell 缺省 .agent-shell。
+    // 目录名是产品注入配置（3.1，product.json dataDirName）；中性 shell 缺省 .agent-shell。
     const dirName = getProductConfig().dataDirName ?? '.agent-shell';
     return path.join(os.homedir(), dirName);
 }
@@ -62,15 +30,6 @@ export function getUserDataDir() {
 export function getDocumentsDir() {
     if (process.env.STEERABLE_DOCUMENTS_DIR)
         return process.env.STEERABLE_DOCUMENTS_DIR;
-    const app = tryElectronApp();
-    if (app) {
-        try {
-            return app.getPath('documents');
-        }
-        catch {
-            // 个别环境 getPath('documents') 不可用，回落到 ~/Documents。
-        }
-    }
     return path.join(os.homedir(), 'Documents');
 }
 /**
@@ -91,9 +50,6 @@ export function setAppRootDir(dir) {
     appRootOverride = dir;
 }
 export function getAppRootDir() {
-    const app = tryElectronApp();
-    if (app)
-        return app.getAppPath();
     if (appRootOverride)
         return appRootOverride;
     // 单测/脚本平面：从 cwd 向上找含 package.json 的目录。
@@ -107,37 +63,12 @@ export function getAppRootDir() {
     }
 }
 /**
- * preload  bundle 路径（3.4 修复）：shell main.ts 创建窗口时需要
- * preload.cjs——shell 自带默认面（dist/preload.cjs，buildPreloadApi()
- * 无包贡献），但带 invoke 型包贡献的产品由产品构建把组合后的
- * preload.cjs 出在产品 main.js 旁，产品入口在动态 import
- * shell main 之前经本函数注入。未注入时回退 shell 自带默认。
- */
-let preloadPathOverride = null;
-/**
- * 注入 preload bundle 绝对路径（产品组装根/入口调用）。重复注入不同值
- * 抛错（组装期笔误，fail fast——与 setAppRootDir 同语义）。
- */
-export function setPreloadPath(file) {
-    if (preloadPathOverride && preloadPathOverride !== file) {
-        throw new Error('[runtime] preload path already set');
-    }
-    preloadPathOverride = file;
-}
-/**
- * 解析窗口应加载的 preload bundle：产品注入优先，其次 shell 自带默认
- * （shellDir 一般为 shell main.js 所在目录）。
- */
-export function getPreloadPath(shellDir) {
-    return preloadPathOverride ?? path.join(shellDir, 'preload.cjs');
-}
-/**
- * 产品 web 产物目录（2.3）：产品入口（products/<id>/{main,server}.ts）
- * 用本函数把 DEEPPATH_WEB_DIST 注入环境，shell 的 main/server 据此定位
- * web dist。双平面探测：源码平面入口在 products/<id>/（web dist 在同级
- * web/dist）；编译平面入口在 products/<id>/dist/products/<id>/（web dist
- * 在仓库根的 products/<id>/web/dist）。两处都没有返回 null（打包后的
- * CS 走 app.getAppPath()/web-dist 约定，不经本函数）。
+ * 产品 web 产物目录（2.3）：产品入口（products/<id>/server.ts）用本函数
+ * 把 DEEPPATH_WEB_DIST 注入环境，shell server 据此定位 web dist。双平面
+ * 探测：源码平面入口在 products/<id>/（web dist 在同级 web/dist）；编译
+ * 平面入口在 products/<id>/dist/products/<id>/（web dist 在仓库根的
+ * products/<id>/web/dist）。两处都没有返回 null（打包后的 Tauri 宿主直接
+ * 注入 DEEPPATH_WEB_DIST，不经本函数）。
  */
 export function resolveProductWebDist(entryUrl) {
     const here = path.dirname(fileURLToPath(entryUrl));
@@ -155,22 +86,13 @@ export function resolveProductWebDist(entryUrl) {
     }
     return null;
 }
-/** 用系统默认应用打开本地路径（Electron `shell.openPath` 的跨宿主等价物）。 */
+/** 用系统默认应用打开本地路径。返回空串表示成功，否则是错误消息。 */
 export async function shellOpenPath(target) {
-    if (tryElectronApp()) {
-        const { shell } = (await import('electron'));
-        return shell.openPath(target);
-    }
     const [cmd, args] = openCommand(target, false);
     return spawnDetached(cmd, args);
 }
-/** 用系统浏览器打开 URL（Electron `shell.openExternal` 的跨宿主等价物）。 */
+/** 用系统浏览器打开 URL。 */
 export async function shellOpenExternal(url) {
-    if (tryElectronApp()) {
-        const { shell } = (await import('electron'));
-        await shell.openExternal(url);
-        return;
-    }
     const [cmd, args] = openCommand(url, true);
     const error = await spawnDetached(cmd, args);
     if (error)
@@ -186,7 +108,7 @@ function openCommand(target, isUrl) {
     }
     return ['xdg-open', [target]];
 }
-/** 返回空串表示成功（对齐 shell.openPath 的约定），否则是错误消息。 */
+/** 返回空串表示成功，否则是错误消息。 */
 function spawnDetached(cmd, args) {
     return new Promise((resolve) => {
         try {
@@ -202,39 +124,3 @@ function spawnDetached(cmd, args) {
         }
     });
 }
-/**
- * 注册应用退出钩子（sidecar 的兜底清理）。BS 下没有 app 生命周期——
- * 宿主退出由 server 的 SIGINT/SIGTERM 钩子统一负责，这里 no-op。
- */
-export function onAppWillQuit(listener) {
-    try {
-        tryElectronApp()?.on?.('will-quit', listener);
-    }
-    catch {
-        /* 非 Electron 宿主 */
-    }
-}
-export function offAppWillQuit(listener) {
-    try {
-        tryElectronApp()?.removeListener?.('will-quit', listener);
-    }
-    catch {
-        /* 非 Electron 宿主 */
-    }
-}
-/**
- * Electron `nativeImage`（图片解码/缩放）。BS / 单测等无 Electron 环境返回
- * null——调用方按"不支持图片解码"降级（image-attachment 已有该分支）。
- */
-export function getNativeImage() {
-    if (!isElectronRuntime())
-        return null;
-    try {
-        const require = createRequire(import.meta.url);
-        const mod = require('electron');
-        return typeof mod.nativeImage?.createFromPath === 'function' ? mod.nativeImage : null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/scenario/pack.d.ts

@@ -5,4 +5,4 @@
  *
  * 契约全文与设计约束见 packages/pack-sdk/types/index.d.ts 头注释。
  */
-export type { ScenarioId, ToolMode, ToolExposure, PackToolContext, PackToolHandler, ToolContribution, ServiceFactory, ServiceCreateContext, MigrationContribution, SkillContribution, AgentSeedIdentity, AgentSeed, IpcContribution, HttpRouteContribution, HttpRouteRequest, MainContribution, PreloadContribution, ComponentRef, SettingsPanelContribution, RouteContribution, ChatSlotContribution, CardRendererContribution, RendererContribution, BrandSpec, PackagingSpec, ScenarioPack, PackBackendRouteResponse, PackBackendRouteRequest, PackBackendRoute, PackTurnObserver, PackTurnHooks, } from '@steerable/pack-sdk';
+export type { ScenarioId, ToolMode, ToolExposure, PackToolContext, PackToolHandler, ToolContribution, ServiceFactory, ServiceCreateContext, MigrationContribution, SkillContribution, AgentSeedIdentity, AgentSeed, HttpRouteContribution, HttpRouteRequest, MainContribution, ComponentRef, SettingsPanelContribution, RouteContribution, ChatSlotContribution, CardRendererContribution, RendererContribution, BrandSpec, PackagingSpec, ScenarioPack, PackBackendRouteResponse, PackBackendRouteRequest, PackBackendRoute, PackTurnObserver, PackTurnHooks, } from '@steerable/pack-sdk';

package/dist/scenario/registry.d.ts

@@ -2,11 +2,10 @@
  * 场景包注册表：宿主装配期的单一入口。
  *
  * 产品的 composition root 在启动早期把选中的包 register 进来；宿主各
- * 子系统（ToolRouter / storage / copy-skills / IPC / 渲染层槽位）从这里
+ * 子系统（ToolRouter / storage / copy-skills / 渲染层槽位）从这里
  * 按槽位读取贡献，而不是各自硬编码 import 场景代码。
  *
- * 注册期即校验（fail loud）：重复 id、IPC 通道不带 '<packId>:' 前缀、
- * preload 命名空间与包 id 不一致，都在 register 时抛错，而不是等到
+ * 注册期即校验（fail loud）：重复 id 在 register 时抛错，而不是等到
  * 运行时才暴露。
  */
 import type { ScenarioId, ScenarioPack } from './pack.js';
@@ -18,7 +17,7 @@ export declare class ScenarioRegistry {
     list(): readonly ScenarioPack[];
 }
 /**
- * 进程级默认注册表。composition root（main.ts / server/index.ts /
- * 渲染层入口）在最早阶段填充；各子系统消费同一个实例。
+ * 进程级默认注册表。composition root（server/index.ts / 渲染层入口）
+ * 在最早阶段填充；各子系统消费同一个实例。
  */
 export declare const scenarioRegistry: ScenarioRegistry;

package/dist/scenario/registry.js

@@ -4,14 +4,6 @@ export class ScenarioRegistry {
         if (this.packs.has(pack.id)) {
             throw new Error(`[scenario] duplicate pack id: ${pack.id}`);
         }
-        for (const ipc of pack.main?.ipc ?? []) {
-            if (!ipc.channel.startsWith(`${pack.id}:`)) {
-                throw new Error(`[scenario] pack ${pack.id} ipc channel "${ipc.channel}" must start with "${pack.id}:"`);
-            }
-        }
-        if (pack.preload && pack.preload.namespace !== pack.id) {
-            throw new Error(`[scenario] pack ${pack.id} preload namespace "${pack.preload.namespace}" must equal pack id`);
-        }
         this.packs.set(pack.id, pack);
     }
     get(id) {
@@ -25,7 +17,7 @@ export class ScenarioRegistry {
     }
 }
 /**
- * 进程级默认注册表。composition root（main.ts / server/index.ts /
- * 渲染层入口）在最早阶段填充；各子系统消费同一个实例。
+ * 进程级默认注册表。composition root（server/index.ts / 渲染层入口）
+ * 在最早阶段填充；各子系统消费同一个实例。
  */
 export const scenarioRegistry = new ScenarioRegistry();

package/dist/server/start.js

@@ -13,8 +13,7 @@ import { getUserDataDir } from '../runtime.js';
 import { createBsServer, } from './http-server.js';
 import { SseBus } from './sse-bus.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Match the Electron entry's dotenv precedence: local file first, existing
-// process variables always win.
+// dotenv precedence: local file first, existing process variables always win.
 for (const file of ['.env.local', '.env']) {
     const fullPath = path.join(path.resolve(__dirname, '..', '..'), file);
     if (existsSync(fullPath))

package/dist/shell-exec.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shell 执行规划：前缀策略，以及本地 / SSH 的启动参数。
+ * 这里不启动进程。多条前缀同时命中时，取更严的决定：
+ * allow < prompt < forbidden。
+ */
+export type ExecDecisionName = 'allow' | 'prompt' | 'forbidden';
+export interface PrefixRule {
+    argv: string[];
+    decision: ExecDecisionName;
+    justification?: string;
+}
+export interface ExecPolicy {
+    rules: PrefixRule[];
+}
+export interface ExecEvaluation {
+    decision: ExecDecisionName;
+    command: string[];
+    rule?: PrefixRule;
+}
+export interface SshEndpoint {
+    kind: 'ssh';
+    destination: string;
+    remoteCwd?: string;
+}
+export type ShellEndpoint = {
+    kind: 'local';
+} | SshEndpoint;
+export interface ShellRunSpec {
+    file: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    pty: boolean;
+    transport: 'local' | 'ssh';
+}
+export interface ShellRunLimits {
+    timeoutMs: number;
+    maxOutputBytes: number;
+    gui: boolean;
+}
+export interface ShellRunOutcome {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    truncated?: boolean;
+    timedOut?: boolean;
+    stillRunning?: boolean;
+    error?: string;
+}
+export interface ShellProcessBackend {
+    run(spec: ShellRunSpec, limits: ShellRunLimits): Promise<ShellRunOutcome>;
+}
+export declare function splitShellScript(script: string): string[][];
+export declare function evaluateExecPolicy(script: string, policy: ExecPolicy): ExecEvaluation;
+export declare function planSshArgv(input: {
+    command: string;
+    cwd?: string;
+    pty: boolean;
+    shell?: 'powershell';
+    endpoint: SshEndpoint;
+}): ShellRunSpec;
+export declare function shellQuote(value: string): string;

package/dist/shell-exec.js

@@ -0,0 +1,147 @@
+/**
+ * Shell 执行规划：前缀策略，以及本地 / SSH 的启动参数。
+ * 这里不启动进程。多条前缀同时命中时，取更严的决定：
+ * allow < prompt < forbidden。
+ */
+const DECISION_RANK = {
+    allow: 0,
+    prompt: 1,
+    forbidden: 2,
+};
+export function splitShellScript(script) {
+    return splitSegments(script).map(tokenize).filter((argv) => argv.length > 0);
+}
+export function evaluateExecPolicy(script, policy) {
+    const commands = splitShellScript(script);
+    let best = { decision: 'allow', command: commands[0] ?? [] };
+    for (const command of commands) {
+        for (const rule of policy.rules) {
+            if (rule.argv.length === 0 || !isPrefix(rule.argv, command))
+                continue;
+            const stricter = DECISION_RANK[rule.decision] > DECISION_RANK[best.decision];
+            const sameDecisionLonger = rule.decision === best.decision && rule.argv.length > (best.rule?.argv.length ?? 0);
+            if (stricter || sameDecisionLonger) {
+                best = { decision: rule.decision, command, rule };
+            }
+        }
+    }
+    return best;
+}
+export function planSshArgv(input) {
+    const destination = input.endpoint.destination.trim();
+    if (!destination) {
+        throw new Error('ssh destination is required');
+    }
+    const cwd = input.cwd ?? input.endpoint.remoteCwd;
+    const script = remoteScript(input.command, cwd, input.shell);
+    const args = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=15'];
+    if (input.pty)
+        args.push('-tt');
+    args.push(destination, '--');
+    if (input.shell === 'powershell') {
+        args.push('pwsh', '-NoProfile', '-NonInteractive', '-Command', script);
+    }
+    else {
+        args.push('bash', '-lc', script);
+    }
+    return { file: 'ssh', args, pty: input.pty, transport: 'ssh' };
+}
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function remoteScript(command, cwd, shell) {
+    if (!cwd)
+        return command;
+    if (shell === 'powershell')
+        return `Set-Location ${shellQuote(cwd)}; ${command}`;
+    return `cd ${shellQuote(cwd)} && ${command}`;
+}
+function isPrefix(prefix, argv) {
+    if (prefix.length > argv.length)
+        return false;
+    return prefix.every((token, index) => token === argv[index]);
+}
+function splitSegments(script) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < script.length; i += 1) {
+        const ch = script[i];
+        if (quote) {
+            current += ch;
+            if (ch === '\\' && quote === '"' && i + 1 < script.length) {
+                current += script[i + 1];
+                i += 1;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '\\' && i + 1 < script.length) {
+            current += ch + script[i + 1];
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        const two = script.slice(i, i + 2);
+        if (two === '&&' || two === '||' || two === '|&') {
+            segments.push(current);
+            current = '';
+            i += 1;
+            continue;
+        }
+        if (ch === ';' || ch === '|' || ch === '\n') {
+            segments.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    segments.push(current);
+    return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function tokenize(segment) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (quote) {
+            if (ch === '\\' && quote === '"' && i + 1 < segment.length) {
+                current += segment[i + 1];
+                i += 1;
+                continue;
+            }
+            if (ch === quote) {
+                quote = null;
+                continue;
+            }
+            current += ch;
+            continue;
+        }
+        if (ch === '\\' && i + 1 < segment.length) {
+            current += segment[i + 1];
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t') {
+            if (current)
+                tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}

package/dist/shell-process.d.ts

@@ -0,0 +1,3 @@
+import type { ShellProcessBackend } from './shell-exec.js';
+export declare function stripAnsi(input: string): string;
+export declare const nodeShellBackend: ShellProcessBackend;

package/dist/shell-process.js

@@ -0,0 +1,137 @@
+/**
+ * 本地进程启动：管道用 child_process，PTY 用 node-pty。
+ * SSH 也走这里，argv 由 shell-exec 规划好，本文件不再解释命令文本。
+ */
+import { spawn } from 'child_process';
+import * as pty from 'node-pty';
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
+export function stripAnsi(input) {
+    return input.replace(ANSI_RE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+export const nodeShellBackend = {
+    run(spec, limits) {
+        return spec.pty ? runPty(spec, limits) : runPipe(spec, limits);
+    },
+};
+function runPipe(spec, limits) {
+    return new Promise((resolve) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let truncated = false;
+        let settled = false;
+        const child = spawn(spec.file, spec.args, {
+            cwd: spec.cwd,
+            env: spec.env,
+            windowsHide: true,
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        const take = (chunks, bytes, chunk) => {
+            if (bytes >= limits.maxOutputBytes) {
+                truncated = true;
+                return bytes;
+            }
+            const remain = limits.maxOutputBytes - bytes;
+            const safe = chunk.length > remain ? chunk.subarray(0, remain) : chunk;
+            chunks.push(safe);
+            if (safe.length < chunk.length)
+                truncated = true;
+            return bytes + safe.length;
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdoutBytes = take(stdoutChunks, stdoutBytes, chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderrBytes = take(stderrChunks, stderrBytes, chunk);
+        });
+        const stdout = () => Buffer.concat(stdoutChunks).toString('utf-8');
+        const stderr = () => Buffer.concat(stderrChunks).toString('utf-8');
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                child.kill();
+            finish({
+                exitCode: -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        child.on('error', (err) => {
+            finish({ exitCode: -1, stdout: stdout(), stderr: stderr(), truncated, error: err.message });
+        });
+        child.on('close', (exitCode) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+            });
+        });
+    });
+}
+function runPty(spec, limits) {
+    return new Promise((resolve) => {
+        let output = '';
+        let truncated = false;
+        let settled = false;
+        const proc = pty.spawn(spec.file, spec.args, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 30,
+            cwd: spec.cwd,
+            env: { ...spec.env, TERM: 'xterm-256color' },
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        proc.onData((chunk) => {
+            const next = output + chunk;
+            if (Buffer.byteLength(next) > limits.maxOutputBytes) {
+                truncated = true;
+                output = trimToBytes(next, limits.maxOutputBytes);
+                return;
+            }
+            output = next;
+        });
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                proc.kill();
+            finish({
+                exitCode: -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        proc.onExit(({ exitCode }) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+            });
+        });
+    });
+}
+function trimToBytes(value, maxBytes) {
+    const buffer = Buffer.from(value);
+    return buffer.subarray(0, maxBytes).toString('utf-8');
+}

package/dist/sidecar/boot.js

@@ -20,6 +20,7 @@ import { buildEgressProxyPlan, decideEgressProxy, ensureEgressProxyExecutable, d
 import { WEB_TOOL_RPC_TIMEOUT_MS, webToolsEnabled } from '../tool-router.js';
 import { sidecarWebSearchEnv } from '../storage/web-search-settings.js';
 import { executeHostedWebSearch } from '../hosted-web-search.js';
+import { getProductConfig } from '../product-config.js';
 let egressProxyRef = null;
 let supervisorRef = null;
 let sidecarGeneration = 0;
@@ -121,6 +122,9 @@ async function startEgressProxyIfEnabled(store) {
             ? {
                 STEERABLE_EGRESS_CONTROL_PORT: String(egressProxyRef.controlPort),
                 [plan.control.tokenEnv]: plan.control.tokenValue,
+                ...(getProductConfig().egressApproval === 'off'
+                    ? { STEERABLE_EGRESS_APPROVAL: 'off' }
+                    : {}),
             }
             : {};
         return {

package/dist/sidecar/reverse-spawn.js

@@ -33,21 +33,12 @@ export function resolveWinSpawnHelperPath() {
     if (override !== undefined) {
         return override && existsSync(override) ? override : null;
     }
-    const electron = process;
-    const resourcesPath = electron.resourcesPath;
-    const candidates = [];
-    if (resourcesPath) {
-        candidates.push(join(resourcesPath, 'win-spawn-helper', binary));
-    }
-    // Packaged extraResources live under resourcesPath. cwd is the user's
-    // launch directory and must not supply the confinement binary.
-    // `electron .` sets defaultApp and does not copy extraResources there;
-    // npm-published shell also cannot see the host checkout via __dirname.
-    const packagedElectron = Boolean(resourcesPath) && electron.defaultApp !== true;
-    if (!packagedElectron) {
-        candidates.push(join(process.cwd(), 'resources', 'windows-spawn-helper', binary));
-        candidates.push(join(__dirname, '..', '..', 'resources', 'windows-spawn-helper', binary));
-    }
+    // Packaged desktop hosts pass the bundled helper through the override.
+    // npm-published shell cannot see the host checkout via __dirname.
+    const candidates = [
+        join(process.cwd(), 'resources', 'windows-spawn-helper', binary),
+        join(__dirname, '..', '..', 'resources', 'windows-spawn-helper', binary),
+    ];
     for (const candidate of candidates) {
         if (existsSync(candidate))
             return candidate;