@mobvibe/cli 0.1.4 → 0.1.7

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 path5 from "path";
+import fs5 from "fs/promises";
+import path6 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, force = false) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+    if (record.isAttached && !force) {
+      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, true);
       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) {
@@ -1524,110 +1581,81 @@ var SessionManager = class {
     }
   }
   /**
-   * 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
+   * Reload a historical session from the ACP agent.
+   * Replays session history even if the session is already loaded.
    */
-  async resumeSession(sessionId, cwd, backendId) {
+  async reloadSession(sessionId, cwd, backendId) {
     const existing = this.sessions.get(sessionId);
-    if (existing) {
-      return this.buildSummary(existing);
+    if (!existing) {
+      return this.loadSession(sessionId, cwd, backendId);
     }
-    const backend = this.resolveBackend(backendId);
-    const connection = new AcpConnection({
-      backend,
-      client: {
-        name: this.config.clientName,
-        version: this.config.clientVersion
-      }
+    if (!existing.connection.supportsSessionLoad()) {
+      throw createCapabilityNotSupportedError(
+        "Agent does not support session loading"
+      );
+    }
+    const response = await existing.connection.loadSession(sessionId, cwd);
+    const { modelId, modelName, availableModels } = resolveModelState(
+      response.models
+    );
+    const { modeId, modeName, availableModes } = resolveModeState(
+      response.modes
+    );
+    const agentInfo = existing.connection.getAgentInfo();
+    existing.cwd = cwd;
+    existing.agentName = agentInfo?.title ?? agentInfo?.name ?? existing.agentName;
+    existing.modelId = modelId;
+    existing.modelName = modelName;
+    existing.availableModels = availableModels;
+    existing.modeId = modeId;
+    existing.modeName = modeName;
+    existing.availableModes = availableModes;
+    existing.updatedAt = /* @__PURE__ */ new Date();
+    const summary = this.buildSummary(existing);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [summary],
+      removed: []
     });
-    try {
-      await connection.connect();
-      if (!connection.supportsSessionResume()) {
-        throw createCapabilityNotSupportedError(
-          "Agent does not support session resuming"
-        );
+    this.emitSessionAttached(sessionId, true);
+    logger.info({ sessionId, backendId }, "session_reloaded");
+    return summary;
+  }
+  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;
+    }
+    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;
       }
-      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 +1665,7 @@ var SessionManager = class {
           sessionId,
           error: status.error
         });
+        this.emitSessionDetached(sessionId, "agent_exit");
       }
     });
   }
@@ -1647,7 +1676,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,11 +1695,189 @@ 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 path5 from "path";
 import ignore from "ignore";
 import { io } from "socket.io-client";
+
+// src/lib/git-utils.ts
+import { exec } from "child_process";
+import path4 from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var MAX_BUFFER = 10 * 1024 * 1024;
+async function isGitRepo(cwd) {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitBranch(cwd) {
+  try {
+    const { stdout } = await execAsync("git branch --show-current", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    const branch = stdout.trim();
+    if (branch) {
+      return branch;
+    }
+    const { stdout: hashOut } = await execAsync("git rev-parse --short HEAD", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return hashOut.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseGitStatus(output) {
+  const files = [];
+  const lines = output.split("\n").filter((line) => line.length > 0);
+  for (const line of lines) {
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const filePath = line.slice(3).split(" -> ").pop()?.trim();
+    if (!filePath) {
+      continue;
+    }
+    let status;
+    if (indexStatus === "?" || workTreeStatus === "?") {
+      status = "?";
+    } else if (indexStatus === "!" || workTreeStatus === "!") {
+      status = "!";
+    } else if (indexStatus === "A" || workTreeStatus === "A") {
+      status = "A";
+    } else if (indexStatus === "D" || workTreeStatus === "D") {
+      status = "D";
+    } else if (indexStatus === "R" || workTreeStatus === "R") {
+      status = "R";
+    } else if (indexStatus === "C" || workTreeStatus === "C") {
+      status = "C";
+    } else if (indexStatus === "U" || workTreeStatus === "U") {
+      status = "U";
+    } else if (indexStatus === "M" || workTreeStatus === "M" || indexStatus !== " " || workTreeStatus !== " ") {
+      status = "M";
+    } else {
+      continue;
+    }
+    files.push({ path: filePath, status });
+  }
+  return files;
+}
+async function getGitStatus(cwd) {
+  try {
+    const { stdout } = await execAsync("git status --porcelain=v1", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return parseGitStatus(stdout);
+  } catch {
+    return [];
+  }
+}
+function aggregateDirStatus(files) {
+  const dirStatus = {};
+  const statusPriority = {
+    A: 7,
+    D: 6,
+    M: 5,
+    R: 4,
+    C: 3,
+    U: 2,
+    "?": 1,
+    "!": 0
+  };
+  for (const file of files) {
+    const parts = file.path.split("/");
+    let currentPath = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      currentPath = currentPath ? `${currentPath}/${parts[i]}` : parts[i];
+      const existing = dirStatus[currentPath];
+      if (!existing || statusPriority[file.status] > statusPriority[existing]) {
+        dirStatus[currentPath] = file.status;
+      }
+    }
+  }
+  return dirStatus;
+}
+function parseDiffOutput(diffOutput) {
+  const addedLines = [];
+  const modifiedLines = [];
+  const deletedLines = [];
+  const lines = diffOutput.split("\n");
+  let currentLine = 0;
+  let inHunk = false;
+  let pendingDeletionLine = 0;
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/);
+    if (hunkMatch) {
+      currentLine = Number.parseInt(hunkMatch[1], 10);
+      inHunk = true;
+      pendingDeletionLine = 0;
+      continue;
+    }
+    if (!inHunk) {
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      addedLines.push(currentLine);
+      currentLine++;
+      pendingDeletionLine = 0;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      if (pendingDeletionLine === 0) {
+        pendingDeletionLine = currentLine;
+      }
+      const deletionPos = Math.max(1, currentLine);
+      if (!deletedLines.includes(deletionPos)) {
+        deletedLines.push(deletionPos);
+      }
+    } else if (!line.startsWith("\\")) {
+      currentLine++;
+      pendingDeletionLine = 0;
+    }
+  }
+  return { addedLines, modifiedLines, deletedLines };
+}
+async function getFileDiff(cwd, filePath) {
+  try {
+    const relativePath = path4.isAbsolute(filePath) ? path4.relative(cwd, filePath) : filePath;
+    const { stdout } = await execAsync(`git diff HEAD -- "${relativePath}"`, {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    if (!stdout.trim()) {
+      const { stdout: statusOut } = await execAsync(
+        `git status --porcelain=v1 -- "${relativePath}"`,
+        { cwd, maxBuffer: MAX_BUFFER }
+      );
+      if (statusOut.startsWith("?") || statusOut.startsWith("A")) {
+        const { stdout: wcOut } = await execAsync(`wc -l < "${relativePath}"`, {
+          cwd,
+          maxBuffer: MAX_BUFFER
+        });
+        const lineCount = Number.parseInt(wcOut.trim(), 10) || 0;
+        return {
+          addedLines: Array.from({ length: lineCount }, (_, i) => i + 1),
+          modifiedLines: [],
+          deletedLines: []
+        };
+      }
+      return { addedLines: [], modifiedLines: [], deletedLines: [] };
+    }
+    return parseDiffOutput(stdout);
+  } catch {
+    return { addedLines: [], modifiedLines: [], deletedLines: [] };
+  }
+}
+
+// src/daemon/socket-client.ts
 var SESSION_ROOT_NAME = "Working Directory";
 var MAX_RESOURCE_FILES = 2e3;
 var DEFAULT_IGNORES = [
@@ -1691,15 +1897,15 @@ var DEFAULT_IGNORES = [
 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 gitignorePath = path5.join(rootPath, ".gitignore");
+    const content = await fs4.readFile(gitignorePath, "utf8");
     ig.add(content);
   } catch {
   }
   return ig;
 };
 var resolveImageMimeType = (filePath) => {
-  const extension = path4.extname(filePath).toLowerCase();
+  const extension = path5.extname(filePath).toLowerCase();
   switch (extension) {
     case ".apng":
       return "image/apng";
@@ -1722,14 +1928,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);
+      const entryPath = path5.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 +2019,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");
       }
@@ -2115,7 +2331,7 @@ var SocketClient = class extends EventEmitter3 {
         if (!record || !record.cwd) {
           throw new Error("Session not found or no working directory");
         }
-        const resolved = requestPath ? path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath) : record.cwd;
+        const resolved = requestPath ? path5.isAbsolute(requestPath) ? requestPath : path5.join(record.cwd, requestPath) : record.cwd;
         const entries = await readDirectoryEntries(resolved);
         this.sendRpcResponse(request.requestId, { path: resolved, entries });
       } catch (error) {
@@ -2141,10 +2357,10 @@ var SocketClient = class extends EventEmitter3 {
         if (!record || !record.cwd) {
           throw new Error("Session not found or no working directory");
         }
-        const resolved = path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath);
+        const resolved = path5.isAbsolute(requestPath) ? requestPath : path5.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 +2370,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 +2419,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,14 +2462,14 @@ var SocketClient = class extends EventEmitter3 {
         this.sendRpcError(request.requestId, error);
       }
     });
-    this.socket.on("rpc:session:resume", async (request) => {
+    this.socket.on("rpc:session:reload", async (request) => {
       try {
         const { sessionId, cwd } = request.params;
         logger.info(
           { requestId: request.requestId, sessionId, cwd },
-          "rpc_session_resume"
+          "rpc_session_reload"
         );
-        const session = await sessionManager.resumeSession(sessionId, cwd);
+        const session = await sessionManager.reloadSession(sessionId, cwd);
         this.sendRpcResponse(request.requestId, session);
       } catch (error) {
         logger.error(
@@ -2261,7 +2478,93 @@ var SocketClient = class extends EventEmitter3 {
             requestId: request.requestId,
             sessionId: request.params.sessionId
           },
-          "rpc_session_resume_error"
+          "rpc_session_reload_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:git:status", async (request) => {
+      try {
+        const { sessionId } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId },
+          "rpc_git_status"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const isRepo = await isGitRepo(record.cwd);
+        if (!isRepo) {
+          this.sendRpcResponse(request.requestId, {
+            isGitRepo: false,
+            files: [],
+            dirStatus: {}
+          });
+          return;
+        }
+        const [branch, files] = await Promise.all([
+          getGitBranch(record.cwd),
+          getGitStatus(record.cwd)
+        ]);
+        const dirStatus = aggregateDirStatus(files);
+        this.sendRpcResponse(request.requestId, {
+          isGitRepo: true,
+          branch,
+          files,
+          dirStatus
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_git_status_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:git:fileDiff", async (request) => {
+      try {
+        const { sessionId, path: filePath } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId, path: filePath },
+          "rpc_git_file_diff"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const isRepo = await isGitRepo(record.cwd);
+        if (!isRepo) {
+          this.sendRpcResponse(request.requestId, {
+            isGitRepo: false,
+            path: filePath,
+            addedLines: [],
+            modifiedLines: []
+          });
+          return;
+        }
+        const { addedLines, modifiedLines } = await getFileDiff(
+          record.cwd,
+          filePath
+        );
+        this.sendRpcResponse(request.requestId, {
+          isGitRepo: true,
+          path: filePath,
+          addedLines,
+          modifiedLines
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_git_file_diff_error"
         );
         this.sendRpcError(request.requestId, error);
       }
@@ -2310,13 +2613,23 @@ 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);
     const allFiles = await this.listAllFiles(rootPath, ig, rootPath, []);
     return allFiles.map((filePath) => ({
-      name: path4.basename(filePath),
-      relativePath: path4.relative(rootPath, filePath),
+      name: path5.basename(filePath),
+      relativePath: path5.relative(rootPath, filePath),
       path: filePath
     }));
   }
@@ -2324,13 +2637,13 @@ 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;
       }
-      const entryPath = path4.join(rootPath, entry.name);
-      const relativePath = path4.relative(baseDir, entryPath);
+      const entryPath = path5.join(rootPath, entry.name);
+      const relativePath = path5.relative(baseDir, entryPath);
       const checkPath = entry.isDirectory() ? `${relativePath}/` : relativePath;
       if (ig.ignores(checkPath)) {
         continue;
@@ -2424,12 +2737,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 +2759,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 {
     }
   }
@@ -2517,7 +2830,7 @@ var DaemonManager = class {
     }
   }
   async spawnBackground() {
-    const logFile = path5.join(
+    const logFile = path6.join(
       this.config.logPath,
       `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-daemon.log`
     );
@@ -2535,7 +2848,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,14 +2924,14 @@ 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");
       console.log("No log files found");
       return;
     }
-    const latestLog = path5.join(this.config.logPath, logFiles[0]);
+    const latestLog = path6.join(this.config.logPath, logFiles[0]);
     logger.info({ logFile: latestLog }, "daemon_logs_latest");
     console.log(`Log file: ${latestLog}
 `);
@@ -2630,7 +2943,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"));