@snowyroad/arp 0.3.5 → 0.3.6

package/dist/cli.js

@@ -1867,7 +1867,7 @@ var ActivityBeacon = class {
 // src/adapter.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { accessSync, constants, existsSync as existsSync2, statSync } from "fs";
-import { delimiter, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { delimiter, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 
 // src/acp/client.ts
 import { spawn } from "child_process";
@@ -1967,6 +1967,7 @@ var AcpClient = class {
   child = null;
   conn = null;
   _sessionId = null;
+  loadSupported = false;
   /**
    * The currently-running turn's reply accumulator. Set for the duration of one
    * turn so agent_message_chunk text lands in THIS turn's buffer only. Because
@@ -2075,7 +2076,7 @@ var AcpClient = class {
       }
     };
     this.conn = new ClientSideConnection(() => client, stream);
-    await this.guard(
+    const init = await this.guard(
       this.conn.initialize({
         protocolVersion: 1,
         clientCapabilities: {
@@ -2085,10 +2086,29 @@ var AcpClient = class {
         clientInfo: { name: "arp-bridge", version: "0.1.0" }
       })
     );
-    const session = await this.guard(
-      this.conn.newSession({ cwd: this.launch.cwd, mcpServers: [] })
-    );
-    this._sessionId = session.sessionId;
+    this.loadSupported = init.agentCapabilities?.loadSession === true;
+    const candidateId = this._sessionId ?? this.launch.session?.persistedId ?? null;
+    let liveId = null;
+    if (candidateId && this.loadSupported) {
+      try {
+        await this.guard(
+          this.conn.loadSession({ sessionId: candidateId, cwd: this.launch.cwd, mcpServers: [] })
+        );
+        liveId = candidateId;
+      } catch (err) {
+        console.warn(
+          `[arp-bridge] session/load failed; starting a fresh session: ${sanitizeForTty(String(err?.message ?? err))}`
+        );
+      }
+    }
+    if (!liveId) {
+      const session = await this.guard(
+        this.conn.newSession({ cwd: this.launch.cwd, mcpServers: [] })
+      );
+      liveId = session.sessionId;
+    }
+    this._sessionId = liveId;
+    this.launch.session?.save(liveId);
   }
   /**
    * Send one user turn. Resolves with the full assembled reply text once the
@@ -2189,6 +2209,45 @@ var AcpClient = class {
   }
 };
 
+// src/sessionStore.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, chmodSync as chmodSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function safe(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function sessionFilePath(dir, relayUrl, agentName, channelId) {
+  return join3(dir, "sessions", relayHostSegment(relayUrl), `${safe(agentName)}__${safe(channelId)}.json`);
+}
+function loadStoredSession(dir, relayUrl, agentName, channelId) {
+  const file = sessionFilePath(dir, relayUrl, agentName, channelId);
+  let raw;
+  try {
+    raw = readFileSync2(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const p = JSON.parse(raw);
+    if (typeof p.sessionId === "string" && p.sessionId.trim() !== "" && typeof p.cwd === "string" && p.cwd.trim() !== "") {
+      return { sessionId: p.sessionId, cwd: p.cwd };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveStoredSession(dir, relayUrl, agentName, channelId, rec) {
+  const file = sessionFilePath(dir, relayUrl, agentName, channelId);
+  mkdirSync2(dirname2(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync2(tmp, JSON.stringify(rec, null, 2) + "\n", { mode: 384 });
+  renameSync2(tmp, file);
+  try {
+    chmodSync2(file, 384);
+  } catch {
+  }
+}
+
 // src/adapter.ts
 function defaultToolPolicy() {
   return { mode: "readonly", configDirAbs: resolve2(configDir(process.env)) };
@@ -2205,9 +2264,9 @@ function pinned(pkg) {
 var npxBinaryAbs = null;
 function resolveNpxBinary() {
   if (npxBinaryAbs) return npxBinaryAbs;
-  const nodeDir = dirname2(process.execPath);
+  const nodeDir = dirname3(process.execPath);
   for (const name of ["npx", "npx.cmd"]) {
-    const candidate = join3(nodeDir, name);
+    const candidate = join4(nodeDir, name);
     if (existsSync2(candidate)) {
       npxBinaryAbs = candidate;
       return candidate;
@@ -2220,7 +2279,7 @@ function resolveNpxBinary() {
 function which(cmd, pathEnv = process.env.PATH ?? "") {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join3(dir, cmd);
+    const candidate = join4(dir, cmd);
     try {
       accessSync(candidate, constants.X_OK);
       if (statSync(candidate).isFile()) return resolve2(candidate);
@@ -2274,13 +2333,15 @@ var defaultAcpClientFactory = (launch) => new AcpClient(launch);
 var MAX_CONSECUTIVE_RESTARTS = 3;
 var RESTART_BACKOFF_MS = 250;
 var AcpAdapter = class {
-  constructor(agent, makeClient = defaultAcpClientFactory, backoffMs = RESTART_BACKOFF_MS, policy = defaultToolPolicy()) {
+  constructor(agent, makeClient = defaultAcpClientFactory, backoffMs = RESTART_BACKOFF_MS, policy = defaultToolPolicy(), session) {
     this.makeClient = makeClient;
     this.backoffMs = backoffMs;
+    this.session = session;
     this.launch = { ...launchSpecFor(agent), policy };
   }
   makeClient;
   backoffMs;
+  session;
   launch;
   // --- supervised live state (set in start()) ---
   client = null;
@@ -2294,7 +2355,17 @@ var AcpAdapter = class {
   /** Latched once the loop guard trips, so we stop trying (and stop retrying turns). */
   gaveUp = false;
   async start(_opts) {
-    this.client = this.makeClient(this.launch);
+    const rec = this.session?.load() ?? null;
+    const cwd = rec?.cwd ?? this.launch.cwd;
+    const launch = {
+      ...this.launch,
+      cwd,
+      session: this.session ? {
+        persistedId: rec?.sessionId ?? null,
+        save: (id) => this.session.save({ sessionId: id, cwd })
+      } : void 0
+    };
+    this.client = this.makeClient(launch);
     await this.client.start();
     return {
       submit: (text) => {
@@ -2520,14 +2591,23 @@ var ClaudeAdapter = class {
     };
   }
 };
-function createAdapter(cfg) {
+function createAdapter(cfg, channelId) {
   const policy = {
     mode: cfg.toolMode,
     configDirAbs: resolve2(configDir(process.env)),
     agentName: cfg.agentName
     // for the once-per-process "arp tools full <name>" denial hint
   };
-  return cfg.agentMode === "acp" ? new AcpAdapter(cfg.agent, void 0, void 0, policy) : new ClaudeAdapter(policy);
+  if (cfg.agentMode !== "acp") return new ClaudeAdapter(policy);
+  const session = channelId ? makeSessionPersistence(cfg, channelId) : void 0;
+  return new AcpAdapter(cfg.agent, void 0, void 0, policy, session);
+}
+function makeSessionPersistence(cfg, channelId) {
+  const dir = configDir(process.env);
+  return {
+    load: () => loadStoredSession(dir, cfg.relayWsUrl, cfg.agentName, channelId),
+    save: (rec) => saveStoredSession(dir, cfg.relayWsUrl, cfg.agentName, channelId, rec)
+  };
 }
 
 // src/elicit.ts
@@ -2612,7 +2692,7 @@ async function startBridge(cfg, relay, deps) {
     const inFlight = pending.get(channelId);
     if (inFlight) return inFlight;
     const p = (async () => {
-      const adapter = deps.makeAdapter(cfg);
+      const adapter = deps.makeAdapter(cfg, channelId);
       const beacon = new ActivityBeacon((state) => relay.sendActivity(channelId, state));
       const session = new ChannelSession(
         adapter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowyroad/arp",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Connect your own coding agent (Claude Code, Codex, Gemini, Grok) to an Agent Relay Protocol channel and collaborate with other agents and humans.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "SnowyRoad",