@snowyroad/arp 0.5.0 → 0.5.2

package/dist/cli.js

@@ -336,6 +336,18 @@ var CTRL_RE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
 function sanitizeForTty(s) {
   return s.replace(ANSI_RE, "").replace(CTRL_RE, "");
 }
+var ESC = String.fromCharCode(27);
+function restoreTerminal() {
+  const out = process.stdout;
+  if (!out.isTTY) return;
+  out.write(
+    `${ESC}[?1l${ESC}>${ESC}[?25h${ESC}[?1049l${ESC}[?2004l${ESC}[?1000l${ESC}[?1002l${ESC}[?1003l${ESC}[?1006l`
+  );
+  try {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  } catch {
+  }
+}
 function isShellSafeName(s) {
   return /^[A-Za-z0-9_.-]+$/.test(s);
 }
@@ -781,14 +793,14 @@ ${fence("peer roster", joinUntrusted(lines, "\n"))}`;
 }
 
 // src/channelContext.ts
-var MAX_INJECTED_MEMORY_CHARS = 8e3;
+var MAX_INJECTED_INSTRUCTIONS_CHARS = 8e3;
 var MAX_INJECTED_SOURCE_CHARS = 8e3;
 var MAX_INJECTED_SOURCES_TOTAL_CHARS = 24e3;
 function buildChannelContext(input) {
   let out = "";
-  if (!isBlankText(input.memory)) {
-    const raw = rawUntrusted(input.memory);
-    const bounded = raw.length > MAX_INJECTED_MEMORY_CHARS ? untrusted(raw.slice(0, MAX_INJECTED_MEMORY_CHARS) + "\n[...truncated]") : input.memory;
+  if (!isBlankText(input.instructions)) {
+    const raw = rawUntrusted(input.instructions);
+    const bounded = raw.length > MAX_INJECTED_INSTRUCTIONS_CHARS ? untrusted(raw.slice(0, MAX_INJECTED_INSTRUCTIONS_CHARS) + "\n[...truncated]") : input.instructions;
     out += `## Channel Instructions (standing guidance for this channel)
 ${fence("channel instructions", bounded)}
 ---
@@ -1505,21 +1517,21 @@ var RelayClient = class {
       console.warn("[arp-bridge] flow post failed:", sanitizeForTty(String(err)));
     }
   }
-  /** Channel memory text (empty if none or on error — never throws). Branded (H2-4). */
-  async fetchChannelMemory(channelId) {
+  /** Channel instructions text (empty if none or on error — never throws). Branded (H2-4). */
+  async fetchChannelInstructions(channelId) {
     const ch = this.pathId(channelId, "channelId");
     if (!ch) return untrusted("");
-    const url = `${this.cfg.relayHttpUrl}/channels/${ch}/memory`;
+    const url = `${this.cfg.relayHttpUrl}/channels/${ch}/instructions`;
     try {
       const res = await this.deps.fetchFn(url, { headers: { Authorization: `Bearer ${this.cfg.token}` } });
       if (!res.ok) {
-        console.warn("[arp-bridge] memory HTTP", res.status);
+        console.warn("[arp-bridge] instructions HTTP", res.status);
         return untrusted("");
       }
       const data = await res.json();
       return untrusted(typeof data?.content === "string" ? data.content : "");
     } catch (err) {
-      console.warn("[arp-bridge] memory fetch failed:", sanitizeForTty(String(err)));
+      console.warn("[arp-bridge] instructions fetch failed:", sanitizeForTty(String(err)));
       return untrusted("");
     }
   }
@@ -1604,18 +1616,18 @@ var RelayClient = class {
       return null;
     }
   }
-  /** Assemble the situational channel-context block (memory + sources + topics) for a
+  /** Assemble the situational channel-context block (instructions + sources + topics) for a
    *  passive message. Parallel fetch with per-source graceful degradation (each fetcher
    *  swallows its own errors). Returns "" when there is nothing to inject.
    *  The fetchers return raw structured data; untrusted-data fencing happens ONCE, in
    *  buildChannelContext (the single-layer rule, see untrusted.ts). Do not fence here. */
   async fetchChannelContext(channelId) {
-    const [memory, topics, pins] = await Promise.all([
-      this.fetchChannelMemory(channelId),
+    const [instructions, topics, pins] = await Promise.all([
+      this.fetchChannelInstructions(channelId),
       this.fetchChannelTopics(channelId),
       this.fetchSourcesContext(channelId)
     ]);
-    return buildChannelContext({ memory, topics, pins });
+    return buildChannelContext({ instructions, topics, pins });
   }
   /** Fetch a flow's transcript (used to backfill a minimal turn_notification). [] on error. */
   async fetchFlowMessages(channelId, flowId) {
@@ -2838,7 +2850,10 @@ function withTimeout(p, ms) {
 // src/shutdown.ts
 var SHUTDOWN_TIMEOUT_MS = 8e3;
 async function drainAndExit(sessions, exitCode, relay, brokers) {
-  const force = setTimeout(() => process.exit(exitCode), SHUTDOWN_TIMEOUT_MS);
+  const force = setTimeout(() => {
+    restoreTerminal();
+    process.exit(exitCode);
+  }, SHUTDOWN_TIMEOUT_MS);
   force.unref?.();
   try {
     relay?.stop();
@@ -2857,9 +2872,11 @@ async function drainAndExit(sessions, exitCode, relay, brokers) {
     }
   }
   clearTimeout(force);
+  restoreTerminal();
   process.exit(exitCode);
 }
 function installGracefulShutdown(bridge) {
+  process.on("exit", () => restoreTerminal());
   let shuttingDown = false;
   const shutdown = async (sig) => {
     if (shuttingDown) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowyroad/arp",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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",