@wrongstack/acp 1.0.29 → 1.0.33

package/dist/agent.js

@@ -236,6 +236,10 @@ async function handleSessionNewOp(ctx, id, params) {
   }
   const skipped = [];
   const mcpServers = parseMcpServers(p.mcpServers, (reason) => skipped.push(reason));
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
   const sessionId = `sess_${ctx.allocId()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const state = {
@@ -286,6 +290,9 @@ async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
   if (!existing && sessionId && ctx.store) {
     const persisted = await ctx.store.load(sessionId);
     if (persisted) {
+      if (ctx.sessions.has(sessionId)) {
+        return handleSessionLoadOp(ctx, id, params, replayHistory);
+      }
       if (ctx.sessions.size >= ctx.maxSessions) {
         await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
         return false;
@@ -296,6 +303,13 @@ async function handleSessionLoadOp(ctx, id, params, replayHistory = true) {
       }
       const candidateCwd = loadCwd ?? persisted.cwd ?? ctx.defaultCwd;
       const restoredCwd = await resolveSessionCwd(candidateCwd) ?? ctx.defaultCwd;
+      if (ctx.sessions.has(sessionId)) {
+        return handleSessionLoadOp(ctx, id, params, replayHistory);
+      }
+      if (ctx.sessions.size >= ctx.maxSessions) {
+        await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+        return false;
+      }
       const restored = {
         id: sessionId,
         cwd: restoredCwd,
@@ -399,9 +413,17 @@ async function handleSessionForkOp(ctx, id, params) {
     }
     forkCwd = resolved;
   }
+  if (ctx.sessions.get(sourceId) !== source) {
+    await ctx.sendError(id, -32e3, `session not found: ${sourceId}`);
+    return false;
+  }
   const forkSkipped = [];
   const forkRequested = parseMcpServers(p.mcpServers, (reason) => forkSkipped.push(reason));
   const forkMcpServers = forkRequested.length > 0 ? forkRequested : source.mcpServers;
+  if (ctx.sessions.size >= ctx.maxSessions) {
+    await ctx.sendError(id, -32e3, `active session limit reached (${ctx.maxSessions})`);
+    return false;
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const sessionId = `sess_${ctx.allocId()}`;
   const forked = {
@@ -1511,20 +1533,24 @@ var ACPSessionStore = class {
     const tmp = `${target}.${process.pid}.${Date.now()}.${++this.writeSeq}.tmp`;
     let renamed = false;
     try {
-      await fsp2.writeFile(
-        tmp,
-        JSON.stringify({
-          id: state.id,
-          cwd: state.cwd,
-          modeId: state.modeId,
-          configOptions: state.configOptions,
-          createdAt: state.createdAt,
-          updatedAt: state.updatedAt,
-          title: state.title,
-          ...history && history.length > 0 ? { history } : {}
-        }),
-        "utf8"
-      );
+      const data = JSON.stringify({
+        id: state.id,
+        cwd: state.cwd,
+        modeId: state.modeId,
+        configOptions: state.configOptions,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        title: state.title,
+        ...history && history.length > 0 ? { history } : {}
+      });
+      try {
+        await fsp2.writeFile(tmp, data, "utf8");
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+        this.initialized = false;
+        await this.init();
+        await fsp2.writeFile(tmp, data, "utf8");
+      }
       await fsp2.rename(tmp, target);
       renamed = true;
     } finally {
@@ -1548,13 +1574,15 @@ var ACPSessionStore = class {
   }
   /** List all persisted sessions. */
   async list() {
-    const indexEntries = await this.readIndex();
-    if (indexEntries !== null) {
-      return indexEntries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-    }
-    const sessions = await this.scanForSessions();
-    void this.writeIndex(sessions).catch(() => void 0);
-    return sessions;
+    return this.withIndexLock(async () => {
+      const indexEntries = await this.readIndex();
+      if (indexEntries !== null) {
+        return indexEntries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+      }
+      const sessions = await this.scanForSessions();
+      await this.writeIndex(sessions).catch(() => void 0);
+      return sessions;
+    });
   }
   /**
    * Walk `<dir>` and parse every session file into `{id, updatedAt}`
@@ -1579,7 +1607,7 @@ var ACPSessionStore = class {
       try {
         const data = await fsp2.readFile(path2.join(this.dir, file), "utf8");
         const parsed = JSON.parse(data);
-        if (parsed.id) {
+        if (parsed && typeof parsed.id === "string" && parsed.id !== "" && (parsed.updatedAt === void 0 || typeof parsed.updatedAt === "string")) {
           sessions.push({ id: parsed.id, updatedAt: parsed.updatedAt ?? "" });
         }
       } catch {
@@ -1963,7 +1991,7 @@ function toACPInputSchema(src) {
   if (typeof s.maximum === "number") out.maximum = s.maximum;
   if (s.items) out.items = toACPInputSchema(s.items);
   if (s.properties && typeof s.properties === "object") {
-    const props = {};
+    const props = /* @__PURE__ */ Object.create(null);
     for (const [k, v] of Object.entries(s.properties)) {
       props[k] = toACPInputSchema(v);
     }
@@ -2319,6 +2347,7 @@ var WsBridgeTransport = class {
   receive(msg) {
     if (this.closed) return;
     for (const handler of [...this.handlers]) {
+      if (this.closed) break;
       try {
         handler(msg);
       } catch {

package/dist/client/acp-session-messages.d.ts

@@ -0,0 +1,24 @@
+import type { ACPMessage } from '../types/acp-messages.js';
+import { type ACPCallbackOptions, type ACPResponseSender } from './acp-session-callbacks.js';
+import type { ACPProgressEvent } from './acp-session-types.js';
+export interface AcpSessionMessagesHost {
+    sendResult: (id: string | number, result: unknown) => Promise<void>;
+    sendErrorResponse: (id: string | number, code: number, message: string) => Promise<void>;
+    promptCallbackAbort: AbortController | null;
+    callbackAbort: AbortController;
+    pending: Map<string | number, import('./acp-request-state.js').PendingRequest>;
+    sessionId: import('../types/acp-v1.js').SessionId | null;
+    scratch: import('./acp-session-updates.js').ACPSessionScratch;
+    emitProgress: (event: import('./acp-session-types.js').ACPProgressEvent) => void;
+    permissionPolicy: import('./permission.js').PermissionPolicy;
+    responseSender: () => import('./acp-session-callbacks.js').ACPResponseSender;
+    callbackOptions: () => import('./acp-session-callbacks.js').ACPCallbackOptions;
+    fileServer: import('./file-server.js').FileServer;
+    terminalServer: import('./terminal-server.js').TerminalServer;
+    progressHandler: import('./acp-session-types.js').ACPProgressHandler | null;
+}
+export declare function responseSender(this: AcpSessionMessagesHost): ACPResponseSender;
+export declare function callbackOptions(this: AcpSessionMessagesHost): ACPCallbackOptions;
+export declare function handleMessage(this: AcpSessionMessagesHost, msg: ACPMessage): void;
+export declare function emitProgress(this: AcpSessionMessagesHost, event: ACPProgressEvent): void;
+//# sourceMappingURL=acp-session-messages.d.ts.map

package/dist/client/acp-session.d.ts

@@ -139,5 +139,6 @@ export declare class ACPSession {
     private scratch;
     private resetScratch;
     private acpSessionAuthHost;
+    private acpSessionMessagesHost;
 }
 //# sourceMappingURL=acp-session.d.ts.map