@steerable/agent-shell 0.6.53 → 0.6.55

package/dist/preload.js

@@ -1,442 +0,0 @@
-import { contextBridge, ipcRenderer } from 'electron';
-// ---------------------------------------------------------------------------
-// Demo bypass: pre-seed the renderer's localStorage with a long-lived JWT so
-// the bundled web UI can talk to deeppath-api without going through the login
-// flow. This is intentionally limited to the agent shell and only activates
-// when AGENT_DEMO_TOKEN is set in the launch environment. Remove the env var
-// (or leave it unset) for a normal authenticated experience.
-// ---------------------------------------------------------------------------
-const DEMO_TOKEN_KEY = 'deeppath_access_token';
-const DEMO_USER_KEY = 'deeppath_user';
-const demoToken = process.env.AGENT_DEMO_TOKEN;
-const demoUserJson = process.env.AGENT_DEMO_USER;
-function seedDemoCredentials() {
-    if (!demoToken)
-        return;
-    try {
-        if (window.localStorage.getItem(DEMO_TOKEN_KEY) !== demoToken) {
-            window.localStorage.setItem(DEMO_TOKEN_KEY, demoToken);
-        }
-        if (demoUserJson && !window.localStorage.getItem(DEMO_USER_KEY)) {
-            window.localStorage.setItem(DEMO_USER_KEY, demoUserJson);
-        }
-        const expires = new Date(Date.now() + 30 * 864e5).toUTCString();
-        document.cookie = `${DEMO_TOKEN_KEY}=${encodeURIComponent(demoToken)}; expires=${expires}; path=/; SameSite=Lax`;
-    }
-    catch (err) {
-        console.error('[agent-shell] failed to seed demo token', err);
-    }
-}
-try {
-    seedDemoCredentials();
-}
-catch {
-    // window/document may not be ready yet; retry on DOMContentLoaded.
-}
-window.addEventListener('DOMContentLoaded', seedDemoCredentials);
-/**
- * 构建并暴露 window.electron API（2.3 pack-preload 组合）。
- *
- * 包贡献经参数合并进顶层命名空间（如某包给出 `{ <pack>, <pack>Mock }`
- * 这样的 invoke 型命名空间）；shell 本体不含任何
- * 包符号。由产品 preload 入口（products/<id>/preload.ts）或 dev 入口
- * （devtools/dev-preload.ts）调用。
- */
-export function buildPreloadApi(packContributions = {}) {
-    const electronAPI = {
-        runtime: 'local',
-        platform: process.platform,
-        onThemeChanged: (callback) => {
-            ipcRenderer.on('theme-changed', (_event, isDark) => callback(isDark));
-        },
-        offThemeChanged: () => {
-            ipcRenderer.removeAllListeners('theme-changed');
-        },
-        retryConnection: () => {
-            ipcRenderer.send('retry-connection');
-        },
-        checkNetworkStatus: async () => {
-            return await ipcRenderer.invoke('check-network-status');
-        },
-        onNetworkStatusChanged: (callback) => {
-            ipcRenderer.on('network-status-changed', callback);
-        },
-        offNetworkStatusChanged: () => {
-            ipcRenderer.removeAllListeners('network-status-changed');
-        },
-        showNotification: (payload) => {
-            ipcRenderer.send('show-notification', payload);
-        },
-        onNotificationClicked: (callback) => {
-            ipcRenderer.on('notification-clicked', (_event, data) => callback(data));
-        },
-        offNotificationClicked: () => {
-            ipcRenderer.removeAllListeners('notification-clicked');
-        },
-        onMenuNewChat: (callback) => {
-            ipcRenderer.on('menu:new-chat', () => callback());
-        },
-        offMenuNewChat: () => {
-            ipcRenderer.removeAllListeners('menu:new-chat');
-        },
-        onMenuOpenTerminal: (callback) => {
-            ipcRenderer.on('menu:open-terminal', () => callback());
-        },
-        offMenuOpenTerminal: () => {
-            ipcRenderer.removeAllListeners('menu:open-terminal');
-        },
-        /**
-         * AI 标题异步就绪。Backend 在每条 chat 的首条助手回复完成后 fire-and-forget
-         * 跑 LLM 生成标题；完成后通过这个通道把 `{chatId, title}` 广播到所有 renderer。
-         *
-         * 返回 unsubscribe 函数——和 onMenuNewChat 不一样，这个通道有可能多处订阅
-         * （主窗 + 未来的设置窗），所以用 add/remove 配对而不是 removeAllListeners。
-         */
-        onChatTitleUpdated: (callback) => {
-            const handler = (_event, payload) => {
-                if (typeof payload?.chatId === 'string' && typeof payload?.title === 'string') {
-                    callback({ chatId: payload.chatId, title: payload.title });
-                }
-            };
-            ipcRenderer.on('chat-title-updated', handler);
-            return () => {
-                ipcRenderer.removeListener('chat-title-updated', handler);
-            };
-        },
-        /**
-         * 回合追问建议就绪。Backend 在助手回复完成后 fire-and-forget 生成 3 条
-         * 下一轮用户输入；启发式兜底会立刻推一次，LLM 成功后再替换。返回 unsubscribe。
-         */
-        onSuggestedReplies: (callback) => {
-            const handler = (_event, payload) => {
-                if (typeof payload?.chatId === 'string' &&
-                    typeof payload?.messageId === 'string' &&
-                    Array.isArray(payload.suggestions) &&
-                    payload.suggestions.every((item) => typeof item === 'string')) {
-                    callback({
-                        chatId: payload.chatId,
-                        messageId: payload.messageId,
-                        suggestions: payload.suggestions,
-                    });
-                }
-            };
-            ipcRenderer.on('suggested-replies', handler);
-            return () => {
-                ipcRenderer.removeListener('suggested-replies', handler);
-            };
-        },
-        /**
-         * 会话补建通知：Backend 在向本地不存在的 chatId 首次发送时按 URL 里的 id
-         * 现场补建会话，并广播 `chat-created`（{chatId, agentId}）。返回 unsubscribe
-         * （多处订阅用 add/remove 配对）。
-         */
-        onChatCreated: (callback) => {
-            const handler = (_event, payload) => {
-                if (typeof payload?.chatId === 'string' && payload.chatId) {
-                    callback({
-                        chatId: payload.chatId,
-                        agentId: typeof payload.agentId === 'string' ? payload.agentId : null,
-                    });
-                }
-            };
-            ipcRenderer.on('chat-created', handler);
-            return () => {
-                ipcRenderer.removeListener('chat-created', handler);
-            };
-        },
-        /**
-         * 场景包广播事件订阅（3.1 通用化）：按通道名订阅主进程广播，载荷
-         * 原样透传（收窄校验在订阅方——包——一侧）。通道名约定带包前缀
-         * （如 `<pack>:updated`）。返回解除订阅函数。
-         */
-        onPackEvent: (channel, callback) => {
-            const handler = (_event, payload) => {
-                callback(payload);
-            };
-            ipcRenderer.on(channel, handler);
-            return () => {
-                ipcRenderer.removeListener(channel, handler);
-            };
-        },
-        /**
-         * 4.6a 后台任务状态推送：任务到达终态（completed/failed）或 worktree
-         * 合并/丢弃完成时，主进程广播 `task-updated`。载荷只带 chatId/taskId
-         * ——renderer 收到后重新拉任务列表（GET /chats/:id/tasks），
-         * 不把整条任务记录塞进 IPC（避免与 SQLite 双写漂移）。
-         */
-        onTaskUpdated: (callback) => {
-            const handler = (_event, payload) => {
-                if (typeof payload?.chatId === 'string' && typeof payload?.taskId === 'string') {
-                    callback({ chatId: payload.chatId, taskId: payload.taskId });
-                }
-            };
-            ipcRenderer.on('task-updated', handler);
-            return () => {
-                ipcRenderer.removeListener('task-updated', handler);
-            };
-        },
-        onTaskProcess: (callback) => {
-            const handler = (_event, payload) => {
-                if (typeof payload?.chatId !== 'string' || typeof payload?.taskId !== 'string')
-                    return;
-                callback({
-                    chatId: payload.chatId,
-                    taskId: payload.taskId,
-                    timeline: payload.timeline,
-                    live: payload.live === true,
-                });
-            };
-            ipcRenderer.on('task-process', handler);
-            return () => {
-                ipcRenderer.removeListener('task-process', handler);
-            };
-        },
-        /**
-         * W4-1 审批代数：sidecar 的 ApprovalExecutor 经反向通道请示，主进程把
-         * 请求广播到 renderer（approval:request），输入区审批菜单应答后走
-         * approval:decide 回到主进程。pending 供刷新后的 renderer 恢复仍在等待
-         * 的请求。
-         */
-        approval: {
-            onRequest: (callback) => {
-                const handler = (_event, payload) => {
-                    const p = payload;
-                    if (typeof p?.requestId === 'string' && typeof p?.toolName === 'string') {
-                        callback(payload);
-                    }
-                };
-                ipcRenderer.on('approval:request', handler);
-                return () => {
-                    ipcRenderer.removeListener('approval:request', handler);
-                };
-            },
-            decide: async (decision) => {
-                await ipcRenderer.invoke('approval:decide', decision);
-            },
-            pending: async () => {
-                return await ipcRenderer.invoke('approval:pending');
-            },
-        },
-        /**
-         * W8 结构化提问：sidecar 的 ask_user 工具经反向通道请示，主进程把
-         * 请求广播到 renderer（ask-user:request），问题卡片应答后走
-         * ask-user:answer 回到主进程。pending 供刷新后的 renderer 恢复仍在等待
-         * 的请求。
-         */
-        askUser: {
-            onRequest: (callback) => {
-                const handler = (_event, payload) => {
-                    const p = payload;
-                    if (typeof p?.requestId === 'string' && Array.isArray(p?.questions)) {
-                        callback(payload);
-                    }
-                };
-                ipcRenderer.on('ask-user:request', handler);
-                return () => {
-                    ipcRenderer.removeListener('ask-user:request', handler);
-                };
-            },
-            answer: async (reply) => {
-                await ipcRenderer.invoke('ask-user:answer', reply);
-            },
-            pending: async () => {
-                return await ipcRenderer.invoke('ask-user:pending');
-            },
-        },
-        local: {
-            selectDirectory: async (options) => {
-                return await ipcRenderer.invoke('local:select-directory', options);
-            },
-            saveTextFile: async (options) => {
-                return await ipcRenderer.invoke('local:save-text-file', options);
-            },
-            captureScreenshot: async (rect) => {
-                return await ipcRenderer.invoke('local:capture-screenshot', rect ? { rect } : {});
-            },
-            execShell: async (request) => {
-                return await ipcRenderer.invoke('local:exec-shell', request);
-            },
-            readFile: async (request) => {
-                return await ipcRenderer.invoke('local:read-file', request);
-            },
-            writeFile: async (request) => {
-                return await ipcRenderer.invoke('local:write-file', request);
-            },
-            openPath: async (request) => {
-                return await ipcRenderer.invoke('local:open-path', request);
-            },
-            listScripts: async () => {
-                return await ipcRenderer.invoke('local:list-scripts');
-            },
-            addScript: async (input) => {
-                return await ipcRenderer.invoke('local:add-script', input);
-            },
-            updateScript: async (id, updates) => {
-                return await ipcRenderer.invoke('local:update-script', { id, updates });
-            },
-            deleteScript: async (id) => {
-                return await ipcRenderer.invoke('local:delete-script', id);
-            },
-            runScript: async (id) => {
-                return await ipcRenderer.invoke('local:run-script', id);
-            },
-            getPlatformInfo: () => ({ platform: process.platform }),
-            updateSafetyConfig: async (config) => {
-                return await ipcRenderer.invoke('local:update-safety-config', config);
-            },
-        },
-        /** 会话附件：把源文件路径 / base64 字节拷贝进会话空间（`attachments:save`）。 */
-        attachments: {
-            save: async (input) => {
-                return await ipcRenderer.invoke('attachments:save', input);
-            },
-        },
-        localBackend: {
-            request: async (input) => {
-                const result = await ipcRenderer.invoke('local-backend:request', input);
-                if (!result.ok) {
-                    const err = new Error(result.error || 'Local backend request failed');
-                    err.status = result.status;
-                    throw err;
-                }
-                return result.data;
-            },
-            /**
-             * 启动一条本地后端流。
-             * 注意：Electron contextBridge 不支持把 ReadableStream 跨上下文传给 renderer
-             * （structured clone 会把它剥成空对象，导致 web UI 拿到的 Response.body 永远不出数据）。
-             * 这里只暴露 `startStream(input, onEvent)` 原语，由 web UI 端在 renderer 上下文
-             * 内自己构造 ReadableStream 并喂入 onEvent 回调（callback 跨上下文是 proxied 的）。
-             *
-             * 返回 streamId 用于后续 cancelStream(id)。
-             */
-            startStream: async (input, onEvent) => {
-                const result = (await ipcRenderer.invoke('local-backend:stream', input));
-                if (!result.ok || !result.streamId) {
-                    try {
-                        onEvent({ type: 'error', error: result.error || `start stream failed (${result.status ?? 500})` });
-                    }
-                    catch {
-                        // best-effort: callback 抛错不应影响 IPC 路径
-                    }
-                    return null;
-                }
-                const channel = `local-backend:stream:${result.streamId}`;
-                const handler = (_event, payload) => {
-                    try {
-                        onEvent(payload);
-                    }
-                    catch (err) {
-                        console.error('[preload] stream event callback threw', err);
-                    }
-                    if (payload.type === 'end' || payload.type === 'error') {
-                        ipcRenderer.removeListener(channel, handler);
-                    }
-                };
-                ipcRenderer.on(channel, handler);
-                return result.streamId;
-            },
-            cancelStream: (streamId) => {
-                ipcRenderer.send(`local-backend:stream:${streamId}:cancel`);
-            },
-            /**
-             * 轮中转向：把一条用户消息注入该 chat 正在运行的 CoreLoop 回合。
-             * 返回 true 表示已被接受（UI 立即上屏）；false 表示当前没有可转向的
-             * 回合（TS 循环路径或回合刚结束）——调用方应保留草稿。
-             */
-            steerChat: async (chatId, content) => {
-                const result = (await ipcRenderer.invoke('local-backend:steer', {
-                    chatId,
-                    content,
-                }));
-                return result?.ok === true;
-            },
-            traces: {
-                list: async (chatId, limit = 50) => {
-                    const path = `/api/v2/local/traces?chatId=${encodeURIComponent(chatId)}&limit=${limit}`;
-                    return await electronAPI.localBackend.request({ method: 'GET', path });
-                },
-                get: async (traceId) => {
-                    const path = `/api/v2/local/traces/${encodeURIComponent(traceId)}`;
-                    return await electronAPI.localBackend.request({ method: 'GET', path });
-                },
-            },
-        },
-        agent: {
-            hasToken: async () => {
-                return true;
-            },
-            provision: async (_userJWT) => {
-                return { success: true };
-            },
-            start: async () => {
-                return { success: true };
-            },
-            getStatus: async () => {
-                return { status: 'registered', agentId: 'local-agent' };
-            },
-            getInfo: async () => {
-                return {
-                    id: 'local-agent',
-                    machineId: 'local',
-                    name: 'Local Agent',
-                    platform: process.platform,
-                    hostname: 'localhost',
-                    shell: process.platform === 'darwin' ? 'zsh' : 'bash',
-                    isOnline: true,
-                };
-            },
-            onNeedProvision: (_callback) => undefined,
-            offNeedProvision: () => undefined,
-        },
-        terminal: {
-            list: async () => {
-                return await ipcRenderer.invoke('terminal:list');
-            },
-            spawn: async (options = {}) => {
-                return await ipcRenderer.invoke('terminal:spawn', options);
-            },
-            ensure: async (options = {}) => {
-                return await ipcRenderer.invoke('terminal:ensure', options);
-            },
-            write: async (id, data) => {
-                return await ipcRenderer.invoke('terminal:write', { id, data });
-            },
-            resize: async (id, cols, rows) => {
-                return await ipcRenderer.invoke('terminal:resize', { id, cols, rows });
-            },
-            kill: async (id) => {
-                return await ipcRenderer.invoke('terminal:kill', id);
-            },
-            exec: async (payload) => {
-                return await ipcRenderer.invoke('terminal:exec', payload);
-            },
-            onData: (callback) => {
-                const fn = (_event, payload) => callback(payload);
-                ipcRenderer.on('terminal:data', fn);
-                return () => ipcRenderer.removeListener('terminal:data', fn);
-            },
-            onExit: (callback) => {
-                const fn = (_event, payload) => callback(payload);
-                ipcRenderer.on('terminal:exit', fn);
-                return () => ipcRenderer.removeListener('terminal:exit', fn);
-            },
-            onSpawned: (callback) => {
-                const fn = (_event, session) => callback(session);
-                ipcRenderer.on('terminal:spawned', fn);
-                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/single-instance.d.ts

@@ -1,11 +0,0 @@
-/**
- * Electron single-instance lock. Imported first from main.ts so a second
- * OS process exits before LocalStore opens the product DB.
- *
- * `requestSingleInstanceLock` must run before `app.whenReady`. `process.exit`
- * is required because `app.quit()` is async and later imports would still
- * construct LocalStore against the same userData.
- */
-type SecondInstanceHandler = () => void;
-export declare function setSecondInstanceHandler(handler: SecondInstanceHandler): void;
-export {};

package/dist/single-instance.js

@@ -1,21 +0,0 @@
-/**
- * Electron single-instance lock. Imported first from main.ts so a second
- * OS process exits before LocalStore opens the product DB.
- *
- * `requestSingleInstanceLock` must run before `app.whenReady`. `process.exit`
- * is required because `app.quit()` is async and later imports would still
- * construct LocalStore against the same userData.
- */
-import { app } from 'electron';
-const gotTheLock = app.requestSingleInstanceLock();
-if (!gotTheLock) {
-    app.quit();
-    process.exit(0);
-}
-let secondInstanceHandler = null;
-export function setSecondInstanceHandler(handler) {
-    secondInstanceHandler = handler;
-}
-app.on('second-instance', () => {
-    secondInstanceHandler?.();
-});