clawmatrix 0.4.1 → 0.5.0

package/src/acp-proxy.ts

@@ -44,6 +44,7 @@ import type {
   AcpUnsubscribeRequest,
   AcpSessionNotify,
 } from "./types.ts";
+import { nanoid } from "nanoid";
 import { TaskActivityBroadcaster } from "./task-activity.ts";
 
 /** Extract a human-readable message from any thrown value (Error, JSON-RPC error object, etc.) */
@@ -146,7 +147,8 @@ export class AcpProxy {
   private maxSessions: number;
   private permissionMode: AcpPermissionMode;
   private taskActivity: TaskActivityBroadcaster;
-
+  /** Callback for file write attribution (set by ClusterRuntime). */
+  onToolWrite: ((filePath: string, agentId: string) => void) | null = null;
   // Receiver: active sessions (ACP or native OpenClaw)
   private sessions = new Map<string, AnySession>();
   // Requester: pending requests
@@ -176,8 +178,11 @@ export class AcpProxy {
   private daemonStarting = new Map<string, Promise<AgentDaemon>>();
   // In-flight resume operations: prevents concurrent resumes for same acpSessionId
   private resumeInFlight = new Map<string, Promise<AcpSession>>();
-  // Sessions explicitly closed by users — excluded from disk session list
+  // Sessions explicitly closed by users — excluded from disk session list.
+  // Falls back to in-memory Set when Store is not available.
   private closedSessionIds = new Set<string>();
+  /** Optional SQLite store for persistent closedSessionIds (survives restarts). */
+  store: import("./store.ts").Store | null = null;
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, openclawConfig?: Record<string, unknown>, gatewayInfo?: GatewayInfo) {
     this.config = config;
@@ -537,7 +542,7 @@ export class AcpProxy {
     targetNodeId: string,
     sessionId: string,
   ): Promise<AcpCloseResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -577,7 +582,7 @@ export class AcpProxy {
     targetNodeId: string,
     options?: { agent?: string; cwd?: string },
   ): Promise<AcpListResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -619,7 +624,7 @@ export class AcpProxy {
     acpSessionId: string,
     cwd: string,
   ): Promise<AcpResumeResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -659,7 +664,7 @@ export class AcpProxy {
     targetNodeId: string,
     sessionId: string,
   ): Promise<AcpCancelResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -697,7 +702,7 @@ export class AcpProxy {
     sessionId: string,
     modeId: string,
   ): Promise<AcpSetModeResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -734,7 +739,7 @@ export class AcpProxy {
     targetNodeId: string,
     sessionId: string,
   ): Promise<AcpGetModesResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -933,7 +938,7 @@ export class AcpProxy {
             // Re-create native session
             debug("acp", `Native session "${resolvedSessionId}" not found, re-creating with key from cwd`);
             const sessionKey = cwd ?? resolvedSessionId;
-            const newId = `native-${crypto.randomUUID()}`;
+            const newId = `native-${nanoid()}`;
             const nativeSession: NativeSession = {
               kind: "native", sessionId: newId, agent, sessionKey,
               lastActiveAt: Date.now(), from, prompting: false, abortController: null,
@@ -959,13 +964,16 @@ export class AcpProxy {
           await this.runPrompt(id, from, session, task, images);
         }
       } else {
-        // Enforce concurrent session limit
+        // Enforce concurrent session limit — evict oldest idle session if at capacity
         if (this.maxSessions > 0 && this.sessions.size >= this.maxSessions && mode === "persistent") {
-          this.sendResponse(id, from, {
-            success: false,
-            error: `Max concurrent sessions reached (${this.maxSessions})`,
-          });
-          return;
+          const evicted = this.evictOldestIdleSession();
+          if (!evicted) {
+            this.sendResponse(id, from, {
+              success: false,
+              error: `Max concurrent sessions reached (${this.maxSessions})`,
+            });
+            return;
+          }
         }
 
         if (this.isAcpAgent(agent)) {
@@ -1010,8 +1018,8 @@ export class AcpProxy {
             this.sendResponse(id, from, { success: false, error: "Gateway info not available for native sessions" });
             return;
           }
-          const sessionKey = cwd ?? `agent:main:clawmatrix:${crypto.randomUUID()}`;
-          const newId = `native-${crypto.randomUUID()}`;
+          const sessionKey = cwd ?? `agent:main:clawmatrix:${nanoid()}`;
+          const newId = `native-${nanoid()}`;
           const nativeSession: NativeSession = {
             kind: "native", sessionId: newId, agent, sessionKey,
             lastActiveAt: Date.now(), from, prompting: false, abortController: null,
@@ -1076,8 +1084,10 @@ export class AcpProxy {
 
     // Mark session as closed so it won't reappear from disk scan
     const acpSid = session.kind === "acp" ? session.acpSessionId : undefined;
-    if (acpSid) this.closedSessionIds.add(acpSid);
+    const now = Date.now();
+    if (acpSid) { this.closedSessionIds.add(acpSid); this.store?.insertClosedSession(acpSid, now); }
     this.closedSessionIds.add(resolvedId);
+    this.store?.insertClosedSession(resolvedId, now);
 
     // Physical deletion: only OpenClaw sessions can be safely deleted from disk.
     // Claude Code and Codex don't expose a deleteSession API, and their index files
@@ -1137,7 +1147,7 @@ export class AcpProxy {
           if (payload.agent && s.agent !== payload.agent) return false;
           if (clawSessions.some((cs) => cs.sessionId === s.sessionId)) return false;
           if (activeAcpSessionIds.has(s.sessionId)) return false;
-          if (this.closedSessionIds.has(s.sessionId)) return false;
+          if (this.closedSessionIds.has(s.sessionId) || this.store?.isSessionClosed(s.sessionId)) return false;
           return true;
         })
         .map((s) => ({ ...s, status: "idle" as const }));
@@ -1185,14 +1195,17 @@ export class AcpProxy {
         }
       }
 
-      // Enforce concurrent session limit
+      // Enforce concurrent session limit — evict oldest idle session if at capacity
       if (this.maxSessions > 0 && this.sessions.size >= this.maxSessions) {
-        this.peerManager.sendTo(from, {
-          type: "acp_resume_res", id, from: this.config.nodeId, to: from,
-          timestamp: Date.now(),
-          payload: { success: false, error: `Max concurrent sessions reached (${this.maxSessions})` },
-        } satisfies AcpResumeResponse);
-        return;
+        const evicted = this.evictOldestIdleSession();
+        if (!evicted) {
+          this.peerManager.sendTo(from, {
+            type: "acp_resume_res", id, from: this.config.nodeId, to: from,
+            timestamp: Date.now(),
+            payload: { success: false, error: `Max concurrent sessions reached (${this.maxSessions})` },
+          } satisfies AcpResumeResponse);
+          return;
+        }
       }
 
       if (this.isAcpAgent(agent)) {
@@ -1445,7 +1458,7 @@ export class AcpProxy {
     configId: string,
     value: string | boolean,
   ): Promise<AcpSetConfigResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -1484,6 +1497,24 @@ export class AcpProxy {
     const { id, from, payload } = frame;
     const { sessionId, limit = 200 } = payload;
 
+    // Register requester as session watcher so they receive real-time transcript updates.
+    // Resolve to ClawMatrix session ID for watcher registration (same logic as subscribe).
+    let watcherKey = sessionId;
+    let acpSidForWatch = sessionId;
+    if (this.sessions.has(sessionId)) {
+      const s = this.sessions.get(sessionId)!;
+      acpSidForWatch = s.kind === "acp" ? s.acpSessionId : sessionId;
+    } else {
+      for (const [sid, s] of this.sessions) {
+        if (s.kind === "acp" && s.acpSessionId === sessionId) {
+          watcherKey = sid;
+          break;
+        }
+      }
+    }
+    this.addSessionWatcher(watcherKey, from);
+    this.startTranscriptWatcher(watcherKey, acpSidForWatch).catch(() => {});
+
     try {
       const transcriptPath = await this.findTranscriptPath(sessionId);
       if (!transcriptPath) {
@@ -1529,7 +1560,7 @@ export class AcpProxy {
     sessionId: string,
     limit?: number,
   ): Promise<ChatHistoryResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -1752,7 +1783,7 @@ export class AcpProxy {
 
     const session: AcpSession = {
       kind: "acp",
-      sessionId: crypto.randomUUID(),
+      sessionId: nanoid(),
       agent,
       acpSessionId: response.sessionId,
       conn: daemon.conn,
@@ -1878,7 +1909,7 @@ export class AcpProxy {
     if (reused) {
       reused.from = from;
       reused.lastActiveAt = Date.now();
-      reused.sessionId = crypto.randomUUID();
+      reused.sessionId = nanoid();
       this.monitorProcess(reused);
       return reused;
     }
@@ -1888,7 +1919,7 @@ export class AcpProxy {
     if (warm) {
       warm.from = from;
       warm.lastActiveAt = Date.now();
-      warm.sessionId = crypto.randomUUID();
+      warm.sessionId = nanoid();
       this.monitorProcess(warm);
       this.schedulePrewarm(agent, effectiveCwd);
       return warm;
@@ -1973,6 +2004,13 @@ export class AcpProxy {
             const kind = (update as { kind?: string }).kind;
             const toolName = title || toolCallId || "unknown";
             cb?.(`\n[tool_call: ${toolName}]\n`, updateType, { title, toolCallId, kind });
+            // Track file write attribution for knowledge-sync
+            if (title && this.onToolWrite) {
+              const writeMatch = title.match(/^(?:Write|Edit|Create)\s+(.+)/i);
+              if (writeMatch) {
+                this.onToolWrite(writeMatch[1].trim(), params.agent);
+              }
+            }
           } else if (updateType === "tool_call_update") {
             const status = (update as { status?: string }).status;
             // Extract tool output content from completed tool calls
@@ -2107,7 +2145,7 @@ export class AcpProxy {
 
     const session: AcpSession = {
       kind: "acp",
-      sessionId: crypto.randomUUID(),
+      sessionId: nanoid(),
       agent,
       acpSessionId: response.sessionId,
       conn,
@@ -2162,6 +2200,7 @@ export class AcpProxy {
     let streamChunkCount = 0;
     session.setStreamCallback((delta, event, data) => {
       streamChunkCount++;
+
       if (streamChunkCount <= 3 || streamChunkCount % 50 === 0) {
         debug("acp", `stream chunk #${streamChunkCount}: event=${event ?? "text"} delta=${delta.slice(0, 40)} sessionId=${session.sessionId.slice(0, 8)}`);
       }
@@ -2598,7 +2637,7 @@ export class AcpProxy {
       onStream?: (delta: string) => void;
     },
   ): Promise<AcpTaskResponse["payload"]> {
-    const id = crypto.randomUUID();
+    const id = nanoid();
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -2690,6 +2729,26 @@ export class AcpProxy {
     }
   }
 
+  /**
+   * Evict the oldest non-prompting session to make room for a new one.
+   * Returns true if a session was evicted, false if all sessions are actively prompting.
+   */
+  private evictOldestIdleSession(): boolean {
+    let oldest: { id: string; session: AnySession } | null = null;
+    for (const [id, session] of this.sessions) {
+      if (session.prompting) continue; // never evict mid-prompt sessions
+      if (!oldest || session.lastActiveAt < oldest.session.lastActiveAt) {
+        oldest = { id, session };
+      }
+    }
+    if (!oldest) return false;
+    debug("acp", `evicting idle session ${oldest.id.slice(0, 8)} (lastActive=${new Date(oldest.session.lastActiveAt).toISOString()}) to make room`);
+    this.sessions.delete(oldest.id);
+    this.sessionWatchers.delete(oldest.id);
+    this.destroySession(oldest.session);
+    return true;
+  }
+
   private cleanupIdleSessions() {
     const now = Date.now();
     for (const [id, session] of this.sessions) {
@@ -2834,14 +2893,13 @@ export async function readAllSessionStoresFromDisk(): Promise<AcpSessionInfo[]>
       // Fresh cache — return immediately
       return sessionListCache.result;
     }
-    if (now < sessionListCache.staleAt) {
-      // Stale but within grace period — return stale data, refresh in background
-      refreshSessionListInBackground();
-      return sessionListCache.result;
-    }
+    // Stale cache — return stale data immediately, refresh in background
+    // Never block on disk I/O when we have any cached data
+    refreshSessionListInBackground();
+    return sessionListCache.result;
   }
 
-  // Cache miss or expired — fetch from disk and cache
+  // No cache at all — must fetch from disk synchronously
   const results = await fetchSessionListFromDisk();
   const ts = Date.now();
   sessionListCache = { result: results, expiresAt: ts + SESSION_LIST_CACHE_TTL, staleAt: ts + SESSION_LIST_STALE_TTL };
@@ -2935,10 +2993,25 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
 
     const ccResults: AcpSessionInfo[] = [];
     const existingIds = new Set(results.map((r) => r.sessionId));
-    // Stat transcript files in parallel to get more accurate mtime
+    // Build a sessionId → file path index from project dirs (one readdir per dir)
+    // instead of O(sessions × dirs) stat calls
     const claudeProjectsDir = join(homedir(), ".claude", "projects");
-    let projectDirs: string[] = [];
-    try { projectDirs = await readdir(claudeProjectsDir); } catch { /* no projects dir */ }
+    const sessionFileIndex = new Map<string, string>(); // sessionId → full path
+    try {
+      const projectDirs = await readdir(claudeProjectsDir);
+      await Promise.all(
+        projectDirs.map(async (dir) => {
+          try {
+            const files = await readdir(join(claudeProjectsDir, dir));
+            for (const f of files) {
+              if (f.endsWith(".jsonl")) {
+                sessionFileIndex.set(f.slice(0, -6), join(claudeProjectsDir, dir, f));
+              }
+            }
+          } catch { /* unreadable dir */ }
+        }),
+      );
+    } catch { /* no projects dir */ }
 
     const pendingEntries: { sessionId: string; info: { title: string; updatedAt: number; cwd: string } }[] = [];
     for (const [sessionId, info] of sessions) {
@@ -2947,16 +3020,15 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
       pendingEntries.push({ sessionId, info });
     }
 
-    // For each session, try to find its transcript file and stat it
+    // Stat only matching files (O(matched) instead of O(sessions × dirs))
     const mtimeResults = await Promise.all(
       pendingEntries.map(async ({ sessionId }) => {
-        for (const dir of projectDirs) {
-          try {
-            const s = await fsStat(join(claudeProjectsDir, dir, `${sessionId}.jsonl`));
-            return s.mtimeMs;
-          } catch { /* not in this project dir */ }
-        }
-        return null;
+        const filePath = sessionFileIndex.get(sessionId);
+        if (!filePath) return null;
+        try {
+          const s = await fsStat(filePath);
+          return s.mtimeMs;
+        } catch { return null; }
       }),
     );