@steerable/agent-shell 0.6.52 → 0.6.55

package/dist/preload-default.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/preload-default.js

@@ -1,9 +0,0 @@
-/**
- * shell 默认 preload 入口：无包贡献的中性面（buildPreloadApi()）。
- * 由本包构建（esbuild → dist/preload.cjs）打包成单文件 CJS，供
- * shell main.ts 的默认 preload 路径与纯 shell/demo 启动使用。
- * 带 invoke 型包贡献的产品用自己的 preload 入口（产品构建打包到
- * 产品 main.js 旁）并经 setPreloadPath 注入，不走本入口。
- */
-import { buildPreloadApi } from './preload.js';
-buildPreloadApi();

package/dist/preload.cjs

@@ -1,425 +0,0 @@
-"use strict";
-
-// src/preload.ts
-var import_electron = require("electron");
-var DEMO_TOKEN_KEY = "deeppath_access_token";
-var DEMO_USER_KEY = "deeppath_user";
-var demoToken = process.env.AGENT_DEMO_TOKEN;
-var 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.addEventListener("DOMContentLoaded", seedDemoCredentials);
-function buildPreloadApi(packContributions = {}) {
-  const electronAPI = {
-    runtime: "local",
-    platform: process.platform,
-    onThemeChanged: (callback) => {
-      import_electron.ipcRenderer.on("theme-changed", (_event, isDark) => callback(isDark));
-    },
-    offThemeChanged: () => {
-      import_electron.ipcRenderer.removeAllListeners("theme-changed");
-    },
-    retryConnection: () => {
-      import_electron.ipcRenderer.send("retry-connection");
-    },
-    checkNetworkStatus: async () => {
-      return await import_electron.ipcRenderer.invoke("check-network-status");
-    },
-    onNetworkStatusChanged: (callback) => {
-      import_electron.ipcRenderer.on("network-status-changed", callback);
-    },
-    offNetworkStatusChanged: () => {
-      import_electron.ipcRenderer.removeAllListeners("network-status-changed");
-    },
-    showNotification: (payload) => {
-      import_electron.ipcRenderer.send("show-notification", payload);
-    },
-    onNotificationClicked: (callback) => {
-      import_electron.ipcRenderer.on("notification-clicked", (_event, data) => callback(data));
-    },
-    offNotificationClicked: () => {
-      import_electron.ipcRenderer.removeAllListeners("notification-clicked");
-    },
-    onMenuNewChat: (callback) => {
-      import_electron.ipcRenderer.on("menu:new-chat", () => callback());
-    },
-    offMenuNewChat: () => {
-      import_electron.ipcRenderer.removeAllListeners("menu:new-chat");
-    },
-    onMenuOpenTerminal: (callback) => {
-      import_electron.ipcRenderer.on("menu:open-terminal", () => callback());
-    },
-    offMenuOpenTerminal: () => {
-      import_electron.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 });
-        }
-      };
-      import_electron.ipcRenderer.on("chat-title-updated", handler);
-      return () => {
-        import_electron.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
-          });
-        }
-      };
-      import_electron.ipcRenderer.on("suggested-replies", handler);
-      return () => {
-        import_electron.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
-          });
-        }
-      };
-      import_electron.ipcRenderer.on("chat-created", handler);
-      return () => {
-        import_electron.ipcRenderer.removeListener("chat-created", handler);
-      };
-    },
-    /**
-     * 场景包广播事件订阅（3.1 通用化）：按通道名订阅主进程广播，载荷
-     * 原样透传（收窄校验在订阅方——包——一侧）。通道名约定带包前缀
-     * （如 `<pack>:updated`）。返回解除订阅函数。
-     */
-    onPackEvent: (channel, callback) => {
-      const handler = (_event, payload) => {
-        callback(payload);
-      };
-      import_electron.ipcRenderer.on(channel, handler);
-      return () => {
-        import_electron.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 });
-        }
-      };
-      import_electron.ipcRenderer.on("task-updated", handler);
-      return () => {
-        import_electron.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
-        });
-      };
-      import_electron.ipcRenderer.on("task-process", handler);
-      return () => {
-        import_electron.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);
-          }
-        };
-        import_electron.ipcRenderer.on("approval:request", handler);
-        return () => {
-          import_electron.ipcRenderer.removeListener("approval:request", handler);
-        };
-      },
-      decide: async (decision) => {
-        await import_electron.ipcRenderer.invoke("approval:decide", decision);
-      },
-      pending: async () => {
-        return await import_electron.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);
-          }
-        };
-        import_electron.ipcRenderer.on("ask-user:request", handler);
-        return () => {
-          import_electron.ipcRenderer.removeListener("ask-user:request", handler);
-        };
-      },
-      answer: async (reply) => {
-        await import_electron.ipcRenderer.invoke("ask-user:answer", reply);
-      },
-      pending: async () => {
-        return await import_electron.ipcRenderer.invoke("ask-user:pending");
-      }
-    },
-    local: {
-      selectDirectory: async (options) => {
-        return await import_electron.ipcRenderer.invoke("local:select-directory", options);
-      },
-      saveTextFile: async (options) => {
-        return await import_electron.ipcRenderer.invoke("local:save-text-file", options);
-      },
-      captureScreenshot: async (rect) => {
-        return await import_electron.ipcRenderer.invoke(
-          "local:capture-screenshot",
-          rect ? { rect } : {}
-        );
-      },
-      execShell: async (request) => {
-        return await import_electron.ipcRenderer.invoke("local:exec-shell", request);
-      },
-      readFile: async (request) => {
-        return await import_electron.ipcRenderer.invoke("local:read-file", request);
-      },
-      writeFile: async (request) => {
-        return await import_electron.ipcRenderer.invoke("local:write-file", request);
-      },
-      openPath: async (request) => {
-        return await import_electron.ipcRenderer.invoke("local:open-path", request);
-      },
-      listScripts: async () => {
-        return await import_electron.ipcRenderer.invoke("local:list-scripts");
-      },
-      addScript: async (input) => {
-        return await import_electron.ipcRenderer.invoke("local:add-script", input);
-      },
-      updateScript: async (id, updates) => {
-        return await import_electron.ipcRenderer.invoke("local:update-script", { id, updates });
-      },
-      deleteScript: async (id) => {
-        return await import_electron.ipcRenderer.invoke("local:delete-script", id);
-      },
-      runScript: async (id) => {
-        return await import_electron.ipcRenderer.invoke("local:run-script", id);
-      },
-      getPlatformInfo: () => ({ platform: process.platform }),
-      updateSafetyConfig: async (config) => {
-        return await import_electron.ipcRenderer.invoke("local:update-safety-config", config);
-      }
-    },
-    /** 会话附件：把源文件路径 / base64 字节拷贝进会话空间（`attachments:save`）。 */
-    attachments: {
-      save: async (input) => {
-        return await import_electron.ipcRenderer.invoke("attachments:save", input);
-      }
-    },
-    localBackend: {
-      request: async (input) => {
-        const result = await import_electron.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 import_electron.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 {
-          }
-          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") {
-            import_electron.ipcRenderer.removeListener(channel, handler);
-          }
-        };
-        import_electron.ipcRenderer.on(channel, handler);
-        return result.streamId;
-      },
-      cancelStream: (streamId) => {
-        import_electron.ipcRenderer.send(`local-backend:stream:${streamId}:cancel`);
-      },
-      /**
-       * 轮中转向：把一条用户消息注入该 chat 正在运行的 CoreLoop 回合。
-       * 返回 true 表示已被接受（UI 立即上屏）；false 表示当前没有可转向的
-       * 回合（TS 循环路径或回合刚结束）——调用方应保留草稿。
-       */
-      steerChat: async (chatId, content) => {
-        const result = await import_electron.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) => void 0,
-      offNeedProvision: () => void 0
-    },
-    terminal: {
-      list: async () => {
-        return await import_electron.ipcRenderer.invoke("terminal:list");
-      },
-      spawn: async (options = {}) => {
-        return await import_electron.ipcRenderer.invoke("terminal:spawn", options);
-      },
-      ensure: async (options = {}) => {
-        return await import_electron.ipcRenderer.invoke("terminal:ensure", options);
-      },
-      write: async (id, data) => {
-        return await import_electron.ipcRenderer.invoke("terminal:write", { id, data });
-      },
-      resize: async (id, cols, rows) => {
-        return await import_electron.ipcRenderer.invoke("terminal:resize", { id, cols, rows });
-      },
-      kill: async (id) => {
-        return await import_electron.ipcRenderer.invoke("terminal:kill", id);
-      },
-      exec: async (payload) => {
-        return await import_electron.ipcRenderer.invoke("terminal:exec", payload);
-      },
-      onData: (callback) => {
-        const fn = (_event, payload) => callback(payload);
-        import_electron.ipcRenderer.on("terminal:data", fn);
-        return () => import_electron.ipcRenderer.removeListener("terminal:data", fn);
-      },
-      onExit: (callback) => {
-        const fn = (_event, payload) => callback(payload);
-        import_electron.ipcRenderer.on("terminal:exit", fn);
-        return () => import_electron.ipcRenderer.removeListener("terminal:exit", fn);
-      },
-      onSpawned: (callback) => {
-        const fn = (_event, session) => callback(session);
-        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 });
-}
-
-// src/preload-default.ts
-buildPreloadApi();

package/dist/preload.d.ts

@@ -1,20 +0,0 @@
-/**
- * 构建并暴露 window.electron API（2.3 pack-preload 组合）。
- *
- * 包贡献经参数合并进顶层命名空间（如某包给出 `{ <pack>, <pack>Mock }`
- * 这样的 invoke 型命名空间）；shell 本体不含任何
- * 包符号。由产品 preload 入口（products/<id>/preload.ts）或 dev 入口
- * （devtools/dev-preload.ts）调用。
- */
-export declare function buildPreloadApi(packContributions?: Record<string, unknown>): void;
-/**
- * window.electron 的 API 面。shell 本体不含包符号（2.3 起包段由产品
- * preload 入口组合）；渲染端的完整类型镜像维护在
- * apps/web/src/lib/electron-bridge.ts。
- */
-export type ElectronAPI = Record<string, unknown>;
-declare global {
-    interface Window {
-        electron: ElectronAPI;
-    }
-}