@mobvibe/cli 0.1.4 → 0.1.6

package/dist/index.js

@@ -379,12 +379,13 @@ var getCliConfig = async () => {
 
 // src/daemon/daemon.ts
 import { spawn as spawn2 } from "child_process";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path5 from "path";
 
 // src/acp/session-manager.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
+import fs3 from "fs/promises";
 
 // ../../packages/shared/dist/types/errors.js
 var createErrorDetail = (input) => ({
@@ -559,8 +560,7 @@ var AcpConnection = class {
   getSessionCapabilities() {
     return {
       list: this.agentCapabilities?.sessionCapabilities?.list != null,
-      load: this.agentCapabilities?.loadSession === true,
-      resume: this.agentCapabilities?.sessionCapabilities?.resume != null
+      load: this.agentCapabilities?.loadSession === true
     };
   }
   /**
@@ -575,12 +575,6 @@ var AcpConnection = class {
   supportsSessionLoad() {
     return this.agentCapabilities?.loadSession === true;
   }
-  /**
-   * Check if the agent supports session/resume.
-   */
-  supportsSessionResume() {
-    return this.agentCapabilities?.sessionCapabilities?.resume != null;
-  }
   /**
    * List sessions from the agent (session/list).
    * @param params Optional filter parameters
@@ -588,14 +582,17 @@ var AcpConnection = class {
    */
   async listSessions(params) {
     if (!this.supportsSessionList()) {
-      return [];
+      return { sessions: [] };
     }
     const connection = await this.ensureReady();
     const response = await connection.unstable_listSessions({
       cursor: params?.cursor ?? void 0,
       cwd: params?.cwd ?? void 0
     });
-    return response.sessions;
+    return {
+      sessions: response.sessions,
+      nextCursor: response.nextCursor ?? void 0
+    };
   }
   /**
    * Load a historical session with message history replay (session/load).
@@ -616,25 +613,6 @@ var AcpConnection = class {
     this.sessionId = sessionId;
     return response;
   }
-  /**
-   * Resume an active session without message history replay (session/resume).
-   * @param sessionId The session ID to resume
-   * @param cwd The working directory
-   * @returns Resume session response
-   */
-  async resumeSession(sessionId, cwd) {
-    if (!this.supportsSessionResume()) {
-      throw new Error("Agent does not support session/resume capability");
-    }
-    const connection = await this.ensureReady();
-    const response = await connection.unstable_resumeSession({
-      sessionId,
-      cwd,
-      mcpServers: []
-    });
-    this.sessionId = sessionId;
-    return response;
-  }
   setPermissionHandler(handler) {
     this.permissionHandler = handler;
   }
@@ -979,6 +957,14 @@ var createCapabilityNotSupportedError = (message) => new AppError(
   }),
   409
 );
+var isValidWorkspacePath = async (cwd) => {
+  try {
+    const stats = await fs3.stat(cwd);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
 var SessionManager = class {
   constructor(config) {
     this.config = config;
@@ -988,6 +974,7 @@ var SessionManager = class {
     this.defaultBackendId = config.defaultAcpBackendId;
   }
   sessions = /* @__PURE__ */ new Map();
+  discoveredSessions = /* @__PURE__ */ new Map();
   backendById;
   defaultBackendId;
   permissionRequests = /* @__PURE__ */ new Map();
@@ -997,6 +984,8 @@ var SessionManager = class {
   permissionResultEmitter = new EventEmitter2();
   terminalOutputEmitter = new EventEmitter2();
   sessionsChangedEmitter = new EventEmitter2();
+  sessionAttachedEmitter = new EventEmitter2();
+  sessionDetachedEmitter = new EventEmitter2();
   listSessions() {
     return Array.from(this.sessions.values()).map(
       (record) => this.buildSummary(record)
@@ -1041,9 +1030,54 @@ var SessionManager = class {
       this.sessionsChangedEmitter.off("changed", listener);
     };
   }
+  onSessionAttached(listener) {
+    this.sessionAttachedEmitter.on("attached", listener);
+    return () => {
+      this.sessionAttachedEmitter.off("attached", listener);
+    };
+  }
+  onSessionDetached(listener) {
+    this.sessionDetachedEmitter.on("detached", listener);
+    return () => {
+      this.sessionDetachedEmitter.off("detached", listener);
+    };
+  }
   emitSessionsChanged(payload) {
     this.sessionsChangedEmitter.emit("changed", payload);
   }
+  emitSessionAttached(sessionId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+    if (record.isAttached) {
+      return;
+    }
+    const attachedAt = /* @__PURE__ */ new Date();
+    record.isAttached = true;
+    record.attachedAt = attachedAt;
+    this.sessionAttachedEmitter.emit("attached", {
+      sessionId,
+      machineId: this.config.machineId,
+      attachedAt: attachedAt.toISOString()
+    });
+  }
+  emitSessionDetached(sessionId, reason) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+    if (!record.isAttached) {
+      return;
+    }
+    record.isAttached = false;
+    this.sessionDetachedEmitter.emit("detached", {
+      sessionId,
+      machineId: this.config.machineId,
+      detachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+  }
   listPendingPermissions(sessionId) {
     return Array.from(this.permissionRequests.values()).filter((record) => record.sessionId === sessionId).map((record) => this.buildPermissionRequestPayload(record));
   }
@@ -1132,29 +1166,9 @@ var SessionManager = class {
       };
       record.unsubscribe = connection.onSessionUpdate(
         (notification) => {
-          this.touchSession(session.sessionId);
+          record.updatedAt = /* @__PURE__ */ new Date();
           this.sessionUpdateEmitter.emit("update", notification);
-          const update = notification.update;
-          if (update.sessionUpdate === "current_mode_update") {
-            record.modeId = update.currentModeId;
-            record.modeName = record.availableModes?.find(
-              (mode) => mode.id === update.currentModeId
-            )?.name ?? record.modeName;
-            return;
-          }
-          if (update.sessionUpdate === "session_info_update") {
-            if (typeof update.title === "string") {
-              record.title = update.title;
-            }
-            if (typeof update.updatedAt === "string") {
-              record.updatedAt = new Date(update.updatedAt);
-            }
-          }
-          if (update.sessionUpdate === "available_commands_update") {
-            if (update.availableCommands) {
-              record.availableCommands = update.availableCommands;
-            }
-          }
+          this.applySessionUpdateToRecord(record, notification);
         }
       );
       record.unsubscribeTerminal = connection.onTerminalOutput((event) => {
@@ -1166,6 +1180,7 @@ var SessionManager = class {
             sessionId: session.sessionId,
             error: status.error
           });
+          this.emitSessionDetached(session.sessionId, "agent_exit");
         }
       });
       this.sessions.set(session.sessionId, record);
@@ -1175,6 +1190,7 @@ var SessionManager = class {
         updated: [],
         removed: []
       });
+      this.emitSessionAttached(session.sessionId);
       return summary;
     } catch (error) {
       const status = connection.getStatus();
@@ -1391,6 +1407,7 @@ var SessionManager = class {
     } catch (error) {
       logger.error({ err: error, sessionId }, "session_disconnect_failed");
     }
+    this.emitSessionDetached(sessionId, "unknown");
     this.sessions.delete(sessionId);
     this.emitSessionsChanged({
       added: [],
@@ -1424,11 +1441,30 @@ var SessionManager = class {
       await connection.connect();
       const capabilities = connection.getSessionCapabilities();
       const sessions = [];
+      let nextCursor;
       if (capabilities.list) {
-        const agentSessions = await connection.listSessions({
-          cwd: options?.cwd
+        const response = await connection.listSessions({
+          cwd: options?.cwd,
+          cursor: options?.cursor
         });
-        for (const session of agentSessions) {
+        nextCursor = response.nextCursor;
+        const validity = await Promise.all(
+          response.sessions.map(async (session) => ({
+            session,
+            isValid: session.cwd ? await isValidWorkspacePath(session.cwd) : false
+          }))
+        );
+        for (const { session, isValid } of validity) {
+          if (!isValid) {
+            this.discoveredSessions.delete(session.sessionId);
+            continue;
+          }
+          this.discoveredSessions.set(session.sessionId, {
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            title: session.title ?? void 0,
+            updatedAt: session.updatedAt ?? void 0
+          });
           sessions.push({
             sessionId: session.sessionId,
             cwd: session.cwd,
@@ -1445,7 +1481,7 @@ var SessionManager = class {
         },
         "sessions_discovered"
       );
-      return { sessions, capabilities };
+      return { sessions, capabilities, nextCursor };
     } finally {
       await connection.disconnect();
     }
@@ -1461,6 +1497,7 @@ var SessionManager = class {
   async loadSession(sessionId, cwd, backendId) {
     const existing = this.sessions.get(sessionId);
     if (existing) {
+      this.emitSessionAttached(sessionId);
       return this.buildSummary(existing);
     }
     const backend = this.resolveBackend(backendId);
@@ -1478,6 +1515,19 @@ var SessionManager = class {
           "Agent does not support session loading"
         );
       }
+      const bufferedUpdates = [];
+      let recordRef;
+      const unsubscribe = connection.onSessionUpdate(
+        (notification) => {
+          this.sessionUpdateEmitter.emit("update", notification);
+          if (recordRef) {
+            recordRef.updatedAt = /* @__PURE__ */ new Date();
+            this.applySessionUpdateToRecord(recordRef, notification);
+          } else {
+            bufferedUpdates.push(notification);
+          }
+        }
+      );
       const response = await connection.loadSession(sessionId, cwd);
       connection.setPermissionHandler(
         (params) => this.handlePermissionRequest(sessionId, params)
@@ -1490,9 +1540,10 @@ var SessionManager = class {
       const { modeId, modeName, availableModes } = resolveModeState(
         response.modes
       );
+      const discovered = this.discoveredSessions.get(sessionId);
       const record = {
         sessionId,
-        title: `Loaded Session`,
+        title: discovered?.title ?? sessionId,
         backendId: backend.id,
         backendLabel: backend.label,
         connection,
@@ -1508,7 +1559,12 @@ var SessionManager = class {
         availableModels,
         availableCommands: void 0
       };
-      this.setupSessionSubscriptions(record);
+      recordRef = record;
+      record.unsubscribe = unsubscribe;
+      for (const notification of bufferedUpdates) {
+        this.applySessionUpdateToRecord(record, notification);
+      }
+      this.setupSessionSubscriptions(record, { skipSessionUpdates: true });
       this.sessions.set(sessionId, record);
       const summary = this.buildSummary(record);
       this.emitSessionsChanged({
@@ -1516,6 +1572,7 @@ var SessionManager = class {
         updated: [],
         removed: []
       });
+      this.emitSessionAttached(sessionId);
       logger.info({ sessionId, backendId: backend.id }, "session_loaded");
       return summary;
     } catch (error) {
@@ -1523,111 +1580,41 @@ var SessionManager = class {
       throw error;
     }
   }
-  /**
-   * Resume an active session from the ACP agent.
-   * This does not replay message history.
-   * @param sessionId The session ID to resume
-   * @param cwd The working directory
-   * @param backendId Optional backend ID
-   * @returns The resumed session summary
-   */
-  async resumeSession(sessionId, cwd, backendId) {
-    const existing = this.sessions.get(sessionId);
-    if (existing) {
-      return this.buildSummary(existing);
+  applySessionUpdateToRecord(record, notification) {
+    const update = notification.update;
+    if (update.sessionUpdate === "current_mode_update") {
+      record.modeId = update.currentModeId;
+      record.modeName = record.availableModes?.find((mode) => mode.id === update.currentModeId)?.name ?? record.modeName;
+      return;
     }
-    const backend = this.resolveBackend(backendId);
-    const connection = new AcpConnection({
-      backend,
-      client: {
-        name: this.config.clientName,
-        version: this.config.clientVersion
+    if (update.sessionUpdate === "session_info_update") {
+      if (typeof update.title === "string") {
+        record.title = update.title;
       }
-    });
-    try {
-      await connection.connect();
-      if (!connection.supportsSessionResume()) {
-        throw createCapabilityNotSupportedError(
-          "Agent does not support session resuming"
-        );
+      if (typeof update.updatedAt === "string") {
+        record.updatedAt = new Date(update.updatedAt);
+      }
+    }
+    if (update.sessionUpdate === "available_commands_update") {
+      if (update.availableCommands) {
+        record.availableCommands = update.availableCommands;
       }
-      const response = await connection.resumeSession(sessionId, cwd);
-      connection.setPermissionHandler(
-        (params) => this.handlePermissionRequest(sessionId, params)
-      );
-      const now = /* @__PURE__ */ new Date();
-      const agentInfo = connection.getAgentInfo();
-      const { modelId, modelName, availableModels } = resolveModelState(
-        response.models
-      );
-      const { modeId, modeName, availableModes } = resolveModeState(
-        response.modes
-      );
-      const record = {
-        sessionId,
-        title: `Resumed Session`,
-        backendId: backend.id,
-        backendLabel: backend.label,
-        connection,
-        createdAt: now,
-        updatedAt: now,
-        cwd,
-        agentName: agentInfo?.title ?? agentInfo?.name,
-        modelId,
-        modelName,
-        modeId,
-        modeName,
-        availableModes,
-        availableModels,
-        availableCommands: void 0
-      };
-      this.setupSessionSubscriptions(record);
-      this.sessions.set(sessionId, record);
-      const summary = this.buildSummary(record);
-      this.emitSessionsChanged({
-        added: [summary],
-        updated: [],
-        removed: []
-      });
-      logger.info({ sessionId, backendId: backend.id }, "session_resumed");
-      return summary;
-    } catch (error) {
-      await connection.disconnect();
-      throw error;
     }
   }
   /**
    * Set up event subscriptions for a session record.
    */
-  setupSessionSubscriptions(record) {
+  setupSessionSubscriptions(record, options) {
     const { sessionId, connection } = record;
-    record.unsubscribe = connection.onSessionUpdate(
-      (notification) => {
-        this.touchSession(sessionId);
-        this.sessionUpdateEmitter.emit("update", notification);
-        const update = notification.update;
-        if (update.sessionUpdate === "current_mode_update") {
-          record.modeId = update.currentModeId;
-          record.modeName = record.availableModes?.find(
-            (mode) => mode.id === update.currentModeId
-          )?.name ?? record.modeName;
-          return;
-        }
-        if (update.sessionUpdate === "session_info_update") {
-          if (typeof update.title === "string") {
-            record.title = update.title;
-          }
-          if (typeof update.updatedAt === "string") {
-            record.updatedAt = new Date(update.updatedAt);
-          }
-        }
-        if (update.sessionUpdate === "available_commands_update") {
-          if (update.availableCommands) {
-            record.availableCommands = update.availableCommands;
-          }
+    if (!options?.skipSessionUpdates) {
+      record.unsubscribe = connection.onSessionUpdate(
+        (notification) => {
+          record.updatedAt = /* @__PURE__ */ new Date();
+          this.sessionUpdateEmitter.emit("update", notification);
+          this.applySessionUpdateToRecord(record, notification);
         }
-      }
-    );
+      );
+    }
     record.unsubscribeTerminal = connection.onTerminalOutput((event) => {
       this.terminalOutputEmitter.emit("output", event);
     });
@@ -1637,6 +1624,7 @@ var SessionManager = class {
           sessionId,
           error: status.error
         });
+        this.emitSessionDetached(sessionId, "agent_exit");
       }
     });
   }
@@ -1647,7 +1635,6 @@ var SessionManager = class {
       title: record.title,
       backendId: record.backendId,
       backendLabel: record.backendLabel,
-      state: status.state,
       error: status.error,
       pid: status.pid,
       createdAt: record.createdAt.toISOString(),
@@ -1667,7 +1654,7 @@ var SessionManager = class {
 
 // src/daemon/socket-client.ts
 import { EventEmitter as EventEmitter3 } from "events";
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import { homedir } from "os";
 import path4 from "path";
 import ignore from "ignore";
@@ -1692,7 +1679,7 @@ var loadGitignore = async (rootPath) => {
   const ig = ignore().add(DEFAULT_IGNORES);
   try {
     const gitignorePath = path4.join(rootPath, ".gitignore");
-    const content = await fs3.readFile(gitignorePath, "utf8");
+    const content = await fs4.readFile(gitignorePath, "utf8");
     ig.add(content);
   } catch {
   }
@@ -1722,14 +1709,14 @@ var resolveImageMimeType = (filePath) => {
   }
 };
 var readDirectoryEntries = async (dirPath) => {
-  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs4.readdir(dirPath, { withFileTypes: true });
   const resolvedEntries = await Promise.all(
     entries.map(async (entry) => {
       const entryPath = path4.join(dirPath, entry.name);
       let isDirectory = entry.isDirectory();
       if (!isDirectory && entry.isSymbolicLink()) {
         try {
-          const stats = await fs3.stat(entryPath);
+          const stats = await fs4.stat(entryPath);
           isDirectory = stats.isDirectory();
         } catch {
         }
@@ -1813,14 +1800,24 @@ var SocketClient = class extends EventEmitter3 {
     this.socket.on("cli:registered", async (info) => {
       logger.info({ machineId: info.machineId }, "gateway_registered");
       try {
-        const { sessions, capabilities } = await this.options.sessionManager.discoverSessions();
-        if (sessions.length > 0) {
-          this.socket.emit("sessions:discovered", { sessions, capabilities });
-          logger.info(
-            { count: sessions.length, capabilities },
-            "historical_sessions_discovered"
-          );
-        }
+        let cursor;
+        let page = 0;
+        do {
+          const { sessions, capabilities, nextCursor } = await this.options.sessionManager.discoverSessions({ cursor });
+          cursor = nextCursor;
+          if (sessions.length > 0) {
+            this.socket.emit("sessions:discovered", {
+              sessions,
+              capabilities,
+              nextCursor
+            });
+            logger.info(
+              { count: sessions.length, capabilities, page },
+              "historical_sessions_discovered"
+            );
+          }
+          page += 1;
+        } while (cursor);
       } catch (error) {
         logger.warn({ err: error }, "session_discovery_failed");
       }
@@ -2144,7 +2141,7 @@ var SocketClient = class extends EventEmitter3 {
         const resolved = path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath);
         const mimeType = resolveImageMimeType(resolved);
         if (mimeType) {
-          const buffer = await fs3.readFile(resolved);
+          const buffer = await fs4.readFile(resolved);
           const preview2 = {
             path: resolved,
             previewType: "image",
@@ -2154,7 +2151,7 @@ var SocketClient = class extends EventEmitter3 {
           this.sendRpcResponse(request.requestId, preview2);
           return;
         }
-        const content = await fs3.readFile(resolved, "utf8");
+        const content = await fs4.readFile(resolved, "utf8");
         const preview = {
           path: resolved,
           previewType: "code",
@@ -2203,14 +2200,15 @@ var SocketClient = class extends EventEmitter3 {
     });
     this.socket.on("rpc:sessions:discover", async (request) => {
       try {
-        const { cwd, backendId } = request.params;
+        const { cwd, backendId, cursor } = request.params;
         logger.info(
-          { requestId: request.requestId, cwd, backendId },
+          { requestId: request.requestId, cwd, backendId, cursor },
           "rpc_sessions_discover"
         );
         const result = await sessionManager.discoverSessions({
           cwd,
-          backendId
+          backendId,
+          cursor
         });
         this.sendRpcResponse(request.requestId, result);
       } catch (error) {
@@ -2245,27 +2243,6 @@ var SocketClient = class extends EventEmitter3 {
         this.sendRpcError(request.requestId, error);
       }
     });
-    this.socket.on("rpc:session:resume", async (request) => {
-      try {
-        const { sessionId, cwd } = request.params;
-        logger.info(
-          { requestId: request.requestId, sessionId, cwd },
-          "rpc_session_resume"
-        );
-        const session = await sessionManager.resumeSession(sessionId, cwd);
-        this.sendRpcResponse(request.requestId, session);
-      } catch (error) {
-        logger.error(
-          {
-            err: error,
-            requestId: request.requestId,
-            sessionId: request.params.sessionId
-          },
-          "rpc_session_resume_error"
-        );
-        this.sendRpcError(request.requestId, error);
-      }
-    });
   }
   setupSessionManagerListeners() {
     const { sessionManager } = this.options;
@@ -2310,6 +2287,16 @@ var SocketClient = class extends EventEmitter3 {
         this.socket.emit("sessions:changed", payload);
       }
     });
+    sessionManager.onSessionAttached((payload) => {
+      if (this.connected) {
+        this.socket.emit("session:attached", payload);
+      }
+    });
+    sessionManager.onSessionDetached((payload) => {
+      if (this.connected) {
+        this.socket.emit("session:detached", payload);
+      }
+    });
   }
   async listSessionResources(rootPath) {
     const ig = await loadGitignore(rootPath);
@@ -2324,7 +2311,7 @@ var SocketClient = class extends EventEmitter3 {
     if (collected.length >= MAX_RESOURCE_FILES) {
       return collected;
     }
-    const entries = await fs3.readdir(rootPath, { withFileTypes: true });
+    const entries = await fs4.readdir(rootPath, { withFileTypes: true });
     for (const entry of entries) {
       if (collected.length >= MAX_RESOURCE_FILES) {
         break;
@@ -2424,12 +2411,12 @@ var DaemonManager = class {
     this.config = config;
   }
   async ensureHomeDirectory() {
-    await fs4.mkdir(this.config.homePath, { recursive: true });
-    await fs4.mkdir(this.config.logPath, { recursive: true });
+    await fs5.mkdir(this.config.homePath, { recursive: true });
+    await fs5.mkdir(this.config.logPath, { recursive: true });
   }
   async getPid() {
     try {
-      const content = await fs4.readFile(this.config.pidFile, "utf8");
+      const content = await fs5.readFile(this.config.pidFile, "utf8");
       const pid = Number.parseInt(content.trim(), 10);
       if (Number.isNaN(pid)) {
         return null;
@@ -2446,11 +2433,11 @@ var DaemonManager = class {
     }
   }
   async writePidFile(pid) {
-    await fs4.writeFile(this.config.pidFile, String(pid), "utf8");
+    await fs5.writeFile(this.config.pidFile, String(pid), "utf8");
   }
   async removePidFile() {
     try {
-      await fs4.unlink(this.config.pidFile);
+      await fs5.unlink(this.config.pidFile);
     } catch {
     }
   }
@@ -2535,7 +2522,7 @@ var DaemonManager = class {
       logger.error("daemon_spawn_failed");
       throw new Error("Failed to spawn daemon process");
     }
-    const logStream = await fs4.open(logFile, "a");
+    const logStream = await fs5.open(logFile, "a");
     const fileHandle = logStream;
     child.stdout?.on("data", (data) => {
       fileHandle.write(`[stdout] ${data.toString()}`).catch(() => {
@@ -2611,7 +2598,7 @@ var DaemonManager = class {
     });
   }
   async logs(options) {
-    const files = await fs4.readdir(this.config.logPath);
+    const files = await fs5.readdir(this.config.logPath);
     const logFiles = files.filter((f) => f.endsWith("-daemon.log")).sort().reverse();
     if (logFiles.length === 0) {
       logger.warn("daemon_logs_empty");
@@ -2630,7 +2617,7 @@ var DaemonManager = class {
         tail.on("close", () => resolve());
       });
     } else {
-      const content = await fs4.readFile(latestLog, "utf8");
+      const content = await fs5.readFile(latestLog, "utf8");
       const lines = content.split("\n");
       const count = options?.lines ?? 50;
       console.log(lines.slice(-count).join("\n"));