@steerable/agent-shell 0.6.47 → 0.6.48

package/dist/app-update.d.ts

@@ -11,6 +11,16 @@ export interface AppUpdateState {
     percent?: number;
     message?: string;
 }
+/** 渲染层看到的版本与更新状态。`version` 是当前安装版本。 */
+export interface AppReleaseSnapshot {
+    version: string;
+    enabled: boolean;
+    phase: AppUpdatePhase;
+    availableVersion?: string;
+    percent?: number;
+    message?: string;
+}
+export declare function toAppReleaseSnapshot(currentVersion: string, state: AppUpdateState): AppReleaseSnapshot;
 export interface AppUpdateCheckResult {
     updateInfo: {
         version: string;

package/dist/app-update.js

@@ -6,6 +6,20 @@
 import { appendFileSync } from 'node:fs';
 import { gt, valid } from 'semver';
 export const APP_UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000;
+export function toAppReleaseSnapshot(currentVersion, state) {
+    const snapshot = {
+        version: currentVersion,
+        enabled: state.phase !== 'disabled',
+        phase: state.phase,
+    };
+    if (state.version)
+        snapshot.availableVersion = state.version;
+    if (state.percent !== undefined)
+        snapshot.percent = state.percent;
+    if (state.message)
+        snapshot.message = state.message;
+    return snapshot;
+}
 export function appUpdateMenuAction(state) {
     if (state.phase === 'disabled')
         return 'none';

package/dist/main.js

@@ -11,7 +11,7 @@ import log from 'electron-log';
 import { getBrand } from './brand.js';
 import { getPreloadPath } from './runtime.js';
 import { getProductConfig } from './product-config.js';
-import { AppUpdateController, appUpdateMenuAction, shouldNotifyUpdateReady, } from './app-update.js';
+import { AppUpdateController, appUpdateMenuAction, shouldNotifyUpdateReady, toAppReleaseSnapshot, } from './app-update.js';
 import { createElectronAppUpdater } from './app-update-electron.js';
 import { assertHostIpcAllowed, getResolvedHostTools } from './host-tools-runtime.js';
 import { createJsonStore } from './json-store.js';
@@ -513,7 +513,26 @@ function createMenu() {
     ];
     Menu.setApplicationMenu(Menu.buildFromTemplate(template));
 }
+function currentReleaseSnapshot(state) {
+    return toAppReleaseSnapshot(app.getVersion(), state ?? appUpdates?.state ?? { phase: 'disabled' });
+}
+function broadcastRelease(state) {
+    if (!mainWindow || mainWindow.isDestroyed())
+        return;
+    mainWindow.webContents.send('app-update-state', currentReleaseSnapshot(state));
+}
 function setupIpcHandlers() {
+    ipcMain.handle('app:release-snapshot', () => currentReleaseSnapshot());
+    ipcMain.handle('app:release-check', async () => {
+        if (!appUpdates)
+            return currentReleaseSnapshot({ phase: 'disabled' });
+        return currentReleaseSnapshot(await appUpdates.checkNow());
+    });
+    ipcMain.handle('app:release-install', () => {
+        if (!appUpdates)
+            return currentReleaseSnapshot({ phase: 'disabled' });
+        return currentReleaseSnapshot(appUpdates.installNow());
+    });
     ipcMain.on('retry-connection', async () => {
         retryCount = 0;
         if (retryTimer) {
@@ -844,6 +863,7 @@ function startDesktopUpdates() {
         updater: createElectronAppUpdater(),
         onState: state => {
             log.info('[app-update]', state.phase, state.version ?? '', state.message ?? '');
+            broadcastRelease(state);
             if (shouldNotifyUpdateReady(previous, state) && state.version) {
                 const notification = new ElectronNotification({
                     title: getBrand().displayName,

package/dist/preload.cjs

@@ -406,6 +406,16 @@ function buildPreloadApi(packContributions = {}) {
         import_electron.ipcRenderer.on("terminal:spawned", fn);
         return () => import_electron.ipcRenderer.removeListener("terminal:spawned", fn);
       }
+    },
+    app: {
+      snapshot: () => import_electron.ipcRenderer.invoke("app:release-snapshot"),
+      check: () => import_electron.ipcRenderer.invoke("app:release-check"),
+      install: () => import_electron.ipcRenderer.invoke("app:release-install"),
+      onState: (callback) => {
+        const fn = (_event, snapshot) => callback(snapshot);
+        import_electron.ipcRenderer.on("app-update-state", fn);
+        return () => import_electron.ipcRenderer.removeListener("app-update-state", fn);
+      }
     }
   };
   import_electron.contextBridge.exposeInMainWorld("electron", { ...electronAPI, ...packContributions });

package/dist/preload.js

@@ -427,6 +427,16 @@ export function buildPreloadApi(packContributions = {}) {
                 return () => ipcRenderer.removeListener('terminal:spawned', fn);
             },
         },
+        app: {
+            snapshot: () => ipcRenderer.invoke('app:release-snapshot'),
+            check: () => ipcRenderer.invoke('app:release-check'),
+            install: () => ipcRenderer.invoke('app:release-install'),
+            onState: (callback) => {
+                const fn = (_event, snapshot) => callback(snapshot);
+                ipcRenderer.on('app-update-state', fn);
+                return () => ipcRenderer.removeListener('app-update-state', fn);
+            },
+        },
     };
     contextBridge.exposeInMainWorld('electron', { ...electronAPI, ...packContributions });
 }

package/dist/server/start.js

@@ -92,7 +92,7 @@ export async function startBsHost(options = {}) {
         shutdown() {
             shutdownPromise ??= (async () => {
                 try {
-                    await new Promise((resolve, reject) => {
+                    const closed = new Promise((resolve, reject) => {
                         server.close((error) => {
                             if (error)
                                 reject(error);
@@ -100,6 +100,12 @@ export async function startBsHost(options = {}) {
                                 resolve();
                         });
                     });
+                    // The Tauri webview keeps HTTP/SSE connections alive while its
+                    // ExitRequested handler waits for this promise. Force those
+                    // connections closed so Cmd+Q does not deadlock until the outer
+                    // five-second process timeout.
+                    server.closeAllConnections();
+                    await closed;
                 }
                 finally {
                     await runtime.shutdown();

package/dist/sidecar/boot.js

@@ -9,7 +9,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import log from 'electron-log';
-import { SidecarSupervisor } from './supervisor.js';
+import { rustSidecarEnabled, SidecarSupervisor, } from './supervisor.js';
 import { setSidecarSupervisor, setSidecarSupervisorPending, llmService } from '../llm/index.js';
 import { resolveSidecarStoragePath } from './storage-path.js';
 import { deriveEgressAllowListFromBaseUrl, probeExecSandboxCapability, } from './exec-sandbox.js';
@@ -22,6 +22,7 @@ import { sidecarWebSearchEnv } from '../storage/web-search-settings.js';
 import { executeHostedWebSearch } from '../hosted-web-search.js';
 let egressProxyRef = null;
 let supervisorRef = null;
+let sidecarGeneration = 0;
 async function deriveSidecarEgressAllowList() {
     const envList = (process.env.STEERABLE_SIDECAR_SANDBOX_ALLOWED_HOSTS ?? '')
         .split(',')
@@ -166,9 +167,16 @@ async function startEgressProxyIfEnabled(store) {
 export async function startHostSidecar(deps) {
     if (process.env.STEERABLE_USE_SIDECAR === '0')
         return;
+    const generation = ++sidecarGeneration;
+    const pythonRunner = process.env.STEERABLE_PYTHON?.trim();
+    const runCodeEnabled = !rustSidecarEnabled() || Boolean(pythonRunner);
     // ready 后的完整接线：注册全局 handle + reverse channels + web 工具握手。
     // 正常 boot 路径与「boot 失败后后台 restart 迟到就绪」路径共用。
     const wireSupervisor = async (supervisor) => {
+        if (generation !== sidecarGeneration) {
+            await supervisor.shutdown();
+            return;
+        }
         supervisorRef = supervisor;
         setSidecarSupervisor(supervisor);
         // A4 reverse channel: the sidecar-hosted CoreLoop asks this process to
@@ -302,7 +310,8 @@ export async function startHostSidecar(deps) {
                     // P1: offer the sidecar's run_code (programmatic tool calls) to the
                     // model. The sidecar registers + advertises it; the desktop's
                     // tool-router forwards the call back over the reverse channel.
-                    STEERABLE_RUN_CODE: '1',
+                    STEERABLE_RUN_CODE: runCodeEnabled ? '1' : '0',
+                    ...(pythonRunner ? { STEERABLE_PYTHON: pythonRunner } : {}),
                     // P3: conversational JS PTC (run_js/wait_js). The sidecar spawns a
                     // long-lived Node worker. Browser and Tauri desktop hosts both run
                     // under the pinned Node runtime, so process.execPath is directly
@@ -311,6 +320,13 @@ export async function startHostSidecar(deps) {
                     STEERABLE_PTC_NODE: process.execPath,
                 },
                 onLogLine: (line) => (deps.onLogLine ?? ((l) => log.info('[sidecar]', l)))(line),
+            }, (created) => {
+                if (generation === sidecarGeneration) {
+                    supervisorRef = created;
+                }
+                else {
+                    void created.shutdown();
+                }
             });
             await wireSupervisor(supervisor);
             return supervisor;
@@ -336,6 +352,7 @@ export async function startHostSidecar(deps) {
 }
 /** 宿主退出钩子：停 supervisor + egress proxy。幂等。 */
 export async function shutdownHostSidecar() {
+    sidecarGeneration += 1;
     if (supervisorRef) {
         const supervisor = supervisorRef;
         supervisorRef = null;

package/dist/sidecar/supervisor.d.ts

@@ -48,7 +48,7 @@ export declare class SidecarSupervisor extends EventEmitter {
     private reverseHandlers;
     private constructor();
     /** Spawn the sidecar and wait for the ready marker. */
-    static start(options?: SidecarStartOptions): Promise<SidecarSupervisor>;
+    static start(options?: SidecarStartOptions, onCreate?: (supervisor: SidecarSupervisor) => void): Promise<SidecarSupervisor>;
     /** Round-trip a JSON-RPC method call. */
     call<T = unknown>(method: string, params?: unknown, options?: SidecarMethodOptions): Promise<T>;
     /** Convenience: list tools registered on the sidecar. */
@@ -220,7 +220,8 @@ export declare class SidecarSupervisor extends EventEmitter {
 export declare function resolveSidecarPython(pythonExecutable?: string): string;
 export declare function rustSidecarEnabled(): boolean;
 /**
- * Resolve the optional Rust sidecar binary. Missing binary with the flag
- * on is a silent fallback to Python (`python -m steerable_sidecar`).
+ * Resolve the Rust sidecar binary from an explicit path, a packaged engine,
+ * or a framework source checkout. Boot fails when Rust was explicitly
+ * enabled but no binary resolves.
  */
 export declare function resolveRustSidecarBin(explicit?: string): string | undefined;

package/dist/sidecar/supervisor.js

@@ -77,8 +77,9 @@ export class SidecarSupervisor extends EventEmitter {
         this.options = options;
     }
     /** Spawn the sidecar and wait for the ready marker. */
-    static async start(options = {}) {
+    static async start(options = {}, onCreate) {
         const supervisor = new SidecarSupervisor(options);
+        onCreate?.(supervisor);
         try {
             await supervisor.boot();
             SidecarSupervisor.lastSpawnRefusal = null;
@@ -383,19 +384,28 @@ export class SidecarSupervisor extends EventEmitter {
     // Internal: boot
     // ------------------------------------------------------------------
     async boot() {
-        const rustBin = rustSidecarEnabled()
+        const useRustSidecar = rustSidecarEnabled();
+        const rustBin = useRustSidecar
             ? resolveRustSidecarBin(this.options.rustSidecarBin)
             : undefined;
         let spawnPlan;
         if (rustBin) {
             spawnPlan = await this.resolveSandboxedSpawn(rustBin, this.options.args ?? []);
         }
+        else if (useRustSidecar) {
+            throw new Error('STEERABLE_RUST_SIDECAR is enabled but the Rust sidecar binary is missing');
+        }
         else {
             const py = this.resolvePythonBinary();
             const entry = this.options.entryModule ?? 'steerable_sidecar';
             const args = ['-m', entry, ...(this.options.args ?? [])];
             spawnPlan = await this.resolveSandboxedSpawn(py, args);
         }
+        // Profile generation is asynchronous. A quit can begin while it runs;
+        // never spawn a new child after shutdown has claimed the supervisor.
+        if (this.shuttingDown) {
+            throw new SidecarShutdownError('sidecar startup cancelled by shutdown');
+        }
         const child = spawn(spawnPlan.command, spawnPlan.args, {
             cwd: this.options.cwd,
             env: { ...process.env, ...this.options.env, ...spawnPlan.env },
@@ -508,9 +518,6 @@ export class SidecarSupervisor extends EventEmitter {
                 (allowResolver ? ' + resolver only (web tools egress via the per-host proxy)' : '') +
                 ')');
             this.sandboxPosture = { backend: 'seatbelt', enforcement: 'partial', reason: 'active' };
-            // macOS TMPDIR is /var/folders, which the Seatbelt profile does not
-            // allow. run_code / run_js materialize their workers there and fail
-            // with EPERM, so the model cannot list or read local folders.
             const confinedTmp = join(writableRoots[0], 'tmp');
             mkdirSync(confinedTmp, { recursive: true });
             return {
@@ -646,6 +653,15 @@ export class SidecarSupervisor extends EventEmitter {
         child.stderr.setEncoding('utf-8');
         child.stdout.on('data', (chunk) => this.handleStdoutChunk(chunk));
         child.stderr.on('data', (chunk) => this.handleStderrChunk(chunk));
+        child.stdin.on('error', (error) => {
+            // A child may close stdin between shutdown's requireChild() and write().
+            // Keep the stream error handled; the write callback/pending failure
+            // carries the transport error to callers.
+            this.failPending(new SidecarShutdownError(`sidecar stdin closed: ${error.message}`));
+            if (!this.shuttingDown) {
+                this.options.onLogLine?.(`sidecar stdin error: ${error.message}`);
+            }
+        });
         child.on('exit', (code, signal) => {
             this.emit('exit', { code, signal });
             this.failPending(new SidecarShutdownError(`sidecar exited (code=${code ?? 'null'}, signal=${signal ?? 'null'})`));
@@ -968,11 +984,15 @@ function envFlag(name) {
     return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
 }
 export function rustSidecarEnabled() {
-    return envFlag(RUST_SIDECAR_ENV);
+    if ((process.env[RUST_SIDECAR_ENV] ?? '').trim()) {
+        return envFlag(RUST_SIDECAR_ENV);
+    }
+    return resolveRustSidecarBin() !== undefined;
 }
 /**
- * Resolve the optional Rust sidecar binary. Missing binary with the flag
- * on is a silent fallback to Python (`python -m steerable_sidecar`).
+ * Resolve the Rust sidecar binary from an explicit path, a packaged engine,
+ * or a framework source checkout. Boot fails when Rust was explicitly
+ * enabled but no binary resolves.
  */
 export function resolveRustSidecarBin(explicit) {
     if (explicit) {
@@ -983,6 +1003,12 @@ export function resolveRustSidecarBin(explicit) {
         return existsSync(fromEnv) ? fromEnv : undefined;
     }
     const exe = process.platform === 'win32' ? 'steerable-sidecar.exe' : 'steerable-sidecar';
+    const resourcesPath = process.resourcesPath;
+    if (resourcesPath) {
+        const packaged = join(resourcesPath, 'engine', exe);
+        if (existsSync(packaged))
+            return packaged;
+    }
     const relatives = [
         join('..', '..', '..', '..', 'sidecar', 'rs', 'target', 'debug', exe),
         join('..', '..', '..', '..', '..', 'sidecar', 'rs', 'target', 'debug', exe),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerable/agent-shell",
-  "version": "0.6.47",
+  "version": "0.6.48",
   "description": "Steerable framework — product-neutral Node HostRuntime and headless HTTP server shared by Tauri desktop and browser deployments; scenario packs extend it through @steerable/pack-sdk.",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",
@@ -55,9 +55,9 @@
     "he": "^1.2.0",
     "node-pty": "^1.1.0",
     "semver": "^7.8.0",
-    "@steerable/pack-sdk": "0.6.47",
-    "@steerable/agent-harness": "0.6.47",
-    "@steerable/agent-protocol": "0.6.47"
+    "@steerable/agent-harness": "0.6.48",
+    "@steerable/pack-sdk": "0.6.48",
+    "@steerable/agent-protocol": "0.6.48"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",