@snowyroad/arp 0.3.4 → 0.3.6

package/dist/cli.js

@@ -857,15 +857,15 @@ function isAddressed(content, agentName) {
   return false;
 }
 function classifyCatchUp(messages, agentName, nowMs, opts) {
-  const mentions = messages.filter((m) => {
-    if (m.seq <= opts.deliveredMaxSeq) return false;
+  const inWindow = messages.filter((m) => {
     const t = Date.parse(rawUntrusted(m.createdAt));
-    const withinTtl = Number.isFinite(t) ? t >= nowMs - opts.ttlMs : true;
-    if (!withinTtl) return false;
-    return !sameText(m.senderName, agentName) && isAddressed(m.content, agentName);
+    return Number.isFinite(t) ? t >= nowMs - opts.ttlMs : true;
   });
+  const mentions = inWindow.filter(
+    (m) => !sameText(m.senderName, agentName) && isAddressed(m.content, agentName)
+  );
   const capped = mentions.slice(-opts.maxMentions);
-  return { context: messages, mentions: capped };
+  return { context: inWindow, mentions: capped };
 }
 
 // src/relayClient.ts
@@ -883,7 +883,6 @@ var MAX_BACKFILL_CHARS_PER_CATCHUP = 2e6;
 var MAX_BACKFILL_CHARS_PER_CONNECTION = 8e6;
 var MAX_CONCURRENT_CATCHUPS = 3;
 var GAP_RESUME_MIN_INTERVAL_MS = 5e3;
-var REBUILD_LOOKBACK_SEQS = 100;
 function clampContent(s) {
   if (s.length <= MAX_MESSAGE_CONTENT_CHARS) return s;
   return `${s.slice(0, MAX_MESSAGE_CONTENT_CHARS)}
@@ -1123,10 +1122,10 @@ var RelayClient = class {
   }
   /** Run a catch-up with bounded concurrency (BRIDGE-12): at most
    *  MAX_CONCURRENT_CATCHUPS paginated backfill loops in flight; extras queue FIFO. */
-  scheduleCatchUp(channelId, afterSeq, deliveredMaxSeq) {
+  scheduleCatchUp(channelId, afterSeq) {
     const run = () => {
       this.activeCatchUps++;
-      void this.catchUp(channelId, afterSeq, deliveredMaxSeq).finally(() => {
+      void this.catchUp(channelId, afterSeq).finally(() => {
         this.activeCatchUps--;
         const next = this.catchUpWaiters.shift();
         if (next) next();
@@ -1141,15 +1140,14 @@ var RelayClient = class {
   }
   /** Offline-rejoin catch-up: classify the missed window and hand it to onCatchUp once.
    *  Does NOT route through emitInbound/onInbound to avoid per-message passive submits. */
-  async catchUp(channelId, afterSeq, deliveredMaxSeq) {
+  async catchUp(channelId, afterSeq) {
     const missed = await this.fetchAfterSeq(channelId, afterSeq);
     if (missed.length === 0) return;
     for (const m of missed) if (m.id) this.markSeen(channelId, m.id);
     this.bumpCursor(channelId, missed[missed.length - 1].seq);
     const result = classifyCatchUp(missed, this.cfg.agentName, Date.now(), {
       ttlMs: this.cfg.catchUpTtlMs,
-      maxMentions: this.cfg.catchUpMaxMentions,
-      deliveredMaxSeq
+      maxMentions: this.cfg.catchUpMaxMentions
     });
     this.catchUpCbs.forEach((cb) => cb(channelId, result));
   }
@@ -1293,11 +1291,10 @@ var RelayClient = class {
           for (const [ch, seqRaw] of Object.entries(resume)) {
             const seq = Number(seqRaw);
             if (Number.isFinite(seq) && seq > this.cursorOf(ch)) this.cursors.set(ch, seq);
-            const deliveredMax = this.cursorOf(ch);
-            if (!this.caughtUp.has(ch) && deliveredMax > 0) {
+            const floor = this.cursorOf(ch);
+            if (!this.caughtUp.has(ch) && floor > 0) {
               this.caughtUp.add(ch);
-              const rebuildFloor = Math.max(0, deliveredMax - REBUILD_LOOKBACK_SEQS);
-              this.scheduleCatchUp(ch, rebuildFloor, deliveredMax);
+              this.scheduleCatchUp(ch, floor);
             }
           }
         }
@@ -1801,8 +1798,8 @@ ${fence("channel message", msg.content)}
       this.beacon?.begin();
       try {
         await this.session.converseLocal(capPrompt(
-          this.promptHead() + `You just (re)connected to ARP channel ${this.channelId}. Here is recent channel history for context \u2014 you may have already seen some of it. Absorb it so you can follow back-references in later messages; do NOT reply to it:
-` + fence("recent channel history", transcript)
+          this.promptHead() + `You just reconnected to ARP channel ${this.channelId} after being away. Here is what you missed (context only, do NOT reply to it):
+` + fence("missed channel messages", transcript)
         ));
       } finally {
         this.beacon?.end();
@@ -1870,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";
@@ -1970,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
@@ -2078,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: {
@@ -2088,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
@@ -2192,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)) };
@@ -2208,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;
@@ -2223,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);
@@ -2277,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;
@@ -2297,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) => {
@@ -2523,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
@@ -2615,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.4",
+  "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",