linkshell-cli 0.10.18 → 0.10.20

package/dist/host/src/hub.js

@@ -1,4 +1,4 @@
-import { RpcError, questionReplies, updateAsyncQuestions, sessionIdFor, } from "@linkshell/wire";
+import { RpcError, questionReplies, questionAnswerError, updateAsyncQuestions, sessionIdFor, } from "@linkshell/wire";
 import { inOrder } from "./drivers/acp/driver.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -91,10 +91,13 @@ export class SessionHub {
     store;
     log;
     home;
+    acpServices;
     drivers = new Map();
     live = new Map();
     summaryListeners = new Set();
     removedListeners = new Set();
+    interactionListeners = new Set();
+    agentListeners = new Set();
     auth = new Map();
     /** Terminals (`linkshell <agent>`) currently driving handoff sessions. */
     desktops = new Map();
@@ -104,6 +107,29 @@ export class SessionHub {
     authRefreshing;
     previews;
     driverHost = {
+        authChanged: (agent) => {
+            const driver = this.drivers.get(agent);
+            if (!driver)
+                return;
+            void this.refreshAuth(driver).then(() => { const info = this.agents().find((entry) => entry.id === agent); if (info)
+                for (const listener of this.agentListeners)
+                    listener(info); }).catch(() => { });
+        },
+        agentSettings: (agent) => this.acpServices.settings.settings(agent),
+        loginTerminal: async (agent, launch) => {
+            if (!this.acpServices)
+                throw RpcError.app("not_supported", "终端登录不可用");
+            return this.acpServices.loginTerminal(agent, launch);
+        },
+        interaction: (agent, request) => { for (const listener of this.interactionListeners)
+            listener(agent, request); },
+        notice: (agent, nativeId, notice) => {
+            const live = this.live.get(sessionIdFor(agent, nativeId));
+            if (!live || live.importing)
+                return;
+            for (const subscriber of live.subscribers)
+                subscriber.notice?.(notice);
+        },
         tasks: (agent, nativeId) => {
             const id = sessionIdFor(agent, nativeId);
             return this.store.getSession(id) ? this.tasks(id) : [];
@@ -151,10 +177,13 @@ export class SessionHub {
     };
     constructor(store, drivers, log = () => { }, 
     /** Where the host keeps its own files: worktrees go under it. */
-    home = join(homedir(), ".linkshell")) {
+    home = join(homedir(), ".linkshell"), acpServices) {
         this.store = store;
         this.log = log;
         this.home = home;
+        this.acpServices = acpServices;
+        if (!acpServices)
+            this.driverHost.agentSettings = undefined;
         const capture = process.platform === "darwin" ? new MacPreviewCapture(log) : undefined;
         this.previews = new ComputerPreviews({
             load: (id) => store.getDriverState(id, "computer-preview"),
@@ -167,6 +196,8 @@ export class SessionHub {
             this.drivers.set(driver.id, driver);
     }
     async start(options = {}) {
+        for (const id of this.store.resetLiveSessions())
+            this.pendingQuestions.delete(id);
         await Promise.all([...this.drivers.values()].map(async (driver) => {
             try {
                 const status = await driver.start(this.driverHost);
@@ -177,6 +208,7 @@ export class SessionHub {
                     return;
                 for (const session of await driver.listSessions(100))
                     this.recordDiscovered(driver.id, session);
+                await this.refreshArchives(driver);
             }
             catch (error) {
                 this.log(`[hub] ${driver.id} failed to start: ${error instanceof Error ? error.message : String(error)}`);
@@ -198,12 +230,25 @@ export class SessionHub {
             try {
                 for (const session of await driver.listSessions(limit))
                     this.recordDiscovered(driver.id, session);
+                await this.refreshArchives(driver);
             }
             catch (error) {
                 this.log(`[hub] ${driver.id} discovery failed: ${error instanceof Error ? error.message : String(error)}`);
             }
         }));
     }
+    async refreshArchives(driver) {
+        for (const nativeId of await driver.archivedSessions?.() ?? []) {
+            const before = this.store.getSession(sessionIdFor(driver.id, nativeId));
+            // Only reconcile sessions already known here; never import the entire native archive.
+            if (!before || (before.archived && before.state === "idle"))
+                continue;
+            this.recordDiscovered(driver.id, {
+                nativeId, cwd: before.cwd, createdAt: before.createdAt, updatedAt: before.updatedAt,
+                archived: true, state: "idle", asyncQuestions: [],
+            });
+        }
+    }
     async stop() {
         if (this.discoveryTimer)
             clearInterval(this.discoveryTimer);
@@ -225,6 +270,85 @@ export class SessionHub {
             };
         });
     }
+    onInteraction(listener) {
+        this.interactionListeners.add(listener);
+        return () => { this.interactionListeners.delete(listener); };
+    }
+    onAgent(listener) { this.agentListeners.add(listener); return () => { this.agentListeners.delete(listener); }; }
+    async acpInfo(agent, sessionId) {
+        const driver = this.requireDriver(agent);
+        if (!driver.acpInfo)
+            throw RpcError.app("not_supported", "这个 AI 不使用 ACP");
+        const session = sessionId ? this.getSession(sessionId) : undefined;
+        if (session && session.agent !== agent)
+            throw RpcError.app("invalid_params", "会话与 AI 不匹配");
+        return driver.acpInfo(session?.nativeId);
+    }
+    pendingInteractions() { return [...this.drivers.values()].flatMap((driver) => (driver.pendingInteractions?.() ?? []).map((request) => ({ agent: driver.id, request }))); }
+    async editor(input) {
+        const driver = this.requireDriver(input.agent);
+        if (!driver.editor)
+            throw RpcError.app("not_supported", "这个 AI 不支持编辑建议");
+        return driver.editor(input);
+    }
+    async configureAcp(agent, settings, sessionId) {
+        const driver = this.requireDriver(agent);
+        if (!driver.configureAcp || !this.acpServices)
+            throw RpcError.app("not_supported", "这个 AI 不支持 ACP 配置");
+        const session = sessionId ? this.getSession(sessionId) : undefined;
+        if (session && session.agent !== agent)
+            throw RpcError.app("invalid_params", "会话与 AI 不匹配");
+        await driver.configureAcp(settings, session?.nativeId);
+        if (!session)
+            this.acpServices.settings.setSettings(agent, settings);
+    }
+    async authenticate(agent, methodId, logout) {
+        const driver = this.requireDriver(agent);
+        if (!driver.authenticate)
+            throw RpcError.app("not_supported", "这个 AI 不支持 ACP 登录");
+        const result = await driver.authenticate(methodId, logout);
+        await this.refreshAuth(driver);
+        return result;
+    }
+    async respondInteraction(agent, requestId, response) {
+        const driver = this.requireDriver(agent);
+        if (!driver.respondInteraction)
+            throw RpcError.app("not_supported", "这个 AI 不支持此交互");
+        await driver.respondInteraction(requestId, response);
+    }
+    async providers(agent, operation, config) {
+        const driver = this.requireDriver(agent);
+        if (!driver.providers)
+            throw RpcError.app("not_supported", "这个 AI 不支持供应商配置");
+        return driver.providers(operation, config);
+    }
+    async customAgents(save, remove) {
+        const services = this.acpServices;
+        if (!services)
+            throw RpcError.app("not_supported", "自定义 ACP 配置不可用");
+        if (save && remove)
+            throw RpcError.app("invalid_params", "不能同时保存和移除 Agent");
+        const id = save?.id ?? remove;
+        if (id) {
+            const existing = this.drivers.get(id);
+            if (existing && !services.settings.agents().some((agent) => agent.id === id))
+                throw RpcError.app("invalid_params", "不能覆盖或移除内置 AI");
+            const driver = save ? services.createDriver(save) : undefined;
+            if (existing) {
+                await existing.configureAcp?.(services.settings.settings(id));
+                await existing.stop();
+                this.drivers.delete(id);
+            }
+            if (save && driver) {
+                services.settings.saveAgent(save);
+                this.drivers.set(id, driver);
+                await driver.start(this.driverHost);
+            }
+            else
+                services.settings.removeAgent(id);
+        }
+        return services.settings.agents();
+    }
     /** Re-checks login state in the background when the cached answer is older than `maxAgeMs`. */
     refreshAuthIfStale(maxAgeMs = 60_000) {
         if (this.authRefreshing)
@@ -336,9 +460,12 @@ export class SessionHub {
         if (first) {
             decorated.permission = {
                 requestId: first.requestId,
+                childSessionId: first.childSessionId,
                 toolCallId: first.toolCallId,
                 title: first.title,
                 detail: first.detail,
+                tool: first.tool,
+                url: first.url,
                 options: first.options,
                 questions: first.questions,
             };
@@ -511,9 +638,13 @@ export class SessionHub {
                 // Serve the log we have; not_ready sessions attach once they get a turn.
                 if (!(error instanceof RpcError && error.appCode === "not_ready")) {
                     this.log(`[hub] attach ${sessionId} failed: ${error instanceof Error ? error.message : String(error)}`);
-                    if (error instanceof RpcError && error.appCode === "not_logged_in") {
-                        this.commit(sessionId, { sessionUpdate: "ls_error", code: error.appCode, message: error.message });
-                    }
+                    this.commit(sessionId, { sessionUpdate: "ls_status", state: "error" });
+                    this.commit(sessionId, {
+                        sessionUpdate: "ls_error",
+                        code: error instanceof RpcError ? error.appCode ?? "history_unavailable" : "history_unavailable",
+                        message: `读取会话消息失败：${error instanceof Error ? error.message : String(error)}`,
+                        hint: "重新打开会话可重试",
+                    }, undefined, summary.updatedAt);
                 }
             }
         }
@@ -654,6 +785,8 @@ export class SessionHub {
                 task: detail?.task ?? call.title,
                 agentType: detail?.agentType,
                 name: detail?.name,
+                nativeSessionId: detail?.nativeSessionId,
+                canCancel: detail?.canCancel,
                 running,
                 failed: (workflow?.state ? workflow.state === "failed" : detail?.state ? detail.state === "failed" : state.status === "failed") || undefined,
                 startedAt: workflow?.startedAt ?? event.ts,
@@ -665,6 +798,13 @@ export class SessionHub {
         }
         return [...agents.values()].reverse();
     }
+    async cancelSubagent(sessionId, nativeSessionId) {
+        const session = this.getSession(sessionId), driver = this.requireDriver(session.agent);
+        if (!driver.cancelSubagent)
+            throw RpcError.app("not_supported", "这个 AI 不支持单独停止子代理");
+        await this.ensureAttached(sessionId);
+        await driver.cancelSubagent(session.nativeId, nativeSessionId);
+    }
     subagentsOf(sessionId, live) {
         if (!live.subagents) {
             live.subagents = new Map();
@@ -1012,9 +1152,11 @@ export class SessionHub {
             const other = question.other ? answer.other?.trim() || undefined : undefined;
             return [{ id: question.id, values, other }];
         });
-        const missing = request.questions.find((question) => question.required && !kept.some((answer) => answer.id === question.id && (answer.values.some(Boolean) || answer.other)));
-        if (missing)
-            throw RpcError.app("invalid_params", `还没回答：${missing.header ?? missing.text}`);
+        for (const question of request.questions) {
+            const error = questionAnswerError(question, kept.find((answer) => answer.id === question.id));
+            if (error)
+                throw RpcError.app("invalid_params", error);
+        }
         await driver.answerQuestion(summary.nativeId, requestId, kept);
     }
     async desktopLaunch(agent, args, sessionId, context) {
@@ -1153,7 +1295,7 @@ export class SessionHub {
                     if (live.importChanged && stored)
                         this.emitSummary(stored);
                 }
-                live.attached = true;
+                live.attached = !this.store.getSession(sessionId)?.archived;
             }
             finally {
                 const buffered = live.buffer ?? [];
@@ -1183,7 +1325,7 @@ export class SessionHub {
                     session = { ...session, updatedAt: before.updatedAt };
             }
         }
-        const { summary, created } = this.store.upsertSession({
+        const stored = this.store.upsertSession({
             id: sessionIdFor(agent, session.nativeId),
             agent,
             nativeId: session.nativeId,
@@ -1195,9 +1337,14 @@ export class SessionHub {
             createdAt: session.createdAt,
             updatedAt: session.updatedAt,
         });
+        const { created } = stored;
+        const summary = session.archived !== undefined && session.archived !== stored.summary.archived
+            ? this.store.patchSession(stored.summary.id, { archived: session.archived })
+            : stored.summary;
         const changed = !!before &&
             (before.title !== summary.title ||
                 before.state !== summary.state ||
+                before.archived !== summary.archived ||
                 before.updatedAt !== summary.updatedAt ||
                 before.cwd !== summary.cwd ||
                 before.model !== summary.model);
@@ -1242,6 +1389,8 @@ export class SessionHub {
         // A finished turn can't still be waiting on approvals; clear stale cards.
         if (update.sessionUpdate === "ls_turn" && update.state === "ended" && !update.parentToolCallId) {
             for (const requestId of [...live.permissions.keys()]) {
+                if (live.permissions.get(requestId)?.childSessionId)
+                    continue;
                 this.commit(sessionId, { sessionUpdate: "ls_permission_resolved", requestId });
             }
             if (!live.importing)
@@ -1278,6 +1427,18 @@ export class SessionHub {
             activityChanged = true;
         };
         switch (update.sessionUpdate) {
+            case "ls_message": {
+                if (update.parentToolCallId || !update.content)
+                    break;
+                const text = update.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+                if (update.role === "user" && !before.title && text.trim())
+                    patch.title = compact(text, TITLE_LENGTH);
+                if (update.role === "agent" && text.trim())
+                    patch.preview = compact(text, PREVIEW_LENGTH);
+                if (live.turnActive && update.role === "agent")
+                    setActivity({ kind: "responding" });
+                break;
+            }
             case "user_message_chunk": {
                 const text = update.content.type === "text" ? update.content.text : "";
                 if (text && !before.title)
@@ -1315,10 +1476,15 @@ export class SessionHub {
                 live.turnActive = update.state === "started";
                 setActivity(live.turnActive ? { kind: "thinking" } : undefined);
                 // Leftover permissions are cleared right after a turn ends (see commit).
-                patch.state = live.turnActive ? "running" : update.stopReason === "error" ? "error" : "idle";
+                patch.state = live.turnActive ? "running" : [...live.permissions.values()].some((permission) => permission.childSessionId) ? "waiting" : update.stopReason === "error" ? "error" : "idle";
                 break;
             case "ls_status":
                 patch.state = update.state;
+                if (!live.importing) {
+                    live.turnActive = update.turnActive ?? (update.state === "running" || update.state === "waiting");
+                    if (!live.turnActive)
+                        setActivity(undefined);
+                }
                 break;
             case "ls_permission":
                 live.permissions.set(update.requestId, update);
@@ -1332,8 +1498,13 @@ export class SessionHub {
                     patch.state = live.turnActive ? "running" : "idle";
                 break;
             case "session_info_update":
-                if (update.title)
-                    patch.title = compact(update.title, TITLE_LENGTH);
+                if (update.title !== undefined)
+                    patch.title = update.title === null ? null : compact(update.title, TITLE_LENGTH);
+                if (update.updatedAt !== undefined) {
+                    const updatedAt = update.updatedAt === null ? before.createdAt : Date.parse(update.updatedAt);
+                    if (Number.isFinite(updatedAt))
+                        patch.updatedAt = updatedAt;
+                }
                 if (update.model)
                     patch.model = update.model;
                 break;