@steerable/agent-shell 0.6.15

package/dist/sidecar/handle.js

@@ -0,0 +1,53 @@
+let sidecarSupervisor = null;
+let pendingSupervisor = null;
+export function setSidecarSupervisor(supervisor) {
+    sidecarSupervisor = supervisor;
+}
+/**
+ * Register the in-flight boot promise so early callers (e.g. the renderer's
+ * skills request racing sidecar boot) can await readiness instead of
+ * observing a bare `null` and degrading. `main.ts` registers this
+ * synchronously inside `maybeStartSidecar()`, before the first await.
+ */
+export function setSidecarSupervisorPending(pending) {
+    pendingSupervisor = pending;
+}
+/** The supervised sidecar handle, when the sidecar path is active. */
+export function getSidecarSupervisor() {
+    return isSidecarEnabled() ? sidecarSupervisor : null;
+}
+export function isSidecarEnabled() {
+    return process.env.STEERABLE_USE_SIDECAR !== '0' && sidecarSupervisor != null;
+}
+/**
+ * Await the sidecar handle through boot: returns the live handle immediately
+ * when already up, otherwise waits on the registered boot promise. Returns
+ * null when the sidecar is disabled, no boot is in flight, boot failed, or
+ * the wait exceeds `timeoutMs` (bounded so a hung python env degrades the
+ * caller to its no-sidecar fallback instead of hanging the request).
+ */
+export async function whenSidecarSupervisor(timeoutMs = 20_000) {
+    if (process.env.STEERABLE_USE_SIDECAR === '0')
+        return null;
+    const live = getSidecarSupervisor();
+    if (live)
+        return live;
+    const pending = pendingSupervisor;
+    if (!pending)
+        return null;
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), timeoutMs);
+    });
+    // A rejected boot promise (python env broken etc.) is already logged by the
+    // boot path; waiters degrade to their no-sidecar fallback instead of
+    // crashing on someone else's boot failure.
+    const settled = pending.catch(() => null);
+    try {
+        return await Promise.race([settled, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/sidecar/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public API for the steerable-sidecar bridge.
+ *
+ * Usage from main.ts:
+ *
+ *   import { SidecarSupervisor } from './sidecar';
+ *   const sidecar = await SidecarSupervisor.start();
+ *   await sidecar.ping();
+ *   const result = await sidecar.invokeTool('list_events', { limit: 10 });
+ *   await sidecar.shutdown();
+ */
+export { SidecarSupervisor } from './supervisor.js';
+export { SidecarBootError, SidecarMethodError, SidecarShutdownError, SidecarSandboxUnavailableError, } from './errors.js';
+export type { SidecarChatStreamHandlers, SidecarChatStreamRequest, SidecarChildEvent, SidecarHealthSnapshot, SidecarMethodOptions, SidecarRawChunk, SidecarSandboxPosture, SidecarSessionForkResult, SidecarStartOptions, SidecarStreamChunk, SidecarStreamDone, SidecarStreamError, SidecarToolResult, } from './types.js';

package/dist/sidecar/index.js

@@ -0,0 +1,13 @@
+/**
+ * Public API for the steerable-sidecar bridge.
+ *
+ * Usage from main.ts:
+ *
+ *   import { SidecarSupervisor } from './sidecar';
+ *   const sidecar = await SidecarSupervisor.start();
+ *   await sidecar.ping();
+ *   const result = await sidecar.invokeTool('list_events', { limit: 10 });
+ *   await sidecar.shutdown();
+ */
+export { SidecarSupervisor } from './supervisor.js';
+export { SidecarBootError, SidecarMethodError, SidecarShutdownError, SidecarSandboxUnavailableError, } from './errors.js';

package/dist/sidecar/proxy-detect.d.ts

@@ -0,0 +1,50 @@
+/**
+ * W4-8: ambient proxy detection for the sidecar sandbox egress allow-list.
+ *
+ * The sidecar's LLM clients (httpx, `trust_env=True`) honor ambient proxy
+ * configuration: `HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY` env vars, and —
+ * when no env proxy is set — the macOS System Configuration proxy via
+ * `urllib.request.getproxies()`. A configured proxy is therefore an
+ * *effective egress point* of the sidecar: if the Seatbelt allow-list names
+ * only the provider endpoint, every LLM call is denied at connect time for
+ * proxy users (EPERM → httpx "All connection attempts failed").
+ *
+ * The allow-list deliberately takes the union of env and system proxies
+ * rather than replicating `getproxies()` precedence (env shadows system):
+ * both endpoints are operator-configured, and the bypass-list semantics
+ * (NO_PROXY / ExceptionsList) are not faithfully surfaced by
+ * `getproxies()` on macOS, so a proxied daemon and a direct localhost
+ * target can both be in play within one boot.
+ */
+/**
+ * Normalize a proxy env value (`http://host:port`, `host:port`, `socks5://…`)
+ * to the `host[:port]` form the sandbox profile expects. Returns null for
+ * unparseable values — a malformed proxy var must not fail profile
+ * generation (the sidecar would fall back unsandboxed).
+ */
+export declare function endpointFromProxyUrl(raw: string): string | null;
+/** Proxy endpoints declared through the process environment. */
+export declare function envProxyEndpoints(env: NodeJS.ProcessEnv): string[];
+/**
+ * Parse `scutil --proxy` output into `host:port` endpoints. Only enabled
+ * protocols yield an entry; the ExceptionsList is intentionally ignored
+ * (see module docstring — bypass state is not reliably knowable here).
+ */
+export declare function parseScutilProxyOutput(output: string): string[];
+/**
+ * macOS System Configuration proxy endpoints. Empty off-darwin (the
+ * Seatbelt sandbox only exists on macOS, so the allow-list only matters
+ * there) and on any scutil failure — detection must never break boot.
+ */
+export declare function detectSystemProxyEndpoints(platform?: NodeJS.Platform): Promise<string[]>;
+/**
+ * Parse `reg query` output for ProxyServer into `host:port` endpoints.
+ * The value is either `host:port` (single proxy) or
+ * `protocol=host:port;...` (per-protocol). Only enabled proxies yield an
+ * entry; the ProxyEnable flag is intentionally ignored (the value is
+ * still present when disabled, and the bypass list is not reliably
+ * surfaced here).
+ */
+export declare function parseWindowsRegProxyOutput(output: string): string[];
+/** All ambient proxy endpoints the sidecar may legitimately egress to. */
+export declare function collectAmbientProxyEndpoints(env?: NodeJS.ProcessEnv): Promise<string[]>;

package/dist/sidecar/proxy-detect.js

@@ -0,0 +1,182 @@
+/**
+ * W4-8: ambient proxy detection for the sidecar sandbox egress allow-list.
+ *
+ * The sidecar's LLM clients (httpx, `trust_env=True`) honor ambient proxy
+ * configuration: `HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY` env vars, and —
+ * when no env proxy is set — the macOS System Configuration proxy via
+ * `urllib.request.getproxies()`. A configured proxy is therefore an
+ * *effective egress point* of the sidecar: if the Seatbelt allow-list names
+ * only the provider endpoint, every LLM call is denied at connect time for
+ * proxy users (EPERM → httpx "All connection attempts failed").
+ *
+ * The allow-list deliberately takes the union of env and system proxies
+ * rather than replicating `getproxies()` precedence (env shadows system):
+ * both endpoints are operator-configured, and the bypass-list semantics
+ * (NO_PROXY / ExceptionsList) are not faithfully surfaced by
+ * `getproxies()` on macOS, so a proxied daemon and a direct localhost
+ * target can both be in play within one boot.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const PROXY_ENV_VARS = [
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'ALL_PROXY',
+    'http_proxy',
+    'https_proxy',
+    'all_proxy',
+];
+/** Default ports per proxy scheme when the URL omits one. */
+const SCHEME_DEFAULT_PORT = {
+    http: 80,
+    https: 443,
+    socks5: 1080,
+    socks5h: 1080,
+    socks4: 1080,
+};
+/**
+ * Normalize a proxy env value (`http://host:port`, `host:port`, `socks5://…`)
+ * to the `host[:port]` form the sandbox profile expects. Returns null for
+ * unparseable values — a malformed proxy var must not fail profile
+ * generation (the sidecar would fall back unsandboxed).
+ */
+export function endpointFromProxyUrl(raw) {
+    const text = raw.trim();
+    if (!text)
+        return null;
+    try {
+        const withScheme = text.includes('://') ? text : `http://${text}`;
+        const url = new URL(withScheme);
+        const host = url.hostname;
+        if (!host)
+            return null;
+        if (url.port)
+            return `${host}:${url.port}`;
+        const scheme = url.protocol.replace(':', '');
+        const fallback = SCHEME_DEFAULT_PORT[scheme];
+        return fallback ? `${host}:${fallback}` : host;
+    }
+    catch {
+        return null;
+    }
+}
+/** Proxy endpoints declared through the process environment. */
+export function envProxyEndpoints(env) {
+    const out = new Set();
+    for (const name of PROXY_ENV_VARS) {
+        const value = env[name];
+        if (!value)
+            continue;
+        const endpoint = endpointFromProxyUrl(value);
+        if (endpoint)
+            out.add(endpoint);
+    }
+    return [...out];
+}
+/**
+ * Parse `scutil --proxy` output into `host:port` endpoints. Only enabled
+ * protocols yield an entry; the ExceptionsList is intentionally ignored
+ * (see module docstring — bypass state is not reliably knowable here).
+ */
+export function parseScutilProxyOutput(output) {
+    const field = (key) => {
+        const match = output.match(new RegExp(`^\\s*${key}\\s*:\\s*(\\S+)\\s*$`, 'm'));
+        return match?.[1];
+    };
+    const out = new Set();
+    const protocols = [
+        { enable: 'HTTPEnable', host: 'HTTPProxy', port: 'HTTPPort', fallback: 80 },
+        { enable: 'HTTPSEnable', host: 'HTTPSProxy', port: 'HTTPSPort', fallback: 443 },
+        { enable: 'SOCKSEnable', host: 'SOCKSProxy', port: 'SOCKSPort', fallback: 1080 },
+    ];
+    for (const p of protocols) {
+        if (field(p.enable) !== '1')
+            continue;
+        const host = field(p.host);
+        if (!host)
+            continue;
+        out.add(`${host}:${field(p.port) ?? p.fallback}`);
+    }
+    return [...out];
+}
+/**
+ * macOS System Configuration proxy endpoints. Empty off-darwin (the
+ * Seatbelt sandbox only exists on macOS, so the allow-list only matters
+ * there) and on any scutil failure — detection must never break boot.
+ */
+export async function detectSystemProxyEndpoints(platform = process.platform) {
+    if (platform === 'darwin') {
+        try {
+            const { stdout } = await execFileAsync('/usr/sbin/scutil', ['--proxy'], {
+                timeout: 5_000,
+            });
+            return parseScutilProxyOutput(stdout);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (platform === 'win32') {
+        return detectWindowsRegistryProxyEndpoints();
+    }
+    return [];
+}
+/**
+ * Windows Registry proxy endpoints (HKCU\Software\Microsoft\Windows\
+ * CurrentVersion\Internet Settings). Empty on any reg.exe failure —
+ * detection must never break boot.
+ */
+async function detectWindowsRegistryProxyEndpoints() {
+    try {
+        const { stdout } = await execFileAsync('reg.exe', [
+            'query',
+            'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
+            '/v',
+            'ProxyServer',
+        ], { timeout: 5_000 });
+        return parseWindowsRegProxyOutput(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Parse `reg query` output for ProxyServer into `host:port` endpoints.
+ * The value is either `host:port` (single proxy) or
+ * `protocol=host:port;...` (per-protocol). Only enabled proxies yield an
+ * entry; the ProxyEnable flag is intentionally ignored (the value is
+ * still present when disabled, and the bypass list is not reliably
+ * surfaced here).
+ */
+export function parseWindowsRegProxyOutput(output) {
+    const match = output.match(/ProxyServer\s+REG_SZ\s+(.+)$/m);
+    if (!match)
+        return [];
+    const value = match[1].trim();
+    if (!value)
+        return [];
+    const out = new Set();
+    // Per-protocol form: "http=host:port;https=host:port;..."
+    if (value.includes('=')) {
+        for (const part of value.split(';')) {
+            const eq = part.indexOf('=');
+            if (eq < 0)
+                continue;
+            const endpoint = part.slice(eq + 1).trim();
+            if (endpoint)
+                out.add(endpoint);
+        }
+    }
+    else {
+        // Single proxy form: "host:port"
+        out.add(value);
+    }
+    return [...out];
+}
+/** All ambient proxy endpoints the sidecar may legitimately egress to. */
+export async function collectAmbientProxyEndpoints(env = process.env) {
+    const envEndpoints = envProxyEndpoints(env);
+    const systemEndpoints = await detectSystemProxyEndpoints();
+    return [...new Set([...envEndpoints, ...systemEndpoints])];
+}

package/dist/sidecar/reverse-approval.d.ts

@@ -0,0 +1,55 @@
+/**
+ * W4-1 reverse channel: serve the sidecar-hosted CoreLoop's
+ * `approval.request` calls by asking the desktop user (Electron renderer
+ * modal) and returning the 7-variant decision.
+ *
+ * Fail-closed by construction: no window, no listener, a renderer error,
+ * or an invalid reply all become `deny_once` — never a hang, never an
+ * auto-allow. The sidecar additionally bounds the wait (`timeoutMs` on the
+ * approval config), so a wedged renderer degrades to `timed_out` there.
+ *
+ * The renderer answers via the `approval:decide` invoke with the requestId
+ * echoed back; decisions are validated against the algebra's kind set
+ * before crossing back to the sidecar.
+ */
+import type { SidecarReverseHandler } from './types.js';
+/**
+ * The approval algebra's decision variants (mirrors
+ * `steerable_agent_runtime.approval.APPROVAL_KINDS`). `timed_out` is
+ * synthesized by the sidecar on timeout, never by the UI.
+ */
+export declare const APPROVAL_DECISION_KINDS: readonly ["allow_once", "allow_for_session", "allow_always", "deny_once", "deny_for_session", "deny_always", "abort"];
+export type ApprovalDecisionKind = (typeof APPROVAL_DECISION_KINDS)[number];
+export interface ApprovalPromptRequest {
+    /** Correlation id echoed back by the renderer's `approval:decide`. */
+    requestId: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+    mode: string;
+    category: string;
+    round: number;
+}
+export interface ApprovalBridgeDeps {
+    /**
+     * Push the prompt to all renderer windows (main.ts wires
+     * `webContents.send('approval:request', …)`). Returning false/undefined
+     * means no window was available → fail closed.
+     */
+    broadcast: (channel: 'approval:request', payload: ApprovalPromptRequest) => void;
+    /** True when at least one renderer window can receive the prompt. */
+    hasWindow: () => boolean;
+    onLog?: (line: string) => void;
+}
+export interface ApprovalBridge {
+    /** Reverse-channel handler for the sidecar's `approval.request`. */
+    handler: SidecarReverseHandler;
+    /**
+     * IPC entry point for the renderer's answer (`ipcMain.handle(
+     * 'approval:decide')`). Unknown requestIds are dropped (late answer to an
+     * already-settled prompt).
+     */
+    decide: (payload: unknown) => {
+        ok: boolean;
+    };
+}
+export declare function createApprovalBridge(deps: ApprovalBridgeDeps): ApprovalBridge;

package/dist/sidecar/reverse-approval.js

@@ -0,0 +1,86 @@
+/**
+ * W4-1 reverse channel: serve the sidecar-hosted CoreLoop's
+ * `approval.request` calls by asking the desktop user (Electron renderer
+ * modal) and returning the 7-variant decision.
+ *
+ * Fail-closed by construction: no window, no listener, a renderer error,
+ * or an invalid reply all become `deny_once` — never a hang, never an
+ * auto-allow. The sidecar additionally bounds the wait (`timeoutMs` on the
+ * approval config), so a wedged renderer degrades to `timed_out` there.
+ *
+ * The renderer answers via the `approval:decide` invoke with the requestId
+ * echoed back; decisions are validated against the algebra's kind set
+ * before crossing back to the sidecar.
+ */
+import { randomUUID } from 'node:crypto';
+/**
+ * The approval algebra's decision variants (mirrors
+ * `steerable_agent_runtime.approval.APPROVAL_KINDS`). `timed_out` is
+ * synthesized by the sidecar on timeout, never by the UI.
+ */
+export const APPROVAL_DECISION_KINDS = [
+    'allow_once',
+    'allow_for_session',
+    'allow_always',
+    'deny_once',
+    'deny_for_session',
+    'deny_always',
+    'abort',
+];
+export function createApprovalBridge(deps) {
+    const pending = new Map();
+    const deny = (reason) => ({ kind: 'deny_once', reason });
+    return {
+        handler: async (params) => {
+            const p = (params ?? {});
+            const toolName = typeof p.toolName === 'string' ? p.toolName : '';
+            if (!toolName) {
+                return { kind: 'deny_once', reason: 'malformed approval request (no toolName)' };
+            }
+            if (!deps.hasWindow()) {
+                deps.onLog?.(`approval: no renderer window; denying ${toolName} once`);
+                return deny('no renderer window available to approve the call');
+            }
+            const requestId = randomUUID();
+            const prompt = {
+                requestId,
+                toolName,
+                arguments: p.arguments && typeof p.arguments === 'object'
+                    ? p.arguments
+                    : {},
+                mode: typeof p.mode === 'string' ? p.mode : 'other',
+                category: typeof p.category === 'string' ? p.category : toolName,
+                round: typeof p.round === 'number' ? p.round : 0,
+            };
+            deps.onLog?.(`approval: prompting for ${toolName} (${prompt.mode}/${prompt.category})`);
+            return await new Promise((resolve) => {
+                pending.set(requestId, { resolve });
+                try {
+                    deps.broadcast('approval:request', prompt);
+                }
+                catch (err) {
+                    pending.delete(requestId);
+                    resolve(deny(`approval prompt failed: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            });
+        },
+        decide: (payload) => {
+            const p = (payload ?? {});
+            const requestId = typeof p.requestId === 'string' ? p.requestId : '';
+            const entry = pending.get(requestId);
+            if (!entry)
+                return { ok: false };
+            pending.delete(requestId);
+            const kind = APPROVAL_DECISION_KINDS.find((k) => k === p.kind);
+            if (!kind) {
+                entry.resolve(deny(`renderer returned an invalid decision kind: ${String(p.kind)}`));
+                return { ok: true };
+            }
+            entry.resolve({
+                kind,
+                reason: typeof p.reason === 'string' ? p.reason : '',
+            });
+            return { ok: true };
+        },
+    };
+}

package/dist/sidecar/reverse-ask-user.d.ts

@@ -0,0 +1,34 @@
+/**
+ * W8 ask_user 反向通道：sidecar 内 CoreLoop 的 `ask_user.request` 反向调用
+ * 由桌面用户（renderer 问题卡片）应答，返回答案映射。
+ *
+ * 与审批桥不同，这里 fail-open：无窗口、renderer 抛错、应答畸形都归一为
+ * 空 `answers`——模型收到「用户未作答」继续推进，绝不挂起一轮。问题本身
+ * 不设桌面侧超时（用户离开多久都可能回来作答，对齐 Claude Code 的阻塞
+ * 语义）；sidecar 侧 HostAskUserHandler 自身已对调用异常 fail-open。
+ *
+ * renderer 经 `ask-user:answer` invoke 回带 requestId 应答。
+ */
+import type { SidecarReverseHandler } from './types.js';
+/** 广播到 renderer 的请示载荷（renderer 原样渲染问题卡片）。 */
+export interface AskUserPromptRequest {
+    /** 关联 id：renderer 的 `ask-user:answer` 原样回带。 */
+    requestId: string;
+    intro: string;
+    questions: Array<Record<string, unknown>>;
+}
+export interface AskUserBridgeDeps {
+    broadcast: (channel: 'ask-user:request', payload: AskUserPromptRequest) => void;
+    /** 是否有能应答的窗口/浏览器连接；没有则立即空答。 */
+    hasWindow: () => boolean;
+    onLog?: (line: string) => void;
+}
+export interface AskUserBridge {
+    /** 注册为 sidecar 的 `ask_user.request` 反向方法处理器。 */
+    handler: SidecarReverseHandler;
+    /** renderer `ask-user:answer` 的入口；返回是否匹配到待应答请求。 */
+    answer: (payload: unknown) => {
+        ok: boolean;
+    };
+}
+export declare function createAskUserBridge(deps: AskUserBridgeDeps): AskUserBridge;

package/dist/sidecar/reverse-ask-user.js

@@ -0,0 +1,59 @@
+/**
+ * W8 ask_user 反向通道：sidecar 内 CoreLoop 的 `ask_user.request` 反向调用
+ * 由桌面用户（renderer 问题卡片）应答，返回答案映射。
+ *
+ * 与审批桥不同，这里 fail-open：无窗口、renderer 抛错、应答畸形都归一为
+ * 空 `answers`——模型收到「用户未作答」继续推进，绝不挂起一轮。问题本身
+ * 不设桌面侧超时（用户离开多久都可能回来作答，对齐 Claude Code 的阻塞
+ * 语义）；sidecar 侧 HostAskUserHandler 自身已对调用异常 fail-open。
+ *
+ * renderer 经 `ask-user:answer` invoke 回带 requestId 应答。
+ */
+import { randomUUID } from 'node:crypto';
+const EMPTY_REPLY = { answers: {} };
+export function createAskUserBridge(deps) {
+    const pending = new Map();
+    return {
+        handler: (params) => {
+            const p = (params ?? {});
+            const questions = Array.isArray(p.questions) ? p.questions : [];
+            if (questions.length === 0) {
+                deps.onLog?.('ask_user: malformed request (no questions); answering empty');
+                return Promise.resolve({ ...EMPTY_REPLY });
+            }
+            if (!deps.hasWindow()) {
+                deps.onLog?.('ask_user: no renderer window; answering empty');
+                return Promise.resolve({ ...EMPTY_REPLY });
+            }
+            const requestId = randomUUID();
+            const prompt = {
+                requestId,
+                intro: typeof p.intro === 'string' ? p.intro : '',
+                questions: questions,
+            };
+            return new Promise((resolve) => {
+                pending.set(requestId, { resolve });
+                try {
+                    deps.broadcast('ask-user:request', prompt);
+                }
+                catch (err) {
+                    pending.delete(requestId);
+                    deps.onLog?.(`ask_user: broadcast failed: ${String(err)}`);
+                    resolve({ ...EMPTY_REPLY });
+                }
+            });
+        },
+        answer: (payload) => {
+            const p = (payload ?? {});
+            const entry = typeof p.requestId === 'string' ? pending.get(p.requestId) : undefined;
+            if (!entry)
+                return { ok: false };
+            pending.delete(p.requestId);
+            const answers = p.answers && typeof p.answers === 'object' && !Array.isArray(p.answers)
+                ? p.answers
+                : {};
+            entry.resolve({ answers });
+            return { ok: true };
+        },
+    };
+}

package/dist/sidecar/reverse-spawn.d.ts

@@ -0,0 +1,19 @@
+/**
+ * W4.1.1 reverse channel: serve the sidecar's `host.process.spawn` by
+ * spawning the command confined on Windows via the win-spawn-helper Rust
+ * binary (restricted token + Job Object; contract: steerable-framework
+ * docs/spec/safety.md "Host capability surface").
+ *
+ * Fail closed by construction: on non-Windows platforms (which have local
+ * rewriter backends and never legitimately route here) or when the helper
+ * binary is absent, the handler throws — the sidecar surfaces a tool error
+ * and the command never runs unconfined.
+ *
+ * Enforcement honesty: the helper confines filesystem writes only. When the
+ * sidecar policy also constrains the network (`network: false` or an
+ * allow-list), the helper's exit frame lists those fields under
+ * `sandbox.notEnforced` and this handler reports `partial`.
+ */
+import type { SidecarReverseHandler } from './types.js';
+export declare function resolveWinSpawnHelperPath(): string | null;
+export declare function createProcessSpawnHandler(): SidecarReverseHandler;