@moxt-ai/mobius 0.0.4 → 0.0.6

package/dist/acp/session-manager.js

@@ -1,10 +1,12 @@
 import { spawn } from "node:child_process";
-import { once } from "node:events";
 import { methods, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
-import { AGENT_CONTENT_KIND, MOBIUS_PROTOCOL_VERSION, SESSION_COMMANDS_UPDATED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_USAGE_UPDATED_KIND, } from "@moxt-ai/mobius-protocol";
+import { AGENT_CONTENT_KIND, decodeAgentPromptResponse, MOBIUS_PROTOCOL_VERSION, SESSION_COMMANDS_UPDATED_KIND, SESSION_CONFIG_UPDATED_KIND, SESSION_ELICITATION_REQUESTED_KIND, SESSION_ELICITATION_RESOLVED_KIND, SESSION_INFO_UPDATED_KIND, SESSION_PERMISSION_REQUESTED_KIND, SESSION_PERMISSION_RESOLVED_KIND, SESSION_USAGE_UPDATED_KIND, } from "@moxt-ai/mobius-protocol";
+import { revalidateExecutable, stopProcessTree, } from "../process/executable.js";
 import { AcpActivityTracker, isProgressMessage, normalizeContentBlock, } from "./activity.js";
 import { createAcpClient } from "./create-client.js";
-import { AcpStoredSession, FoundAcpStoredSession, MemoryAcpSessionStore, } from "./session-store.js";
+import { nativeSessionIdSchema, nativeSessionPageSchema, } from "./native-session.js";
+import { AcpHistoryReplay } from "./session-history.js";
+import { AcpStoredSession, DeletedAcpStoredSession, FoundAcpStoredSession, MemoryAcpSessionStore, } from "./session-store.js";
 const PROCESS_STOP_TIMEOUT_MILLISECONDS = 1_000;
 const SESSION_CONTROL_COMMAND_ID = "session-control";
 export class NullAcpSessionObserver {
@@ -117,31 +119,6 @@ export function createWritableAcpStream(output) {
         },
     });
 }
-async function stopAgentProcess(child) {
-    child.stdin?.end();
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    try {
-        await once(child, "exit", {
-            signal: AbortSignal.timeout(PROCESS_STOP_TIMEOUT_MILLISECONDS),
-        });
-    }
-    catch {
-        if (child.exitCode === null) {
-            child.kill("SIGKILL");
-            try {
-                await once(child, "exit", {
-                    signal: AbortSignal.timeout(PROCESS_STOP_TIMEOUT_MILLISECONDS),
-                });
-            }
-            catch {
-                // Teardown must not wait forever for a process the OS did not reap.
-            }
-        }
-    }
-}
 function truncate(value, maximumLength) {
     return value.length <= maximumLength
         ? value
@@ -299,6 +276,7 @@ function normalizeCapabilities(capabilities) {
         listSessions: session?.list != null,
         loadSession: capabilities.loadSession === true,
         resumeSession: session?.resume != null,
+        unstableForkSession: session?.fork != null,
     };
 }
 function elicitationFieldType(value) {
@@ -607,14 +585,17 @@ class AcpProcessSession {
         listSessions: false,
         loadSession: false,
         resumeSession: false,
+        unstableForkSession: false,
     };
     #commands = [];
     #configOptions = [];
     #nativeSessionId = "";
     #prompted = false;
-    #replaying = false;
+    #replay = {
+        kind: "idle",
+    };
     #restored = false;
-    #sessionTitle = "";
+    #sessionTitle = null;
     #sessionUpdatedAt = "";
     #turn = new IdleAcpTurn();
     #updateTail = Promise.resolve();
@@ -625,8 +606,11 @@ class AcpProcessSession {
         this.#getObserver = getObserver;
         this.#mobiusSessionId = mobiusSessionId;
         this.#store = store;
-        this.#child = spawn(agent.command, [...agent.arguments], {
+        this.#child = spawn(agent.adapterPath, [...agent.arguments], {
             cwd,
+            detached: process.platform !== "win32",
+            env: { ...process.env, ...agent.environment },
+            shell: false,
             stdio: ["pipe", "pipe", "pipe"],
         });
         const stdin = this.#child.stdin;
@@ -649,13 +633,22 @@ class AcpProcessSession {
     }
     static start = async (options, getObserver, store) => {
         options.signal.throwIfAborted();
+        const [adapterUnchanged, agentUnchanged] = await Promise.all([
+            revalidateExecutable(options.agent.adapterIdentity),
+            revalidateExecutable(options.agent.agentIdentity),
+        ]);
+        options.signal.throwIfAborted();
+        if (!adapterUnchanged || !agentUnchanged) {
+            throw new AcpExecutionError("The local Agent runtime changed; restart Mobius before starting a new conversation", {}, "agent_runtime_changed");
+        }
         const runtime = new AcpProcessSession(options.agent, options.cwd, options.additionalDirectories, options.sessionId, getObserver, store);
         try {
-            await runtime.initialize(options.signal);
+            await runtime.initialize(options.signal, options.origin);
             return runtime;
         }
         catch (error) {
             await runtime.closeProcess();
+            options.signal.throwIfAborted();
             if (error instanceof AcpExecutionError) {
                 throw error;
             }
@@ -669,14 +662,34 @@ class AcpProcessSession {
         arraysEqual(this.#additionalDirectories, additionalDirectories);
     canRebind = () => !this.#prompted && !this.#turn.running;
     prepared = () => new AcpPreparedSession(this.#agentName, this.#agentVersion, this.#capabilities, this.#commands, this.#configOptions, this.#restored);
-    initialize = async (signal) => {
+    loadHistory = async (signal) => {
+        if (!this.#capabilities.loadSession)
+            return { status: "unavailable" };
+        const history = new AcpHistoryReplay();
+        this.#replay = { kind: "capture", history };
+        try {
+            await this.race(this.#connection.agent.request(methods.agent.session.load, {
+                additionalDirectories: [...this.#additionalDirectories],
+                cwd: this.#cwd,
+                mcpServers: [],
+                sessionId: this.#nativeSessionId,
+            }, { cancellationSignal: signal }), "ACP agent exited while loading history", signal);
+            await this.#updateTail;
+            signal.throwIfAborted();
+            return history.snapshot();
+        }
+        finally {
+            this.#replay = { kind: "idle" };
+        }
+    };
+    initialize = async (signal, origin) => {
         const initialized = await this.race(this.#connection.agent.request(methods.agent.initialize, {
             clientCapabilities: {
                 elicitation: { form: {}, url: {} },
                 plan: {},
                 session: { configOptions: { boolean: {} } },
             },
-            clientInfo: { name: "mobius", version: "0.0.2" },
+            clientInfo: { name: "mobius", version: "0.0.3" },
             protocolVersion: PROTOCOL_VERSION,
         }, { cancellationSignal: signal }), "ACP agent exited during initialization", signal);
         if (initialized.protocolVersion !== PROTOCOL_VERSION) {
@@ -688,9 +701,31 @@ class AcpProcessSession {
             initialized.agentInfo?.name ??
             this.#agentId, 255);
         this.#agentVersion = truncate(initialized.agentInfo?.version ?? "", 128);
-        const stored = this.#store.read(this.#mobiusSessionId);
+        const stored = origin?.kind === "import"
+            ? new FoundAcpStoredSession(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, nativeSessionIdSchema.parse(origin.nativeSessionId), this.#cwd, this.#additionalDirectories, true))
+            : this.#store.read(this.#mobiusSessionId);
+        if (stored instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The native Agent session was deleted. Start a new chat.", {}, "native_session_deleted");
         let lifecycleResponse;
-        if (stored instanceof FoundAcpStoredSession &&
+        if (origin?.kind === "fork") {
+            if (!this.#capabilities.unstableForkSession)
+                throw new AcpExecutionError("This Agent does not support session forking", {}, "native_session_unsupported");
+            const forked = await this.race(this.#connection.agent.request(methods.agent.session.fork, {
+                sessionId: nativeSessionIdSchema.parse(origin.nativeSessionId),
+                cwd: this.#cwd,
+                additionalDirectories: [...this.#additionalDirectories],
+                mcpServers: [],
+            }, { cancellationSignal: signal }), "ACP agent exited while forking a session", signal);
+            this.#nativeSessionId = nativeSessionIdSchema.parse(forked.sessionId);
+            if (this.#nativeSessionId === origin.nativeSessionId ||
+                this.#store.findNative(this.#agentId, this.#nativeSessionId).length > 0) {
+                throw new AcpExecutionError("The Agent did not create an independent fork", {}, "invalid_native_session_response");
+            }
+            this.#prompted = true;
+            this.#restored = true;
+            lifecycleResponse = forked;
+        }
+        else if (stored instanceof FoundAcpStoredSession &&
             stored.session.agentId === this.#agentId &&
             stored.session.cwd === this.#cwd &&
             arraysEqual(stored.session.additionalDirectories, this.#additionalDirectories)) {
@@ -706,7 +741,7 @@ class AcpProcessSession {
                 }, { cancellationSignal: signal }), "ACP agent exited while resuming a session", signal);
             }
             else if (this.#capabilities.loadSession) {
-                this.#replaying = true;
+                this.#replay = { kind: "discard" };
                 try {
                     lifecycleResponse = await this.race(this.#connection.agent.request(methods.agent.session.load, {
                         additionalDirectories: [...this.#additionalDirectories],
@@ -716,7 +751,8 @@ class AcpProcessSession {
                     }, { cancellationSignal: signal }), "ACP agent exited while loading a session", signal);
                 }
                 finally {
-                    this.#replaying = false;
+                    await this.#updateTail;
+                    this.#replay = { kind: "idle" };
                 }
             }
             else {
@@ -745,7 +781,23 @@ class AcpProcessSession {
         this.#configOptions = normalizeConfigOptions(lifecycleRecord["configOptions"], lifecycleRecord["modes"]);
         await this.#updateTail;
         signal.throwIfAborted();
+        this.#store.write(new AcpStoredSession(this.#mobiusSessionId, this.#agentId, this.#nativeSessionId, this.#cwd, this.#additionalDirectories, this.#prompted));
+    };
+    listNativeSessions = async (cursor, signal) => {
+        if (!this.#capabilities.listSessions)
+            throw new AcpExecutionError("This Agent does not support native session listing", {}, "native_session_unsupported");
+        const response = await this.race(this.#connection.agent.request(methods.agent.session.list, cursor === null ? {} : { cursor }, { cancellationSignal: signal }), "ACP agent exited while listing sessions", signal);
+        const decoded = nativeSessionPageSchema.safeParse(response);
+        if (!decoded.success)
+            throw new AcpExecutionError("The Agent returned an invalid native session list", { cause: decoded.error }, "invalid_native_session_response");
+        return decoded.data;
+    };
+    deleteNativeSession = async (nativeSessionId, signal) => {
+        if (!this.#capabilities.deleteSession || !this.#capabilities.listSessions)
+            throw new AcpExecutionError("This Agent does not support native session deletion", {}, "native_session_unsupported");
+        await this.race(this.#connection.agent.request(methods.agent.session.delete, { sessionId: nativeSessionIdSchema.parse(nativeSessionId) }, { cancellationSignal: signal }), "ACP agent exited while deleting a session", signal);
     };
+    nativeSessionId = () => this.#nativeSessionId;
     configure = async (options) => {
         const existing = this.#configOptions.find((option) => option.id === options.configId);
         if (existing === undefined || existing.type !== options.valueType) {
@@ -835,7 +887,25 @@ class AcpProcessSession {
             const response = await this.race(this.#connection.agent.request(methods.agent.session.prompt, { prompt, sessionId: this.#nativeSessionId }, { cancellationSignal: options.signal }), "ACP agent exited during a prompt", options.signal);
             await this.#updateTail;
             await running.activities.finish();
-            return { stopReason: response.stopReason };
+            let result;
+            try {
+                result = decodeAgentPromptResponse(response);
+            }
+            catch (cause) {
+                throw new AcpExecutionError("ACP agent returned an invalid prompt response", { cause }, "acp_invalid_prompt_response");
+            }
+            if (result.usage != null || result._meta?.quota !== undefined) {
+                await this.#getObserver().onUsage({
+                    _meta: result._meta ?? null,
+                    commandId: options.commandId,
+                    kind: SESSION_USAGE_UPDATED_KIND,
+                    protocolVersion: MOBIUS_PROTOCOL_VERSION,
+                    sessionId: this.#mobiusSessionId,
+                    source: "prompt",
+                    usage: result.usage ?? null,
+                });
+            }
+            return result;
         }
         catch (error) {
             await running.activities.finish();
@@ -1024,7 +1094,9 @@ class AcpProcessSession {
     processUpdate = async (notification) => {
         this.assertNativeSession(notification.sessionId);
         const update = notification.update;
-        if (this.#replaying &&
+        if (this.#replay.kind === "capture")
+            this.#replay.history.record(update);
+        if (this.#replay.kind !== "idle" &&
             (update.sessionUpdate === "user_message_chunk" ||
                 update.sessionUpdate === "agent_message_chunk" ||
                 update.sessionUpdate === "agent_thought_chunk" ||
@@ -1140,6 +1212,7 @@ class AcpProcessSession {
                 protocolVersion: MOBIUS_PROTOCOL_VERSION,
                 sessionId: this.#mobiusSessionId,
                 size: Math.max(0, Math.trunc(update.size)),
+                source: "context",
                 used: Math.max(0, Math.trunc(update.used)),
             });
         }
@@ -1160,7 +1233,7 @@ class AcpProcessSession {
     };
     closeProcess = async () => {
         this.#connection.close();
-        await stopAgentProcess(this.#child);
+        await stopProcessTree(this.#child);
     };
     race = async (operation, exitMessage, signal) => {
         signal.throwIfAborted();
@@ -1253,6 +1326,7 @@ class AcpProcessSession {
     };
 }
 export class AcpSessionManager {
+    #nativeOperations = new Set();
     #activeSessionIds = new Set();
     #cancellationRequests = new Set();
     #preparing = new Map();
@@ -1298,6 +1372,12 @@ export class AcpSessionManager {
         return await operation;
     }
     prepareSession = async (options) => {
+        const stored = this.#store.read(options.sessionId);
+        if (stored instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The native Agent session was deleted. Start a new chat.", {}, "native_session_deleted");
+        if (stored instanceof FoundAcpStoredSession &&
+            this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`))
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
         const pending = this.#preparing.get(options.sessionId);
         if (pending !== undefined) {
             const runtime = await pending;
@@ -1332,6 +1412,11 @@ export class AcpSessionManager {
         }
     };
     runPrompt = async (options) => {
+        const stored = this.#store.read(options.sessionId);
+        if (stored instanceof FoundAcpStoredSession &&
+            this.#nativeOperations.has(`${stored.session.agentId}:${stored.session.nativeSessionId}`)) {
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
+        }
         if (this.#activeSessionIds.has(options.sessionId)) {
             throw new AcpExecutionError("Another prompt is already running in this conversation", {}, "session_busy");
         }
@@ -1341,6 +1426,8 @@ export class AcpSessionManager {
                 return { stopReason: "cancelled" };
             }
             const runtime = await this.ensureSession(options);
+            if (this.#nativeOperations.has(`${options.agent.id}:${runtime.nativeSessionId()}`))
+                throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
             if (this.#cancellationRequests.has(options.sessionId)) {
                 return { stopReason: "cancelled" };
             }
@@ -1398,5 +1485,103 @@ export class AcpSessionManager {
         }
         return started;
     };
+    listNativeSessions = async (options, cursor) => await (await this.ensureSession(options)).listNativeSessions(cursor, options.signal);
+    openNativeSession = async (options, origin) => {
+        const key = `${options.agent.id}:${origin.nativeSessionId}`;
+        if (this.#nativeOperations.has(key))
+            throw new AcpExecutionError("The native session is being managed", {}, "session_busy");
+        const linked = this.#store.findNative(options.agent.id, origin.nativeSessionId);
+        if (linked.some((entry) => this.#activeSessionIds.has(entry.sessionId) ||
+            this.#preparing.has(entry.sessionId)))
+            throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+        const existing = linked[0];
+        if (origin.kind === "import" && existing !== undefined) {
+            const runtime = await this.ensureSession({
+                ...options,
+                sessionId: existing.sessionId,
+            });
+            if (this.#activeSessionIds.has(existing.sessionId) ||
+                this.#nativeOperations.has(key))
+                throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+            this.#nativeOperations.add(key);
+            try {
+                const history = await runtime.loadHistory(options.signal);
+                return {
+                    prepared: runtime.prepared(),
+                    sessionId: existing.sessionId,
+                    history,
+                };
+            }
+            catch (error) {
+                this.#sessions.delete(existing.sessionId);
+                await runtime.closeProcess();
+                throw error;
+            }
+            finally {
+                this.#nativeOperations.delete(key);
+            }
+        }
+        if (this.#sessions.has(options.sessionId) ||
+            this.#preparing.has(options.sessionId) ||
+            this.#store.read(options.sessionId) instanceof FoundAcpStoredSession ||
+            this.#store.read(options.sessionId) instanceof DeletedAcpStoredSession)
+            throw new AcpExecutionError("The destination conversation already exists", {}, "session_identity_mismatch");
+        this.#nativeOperations.add(key);
+        try {
+            const runtime = await this.#startPreparation({ ...options, origin });
+            const openedKey = `${options.agent.id}:${runtime.nativeSessionId()}`;
+            this.#nativeOperations.add(openedKey);
+            try {
+                const history = await runtime.loadHistory(options.signal);
+                return {
+                    sessionId: options.sessionId,
+                    prepared: runtime.prepared(),
+                    history,
+                };
+            }
+            catch (error) {
+                this.#sessions.delete(options.sessionId);
+                this.#store.remove(options.sessionId);
+                await runtime.closeProcess();
+                throw error;
+            }
+            finally {
+                this.#nativeOperations.delete(openedKey);
+            }
+        }
+        finally {
+            this.#nativeOperations.delete(key);
+        }
+    };
+    deleteNativeSession = async (options, nativeSessionId) => {
+        const runtime = await this.ensureSession(options);
+        const key = `${options.agent.id}:${nativeSessionId}`;
+        const linked = this.#store.findNative(options.agent.id, nativeSessionId);
+        if (this.#nativeOperations.has(key) ||
+            linked.some((entry) => this.#activeSessionIds.has(entry.sessionId) ||
+                this.#preparing.has(entry.sessionId)))
+            throw new AcpExecutionError("Wait for the native session's running operation to finish", {}, "session_busy");
+        this.#nativeOperations.add(key);
+        try {
+            for (const entry of linked) {
+                const active = this.#sessions.get(entry.sessionId);
+                if (active !== undefined && active !== runtime) {
+                    this.#sessions.delete(entry.sessionId);
+                    await active.close();
+                }
+            }
+            options.signal.throwIfAborted();
+            await runtime.deleteNativeSession(nativeSessionId, options.signal);
+            const deleted = this.#store.markDeleted(options.agent.id, nativeSessionId);
+            if (runtime.nativeSessionId() === nativeSessionId) {
+                this.#sessions.delete(options.sessionId);
+                await runtime.close();
+            }
+            return deleted;
+        }
+        finally {
+            this.#nativeOperations.delete(key);
+        }
+    };
 }
 //# sourceMappingURL=session-manager.js.map