@steerable/agent-shell 0.6.34 → 0.6.36

package/dist/app-update-electron.d.ts

@@ -0,0 +1,5 @@
+/**
+ * electron-updater 适配。只在桌面主进程启用更新时加载。
+ */
+import type { AppUpdaterPort } from './app-update.js';
+export declare function createElectronAppUpdater(): AppUpdaterPort;

package/dist/app-update-electron.js

@@ -0,0 +1,66 @@
+/**
+ * electron-updater 适配。只在桌面主进程启用更新时加载。
+ */
+import log from 'electron-log';
+import electronUpdater from 'electron-updater';
+export function createElectronAppUpdater() {
+    const { autoUpdater } = electronUpdater;
+    autoUpdater.logger = log;
+    return {
+        get autoDownload() {
+            return autoUpdater.autoDownload;
+        },
+        set autoDownload(value) {
+            autoUpdater.autoDownload = value;
+        },
+        get autoInstallOnAppQuit() {
+            return autoUpdater.autoInstallOnAppQuit;
+        },
+        set autoInstallOnAppQuit(value) {
+            autoUpdater.autoInstallOnAppQuit = value;
+        },
+        get allowDowngrade() {
+            return autoUpdater.allowDowngrade;
+        },
+        set allowDowngrade(value) {
+            autoUpdater.allowDowngrade = value;
+        },
+        setFeedURL(options) {
+            autoUpdater.setFeedURL(options);
+        },
+        async checkForUpdates() {
+            const result = await autoUpdater.checkForUpdates();
+            if (!result)
+                return null;
+            return {
+                updateInfo: { version: result.updateInfo.version },
+                isUpdateAvailable: result.isUpdateAvailable,
+            };
+        },
+        quitAndInstall(isSilent, isForceRunAfter) {
+            autoUpdater.quitAndInstall(isSilent, isForceRunAfter);
+        },
+        on(event, listener) {
+            if (event === 'download-progress') {
+                autoUpdater.on('download-progress', listener);
+            }
+            else if (event === 'update-downloaded') {
+                autoUpdater.on('update-downloaded', listener);
+            }
+            else {
+                autoUpdater.on('error', listener);
+            }
+        },
+        off(event, listener) {
+            if (event === 'download-progress') {
+                autoUpdater.off('download-progress', listener);
+            }
+            else if (event === 'update-downloaded') {
+                autoUpdater.off('update-downloaded', listener);
+            }
+            else {
+                autoUpdater.off('error', listener);
+            }
+        },
+    };
+}

package/dist/app-update.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 桌面自动更新。产品经 `ProductConfig.updates.feedUrl` 注入 generic 通道；
+ * 本模块只编排检查、下载和安装，具体传输交给 `AppUpdaterPort`
+ * （生产环境是 electron-updater）。
+ */
+export declare const APP_UPDATE_CHECK_INTERVAL_MS: number;
+export type AppUpdatePhase = 'disabled' | 'idle' | 'checking' | 'downloading' | 'ready' | 'installing' | 'error';
+export interface AppUpdateState {
+    phase: AppUpdatePhase;
+    version?: string;
+    percent?: number;
+    message?: string;
+}
+export interface AppUpdateCheckResult {
+    updateInfo: {
+        version: string;
+    };
+    isUpdateAvailable: boolean;
+}
+export interface AppUpdaterPort {
+    autoDownload: boolean;
+    autoInstallOnAppQuit: boolean;
+    allowDowngrade: boolean;
+    setFeedURL(options: {
+        provider: 'generic';
+        url: string;
+    }): void;
+    checkForUpdates(): Promise<AppUpdateCheckResult | null>;
+    quitAndInstall(isSilent?: boolean, isForceRunAfter?: boolean): void;
+    on(event: 'download-progress', listener: (progress: {
+        percent: number;
+    }) => void): void;
+    on(event: 'update-downloaded', listener: (info: {
+        version: string;
+    }) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+    off(event: 'download-progress', listener: (progress: {
+        percent: number;
+    }) => void): void;
+    off(event: 'update-downloaded', listener: (info: {
+        version: string;
+    }) => void): void;
+    off(event: 'error', listener: (error: Error) => void): void;
+}
+export interface AppUpdateOptions {
+    feedUrl?: string;
+    packaged: boolean;
+    currentVersion: string;
+    env: NodeJS.ProcessEnv;
+    updater: AppUpdaterPort;
+    onState?: (state: AppUpdateState) => void;
+    /** 测试注入。缺省写 `env.DEEPPATH_UPDATE_STATUS_FILE`。 */
+    statusFile?: string;
+}
+export declare function appUpdateMenuAction(state: AppUpdateState): 'none' | 'check' | 'install';
+export declare function shouldNotifyUpdateReady(previous: AppUpdatePhase, next: AppUpdateState): boolean;
+export declare class AppUpdateController {
+    private readonly options;
+    private current;
+    private enabled;
+    private started;
+    private disposed;
+    private bound;
+    private candidate;
+    private downloadedVersion;
+    private checkPromise;
+    private cancelTimer;
+    private readonly statusFile;
+    constructor(options: AppUpdateOptions);
+    get state(): AppUpdateState;
+    start(): Promise<AppUpdateState>;
+    checkNow(): Promise<AppUpdateState>;
+    installNow(): AppUpdateState;
+    dispose(): void;
+    private bind;
+    private readonly onProgress;
+    private readonly onDownloaded;
+    private readonly onError;
+    private doCheck;
+    private isNewer;
+    private publish;
+}

package/dist/app-update.js

@@ -0,0 +1,199 @@
+/**
+ * 桌面自动更新。产品经 `ProductConfig.updates.feedUrl` 注入 generic 通道；
+ * 本模块只编排检查、下载和安装，具体传输交给 `AppUpdaterPort`
+ * （生产环境是 electron-updater）。
+ */
+import { appendFileSync } from 'node:fs';
+import { gt, valid } from 'semver';
+export const APP_UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000;
+export function appUpdateMenuAction(state) {
+    if (state.phase === 'disabled')
+        return 'none';
+    if (state.phase === 'ready' || state.phase === 'installing')
+        return 'install';
+    return 'check';
+}
+export function shouldNotifyUpdateReady(previous, next) {
+    return previous !== 'ready' && next.phase === 'ready' && Boolean(next.version);
+}
+function resolveFeed(options) {
+    const override = options.env.DEEPPATH_UPDATE_FEED_URL?.trim() ?? '';
+    const feedUrl = override || options.feedUrl?.trim() || '';
+    const forceUnpackaged = options.env.DEEPPATH_APP_UPDATE === '1';
+    if (!feedUrl || (!options.packaged && !forceUnpackaged))
+        return { enabled: false };
+    return { enabled: true, feedUrl };
+}
+function clampPercent(percent) {
+    if (!Number.isFinite(percent))
+        return 0;
+    return Math.min(100, Math.max(0, percent));
+}
+function defaultSchedule(fn, ms) {
+    const timer = setInterval(fn, ms);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+export class AppUpdateController {
+    options;
+    current = { phase: 'disabled' };
+    enabled = false;
+    started = false;
+    disposed = false;
+    bound = false;
+    candidate;
+    downloadedVersion;
+    checkPromise;
+    cancelTimer;
+    statusFile;
+    constructor(options) {
+        this.options = options;
+        this.statusFile = options.statusFile ?? options.env.DEEPPATH_UPDATE_STATUS_FILE;
+    }
+    get state() {
+        return this.current;
+    }
+    async start() {
+        if (this.started)
+            return this.checkPromise ?? this.state;
+        this.started = true;
+        const target = resolveFeed(this.options);
+        if (!target.enabled)
+            return this.publish({ phase: 'disabled' });
+        this.enabled = true;
+        this.options.updater.autoDownload = true;
+        this.options.updater.autoInstallOnAppQuit = true;
+        this.options.updater.allowDowngrade = false;
+        this.options.updater.setFeedURL({ provider: 'generic', url: target.feedUrl });
+        this.bind();
+        const first = this.checkNow();
+        this.cancelTimer = defaultSchedule(() => {
+            void this.checkNow();
+        }, APP_UPDATE_CHECK_INTERVAL_MS);
+        return first;
+    }
+    checkNow() {
+        if (this.disposed || !this.enabled)
+            return Promise.resolve(this.state);
+        if (this.state.phase === 'downloading' || this.state.phase === 'ready' || this.state.phase === 'installing') {
+            return Promise.resolve(this.state);
+        }
+        if (this.checkPromise)
+            return this.checkPromise;
+        this.checkPromise = this.doCheck().finally(() => {
+            this.checkPromise = undefined;
+        });
+        return this.checkPromise;
+    }
+    installNow() {
+        if (this.disposed || this.state.phase !== 'ready' || !this.downloadedVersion)
+            return this.state;
+        const version = this.downloadedVersion;
+        this.publish({ phase: 'installing', version });
+        try {
+            this.options.updater.quitAndInstall(false, true);
+        }
+        catch (error) {
+            return this.publish({
+                phase: 'error',
+                version,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return this.state;
+    }
+    dispose() {
+        this.disposed = true;
+        this.cancelTimer?.();
+        this.cancelTimer = undefined;
+        if (!this.bound)
+            return;
+        this.options.updater.off('download-progress', this.onProgress);
+        this.options.updater.off('update-downloaded', this.onDownloaded);
+        this.options.updater.off('error', this.onError);
+        this.bound = false;
+    }
+    bind() {
+        if (this.bound)
+            return;
+        this.bound = true;
+        this.options.updater.on('download-progress', this.onProgress);
+        this.options.updater.on('update-downloaded', this.onDownloaded);
+        this.options.updater.on('error', this.onError);
+    }
+    onProgress = (progress) => {
+        if (this.downloadedVersion)
+            return;
+        this.publish({
+            phase: 'downloading',
+            ...(this.candidate ? { version: this.candidate } : {}),
+            percent: clampPercent(progress.percent),
+        });
+    };
+    onDownloaded = (info) => {
+        if (!this.isNewer(info.version))
+            return;
+        this.downloadedVersion = info.version;
+        this.candidate = info.version;
+        this.publish({ phase: 'ready', version: info.version });
+    };
+    onError = (error) => {
+        const version = this.candidate ?? this.state.version;
+        this.publish({
+            phase: 'error',
+            ...(version ? { version } : {}),
+            message: error instanceof Error ? error.message : String(error),
+        });
+    };
+    async doCheck() {
+        this.downloadedVersion = undefined;
+        this.candidate = undefined;
+        this.publish({ phase: 'checking' });
+        try {
+            const result = await this.options.updater.checkForUpdates();
+            if (this.disposed)
+                return this.state;
+            if (this.downloadedVersion && this.isNewer(this.downloadedVersion)) {
+                if (this.state.phase === 'ready' && this.state.version === this.downloadedVersion)
+                    return this.state;
+                return this.publish({ phase: 'ready', version: this.downloadedVersion });
+            }
+            if (!result)
+                return this.publish({ phase: 'error', message: 'app update: no check result' });
+            const version = result.updateInfo.version;
+            if (!result.isUpdateAvailable)
+                return this.publish({ phase: 'idle' });
+            if (valid(version) === null) {
+                return this.publish({ phase: 'error', message: 'app update: feed version is invalid' });
+            }
+            if (!this.isNewer(version))
+                return this.publish({ phase: 'idle' });
+            this.candidate = version;
+            if (this.state.phase === 'downloading') {
+                return this.publish({ phase: 'downloading', version, percent: this.state.percent ?? 0 });
+            }
+            return this.publish({ phase: 'downloading', version, percent: 0 });
+        }
+        catch (error) {
+            if (this.disposed)
+                return this.state;
+            return this.publish({
+                phase: 'error',
+                ...(this.candidate ? { version: this.candidate } : {}),
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    isNewer(version) {
+        return valid(version) !== null && valid(this.options.currentVersion) !== null && gt(version, this.options.currentVersion);
+    }
+    publish(state) {
+        if (this.disposed)
+            return this.current;
+        this.current = state;
+        if (this.statusFile)
+            appendFileSync(this.statusFile, `${JSON.stringify(state)}\n`);
+        this.options.onState?.(state);
+        return state;
+    }
+}

package/dist/main.js

@@ -11,6 +11,8 @@ 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 { createElectronAppUpdater } from './app-update-electron.js';
 import { assertHostIpcAllowed, getResolvedHostTools } from './host-tools-runtime.js';
 import { createJsonStore } from './json-store.js';
 import { getUserDataDir } from './runtime.js';
@@ -471,11 +473,25 @@ function createMenu() {
                 },
             ]
             : []),
-        // 帮助菜单链接是产品注入配置（3.1，product.json links）；中性 shell
-        // 未注入时不渲染对应菜单项；两项都缺则整个「帮助」菜单不渲染。
+        // 帮助菜单：更新动作来自自动更新状态；链接是产品注入配置
+        // （3.1，product.json links）。都没有则不渲染「帮助」。
         ...(() => {
             const links = getProductConfig().links ?? {};
             const submenu = [];
+            const updateAction = appUpdates ? appUpdateMenuAction(appUpdates.state) : 'none';
+            if (updateAction !== 'none') {
+                submenu.push({
+                    label: updateAction === 'install' ? '重启并安装更新' : '检查更新',
+                    click: () => {
+                        if (!appUpdates)
+                            return;
+                        if (appUpdateMenuAction(appUpdates.state) === 'install')
+                            appUpdates.installNow();
+                        else
+                            void appUpdates.checkNow();
+                    },
+                });
+            }
             if (links.releasePage) {
                 submenu.push({
                     label: '打开发布页',
@@ -817,7 +833,37 @@ function setupIpcHandlers() {
         }
     });
 }
+let appUpdates = null;
+function startDesktopUpdates() {
+    let previous = 'disabled';
+    appUpdates = new AppUpdateController({
+        feedUrl: getProductConfig().updates?.feedUrl,
+        packaged: app.isPackaged,
+        currentVersion: app.getVersion(),
+        env: process.env,
+        updater: createElectronAppUpdater(),
+        onState: state => {
+            log.info('[app-update]', state.phase, state.version ?? '', state.message ?? '');
+            if (shouldNotifyUpdateReady(previous, state) && state.version) {
+                const notification = new ElectronNotification({
+                    title: getBrand().displayName,
+                    body: `新版本 ${state.version} 已下载，点击重启并安装`,
+                });
+                notification.on('click', () => {
+                    appUpdates?.installNow();
+                });
+                notification.show();
+            }
+            const actionChanged = appUpdateMenuAction({ phase: previous }) !== appUpdateMenuAction(state);
+            previous = state.phase;
+            if (actionChanged)
+                createMenu();
+        },
+    });
+    void appUpdates.start();
+}
 app.whenReady().then(async () => {
+    startDesktopUpdates();
     applyStrictCsp();
     runtime = await createHostRuntime({
         broadcast: (channel, payload) => broadcastTerminalEvent(channel, payload),

package/dist/product-config.d.ts

@@ -15,6 +15,13 @@ export interface ProductLinks {
     /** 帮助菜单「访问官网」URL。 */
     website?: string;
 }
+export interface ProductUpdates {
+    /**
+     * electron-updater generic 通道根地址（目录，不含 latest*.yml）。
+     * 打包配置里的 publishUrl 由产品组装根注入到这里。空则不检查更新。
+     */
+    feedUrl?: string;
+}
 export interface ProductConfig {
     /**
      * 云端遥测端点（insights flush 的 API base）。空 = 不上报（中性默认）；
@@ -23,6 +30,11 @@ export interface ProductConfig {
     insightsApiBase?: string;
     /** 帮助菜单链接；缺省的项不渲染。 */
     links?: ProductLinks;
+    /**
+     * 桌面自动更新。缺省不检查。只在已打包的应用里生效，除非
+     * `DEEPPATH_APP_UPDATE=1`。`DEEPPATH_UPDATE_FEED_URL` 可覆盖 feedUrl。
+     */
+    updates?: ProductUpdates;
     /**
      * BS 模式的 userData 目录名（~/ 下）。CS 模式由 Electron 按
      * productName 分目录，不经此字段。

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@steerable/agent-shell",
-  "version": "0.6.34",
+  "version": "0.6.36",
   "description": "Steerable framework — product-neutral desktop/headless agent host (Tier 5). Electron main + preload + headless HTTP server (BS) sharing one storage/sidecar/tooling core; scenario packs extend it through the @steerable/pack-sdk contract and are composed at build time by the consuming product.",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pathlyapp/steerable-framework.git",
+    "url": "git+https://github.com/pathlyapp/opensteerable.git",
     "directory": "packages/agent-shell/ts"
   },
   "bugs": {
-    "url": "https://github.com/pathlyapp/steerable-framework/issues"
+    "url": "https://github.com/pathlyapp/opensteerable/issues"
   },
   "type": "module",
   "main": "dist/runtime.js",
@@ -51,20 +51,23 @@
     "dotenv": "^17.4.2",
     "electron-log": "^5.4.3",
     "electron-store": "^8.1.0",
+    "electron-updater": "^6.8.9",
     "he": "^1.2.0",
     "node-pty": "^1.1.0",
-    "@steerable/agent-harness": "0.6.34",
-    "@steerable/pack-sdk": "0.6.34",
-    "@steerable/agent-protocol": "0.6.34"
+    "semver": "^7.8.0",
+    "@steerable/agent-protocol": "0.6.36",
+    "@steerable/pack-sdk": "0.6.36",
+    "@steerable/agent-harness": "0.6.36"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/he": "^1.2.3",
     "@types/node": "^22.10.5",
+    "@types/semver": "^7.8.0",
     "electron": "^28.3.3",
+    "esbuild": "^0.25.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.4",
-    "esbuild": "^0.25.0"
+    "vitest": "^3.2.4"
   },
   "scripts": {
     "gen": "echo agent-shell-ts",