@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/interfaces/cli/http.js

@@ -39,16 +39,8 @@ async function ping(timeoutMs = 400) {
 }
 
 function findDaemonEntry() {
-  const candidates = [
-    // Current layout: src/host/daemon/index.js
-    path.resolve(__dirname, "../../host/daemon/index.js"),
-    // Legacy fallbacks for older installs that still have the shim tree.
-    path.resolve(__dirname, "../../daemon/index.js"),
-    path.resolve(__dirname, "../daemon/index.js"),
-    path.resolve(__dirname, "..", "node_modules", "apx-daemon", "src", "index.js"),
-  ];
-  for (const c of candidates) if (fs.existsSync(c)) return c;
-  return null;
+  const entry = path.resolve(__dirname, "../../host/daemon/index.js");
+  return fs.existsSync(entry) ? entry : null;
 }
 
 async function autoStart({ silent = false } = {}) {
@@ -111,6 +103,40 @@ async function request(method, path, body, opts = {}) {
   return json;
 }
 
+// Like request(), but sends a raw body (Buffer/Uint8Array/string) with
+// caller-supplied headers instead of JSON. For endpoints that take bytes, not
+// objects — e.g. POST /api/transcribe/chunk wants the audio itself in the body
+// plus X-Audio-Format / X-Language / X-Provider headers.
+async function rawRequest(method, path, body, opts = {}) {
+  if (opts.autoStart !== false) await ensureDaemon();
+  else if (!(await ping())) {
+    throw new Error(`apx daemon not running (no response on ${baseUrl()})`);
+  }
+  const token = readToken();
+  const res = await fetch(`${baseUrl()}${path}`, {
+    method,
+    headers: {
+      ...(opts.headers || {}),
+      ...(token ? { "authorization": `Bearer ${token}` } : {}),
+    },
+    body,
+    signal: opts.signal,
+  });
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch {
+    if (!res.ok) throw new Error(`${method} ${path} → ${res.status}: ${text}`);
+    return text;
+  }
+  if (!res.ok) {
+    const msg = json?.error || `${method} ${path} → ${res.status}`;
+    throw new Error(msg);
+  }
+  return json;
+}
+
 async function streamRequest(method, path, body, onEvent, opts = {}) {
   if (opts.autoStart !== false) await ensureDaemon();
   else if (!(await ping())) {
@@ -151,12 +177,18 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
     opts.signal.addEventListener("abort", () => reader.cancel().catch(() => {}), { once: true });
   }
 
+  // A read that dies mid-stream is NOT a clean end unless the caller aborted:
+  // the turn was cut off. Remembered here and raised below, because breaking
+  // out silently returned null and the caller printed an empty answer with exit
+  // 0 — the turn had failed and nothing said so.
+  let readError = null;
+
   while (true) {
     let chunk;
     try {
       chunk = await reader.read();
     } catch (e) {
-      // AbortError or cancel — treat as clean end
+      if (!opts.signal?.aborted) readError = e;
       break;
     }
     if (chunk.done) break;
@@ -172,14 +204,29 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
     }
   }
 
+  // Trailing line with no newline. Only a PARSE failure is ignorable here — a
+  // half-written line at a dropped connection. Wrapping the whole block in a
+  // bare catch also swallowed the `error` event's throw, which is how a failed
+  // turn reached the user as a blank line and a zero exit code.
   buffer += decoder.decode();
   if (buffer.trim()) {
+    let event = null;
     try {
-      const event = JSON.parse(buffer);
+      event = JSON.parse(buffer);
+    } catch {
+      event = null;
+    }
+    if (event) {
       if (event.type === "final") finalResult = event.result;
       if (event.type === "error") throw new Error(event.error || "stream error");
       await onEvent?.(event);
-    } catch {}
+    }
+  }
+
+  if (readError) {
+    throw new Error(
+      `${method} ${path}: the stream ended early (${readError.message}). The turn did not finish.`
+    );
   }
 
   return finalResult;
@@ -188,6 +235,7 @@ async function streamRequest(method, path, body, onEvent, opts = {}) {
 export const http = {
   get: (p, opts) => request("GET", p, undefined, opts),
   post: (p, body, opts) => request("POST", p, body, opts),
+  postRaw: (p, body, opts) => rawRequest("POST", p, body, opts),
   streamPost: (p, body, onEvent, opts) => streamRequest("POST", p, body, onEvent, opts),
   put: (p, body, opts) => request("PUT", p, body, opts),
   patch: (p, body, opts) => request("PATCH", p, body, opts),

package/src/interfaces/cli/index.js

@@ -21,7 +21,7 @@ const VERSION = JSON.parse(
 // Flags that never take a value. Without this the parser would greedily
 // swallow the following positional (e.g. `apx exec --code "hi"` would set
 // flags.code = "hi" and drop the prompt). Boolean flags always resolve to true.
-const BOOLEAN_FLAGS = new Set(["code", "verbose", "global", "mcp", "memory"]);
+const BOOLEAN_FLAGS = new Set(["code", "verbose", "global", "mcp", "memory", "json", "open"]);
 
 function parseArgs(argv) {
   const args = { _: [], flags: {} };

package/src/interfaces/cli/routes/agent.js

@@ -4,14 +4,15 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdAgentAdd, cmdAgentGet, cmdAgentImport, cmdAgentList, cmdAgentRemove, cmdAgentVaultAdd, cmdAgentVaultList, cmdAgentVaultRestore, cmdAgentVaultRm } from "../commands/agent.js";
+import { cmdAgentAdd, cmdAgentGet, cmdAgentImport, cmdAgentList, cmdAgentRemove, cmdAgentSet, cmdAgentVaultAdd, cmdAgentVaultList, cmdAgentVaultRestore, cmdAgentVaultRm } from "../commands/agent.js";
 
 export default async function route(rest, { parseArgs, die }) {
   const sub = rest[0];
   const a = parseArgs(rest.slice(1));
   if (sub === "add") await cmdAgentAdd(a);
-  else if (sub === "list" || sub === "ls") cmdAgentList();
-  else if (sub === "get" || sub === "show") cmdAgentGet(a);
+  else if (sub === "set" || sub === "edit" || sub === "update") await cmdAgentSet(a);
+  else if (sub === "list" || sub === "ls") await cmdAgentList(a);
+  else if (sub === "get" || sub === "show") await cmdAgentGet(a);
   else if (sub === "remove" || sub === "rm" || sub === "delete") await cmdAgentRemove(a);
   else if (sub === "import") await cmdAgentImport(a);
   else if (sub === "vault") {
@@ -23,5 +24,5 @@ export default async function route(rest, { parseArgs, die }) {
     else if (vsub === "restore") cmdAgentVaultRestore(va);
     else die(`unknown vault subcommand: ${vsub || "(none)"} — try: list, add, rm, restore`);
   }
-  else die(`unknown agent subcommand: ${sub || "(none)"}`);
+  else die(`unknown agent subcommand: ${sub || "(none)"} — try: add, set, list, get, remove, import, vault`);
 }

package/src/interfaces/cli/routes/commitment.js

@@ -1,7 +1,7 @@
 // apx commitment — argument routing.
 import {
   cmdCommitmentAdd, cmdCommitmentList, cmdCommitmentShow,
-  cmdCommitmentKept, cmdCommitmentMissed, cmdCommitmentRenegotiate,
+  cmdCommitmentKept, cmdCommitmentMissed, cmdCommitmentDrop, cmdCommitmentRenegotiate,
 } from "../commands/commitment.js";
 
 export const aliases = ["commitments"];
@@ -14,6 +14,7 @@ export default async function route(rest, { parseArgs, die }) {
   else if (sub === "show" || sub === "get") await cmdCommitmentShow(a);
   else if (sub === "kept" || sub === "done") await cmdCommitmentKept(a);
   else if (sub === "missed") await cmdCommitmentMissed(a);
+  else if (sub === "drop" || sub === "rm") await cmdCommitmentDrop(a);
   else if (sub === "renegotiate" || sub === "move") await cmdCommitmentRenegotiate(a);
-  else die(`unknown commitment subcommand: ${sub}\nUsage: apx commitment <list|add|show|kept|missed|renegotiate>`);
+  else die(`unknown commitment subcommand: ${sub}\nUsage: apx commitment <list|add|show|kept|missed|drop|renegotiate>`);
 }

package/src/interfaces/cli/routes/config.js

@@ -7,8 +7,13 @@
 import { cmdConfigSet, cmdConfigShow, cmdConfigUnset } from "../commands/config.js";
 
 export default async function route(rest, { parseArgs, die }) {
-  const sub = rest[0];
-  const a = parseArgs(rest.slice(1));
+  // A leading flag means no subcommand was given: `apx config --global` is
+  // `apx config show --global`. Without this the flag itself was read as the
+  // subcommand name and died with "unknown config subcommand: --global".
+  // (`--help` never reaches here — cli/index.js intercepts it first.)
+  const hasSub = rest[0] !== undefined && !rest[0].startsWith("-");
+  const sub = hasSub ? rest[0] : undefined;
+  const a = parseArgs(hasSub ? rest.slice(1) : rest);
   if (sub === "show" || sub === "ls" || sub === undefined) await cmdConfigShow(a);
   else if (sub === "set") await cmdConfigSet(a);
   else if (sub === "unset" || sub === "rm") await cmdConfigUnset(a);

package/src/interfaces/cli/routes/image.js

@@ -0,0 +1,11 @@
+// apx image — argument routing.
+//
+// One positional (the prompt) or a reserved subcommand (providers /
+// capabilities), plus flags. The command function does the disambiguation, so
+// this hands straight off.
+
+import { cmdImage } from "../commands/image.js";
+
+export default async function route(rest, { parseArgs }) {
+  await cmdImage(parseArgs(rest));
+}

package/src/interfaces/cli/routes/index.js

@@ -66,6 +66,8 @@ export const ROUTES = Object.freeze({
   "overlay": () => import("./overlay.js"),
   "desktop": () => import("./desktop.js"),
   "voice": () => import("./voice.js"),
+  "transcribe": () => import("./transcribe.js"),
+  "image": () => import("./image.js"),
 });
 
 export function resolveRoute(cmd) {

package/src/interfaces/cli/routes/log.js

@@ -14,7 +14,7 @@ export const aliases = ["logs"];
 
 export default async function route(rest, { parseArgs }) {
   // `apx log` is the unified daemon log (everything: telegram, whisper,
-  // super-agent, tools, desktop). For just the legacy stdout sink,
+  // super-agent, tools, desktop). For just the raw daemon stdout sink,
   // use `apx daemon logs`. `apx log -f` follows; `--errors` filters.
   await cmdLog(parseArgs(rest));
 }

package/src/interfaces/cli/routes/memory.js

@@ -4,16 +4,17 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdMemory, cmdMemoryNotebook, cmdMemoryConsolidate, cmdMemoryRevert } from "../commands/memory.js";
+import { cmdMemory, cmdMemoryNotebook, cmdMemoryConsolidate, cmdMemoryRevert, cmdMemoryPrune } from "../commands/memory.js";
 
 export default async function route(rest, { parseArgs }) {
   // `apx memory <agent-slug>` is the original form and stays the default, so
-  // these three names are reserved. An agent literally called "notebook" would
+  // these four names are reserved. An agent literally called "notebook" would
   // be shadowed; that is a trade worth making for a readable command.
   const sub = rest[0];
   const a = parseArgs(rest.slice(1));
   if (sub === "notebook") return cmdMemoryNotebook(a);
   if (sub === "consolidate") return cmdMemoryConsolidate(a);
   if (sub === "revert") return cmdMemoryRevert(a);
+  if (sub === "prune") return cmdMemoryPrune(a);
   return cmdMemory(parseArgs(rest));
 }

package/src/interfaces/cli/routes/panel.js

@@ -4,7 +4,14 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdPanelShare, cmdPanelStatus, cmdPanelUnshare } from "../commands/panel.js";
+import {
+  cmdPanelShare,
+  cmdPanelStatus,
+  cmdPanelTailscaleOff,
+  cmdPanelTailscaleOn,
+  cmdPanelTailscaleStatus,
+  cmdPanelUnshare,
+} from "../commands/panel.js";
 
 export default async function route(rest, { parseArgs, die }) {
   const sub = rest[0];
@@ -12,5 +19,11 @@ export default async function route(rest, { parseArgs, die }) {
   if (!sub || sub === "status") await cmdPanelStatus(a);
   else if (sub === "share") await cmdPanelShare(a);
   else if (sub === "unshare") await cmdPanelUnshare(a);
-  else die(`unknown panel subcommand: ${sub}\nUsage: apx panel <status|share|unshare>`);
+  else if (sub === "tailscale") {
+    const how = rest[1];
+    if (!how || how === "status") await cmdPanelTailscaleStatus();
+    else if (how === "on") await cmdPanelTailscaleOn();
+    else if (how === "off") await cmdPanelTailscaleOff();
+    else die(`unknown panel tailscale subcommand: ${how}\nUsage: apx panel tailscale <status|on|off>`);
+  } else die(`unknown panel subcommand: ${sub}\nUsage: apx panel <status|share|unshare|tailscale>`);
 }

package/src/interfaces/cli/routes/profile.js

@@ -4,7 +4,7 @@
 // owns its own routing and imports only the command functions it calls, so the
 // CLI no longer loads all 38 command modules to run one of them.
 
-import { cmdProfileConfig, cmdProfileDoctor, cmdProfileInstall, cmdProfileList, cmdProfileOff, cmdProfileShow, cmdProfileUninstall, cmdProfileUse } from "../commands/profile.js";
+import { cmdProfileConfig, cmdProfileDoctor, cmdProfileInstall, cmdProfileList, cmdProfileOff, cmdProfileShow, cmdProfileSync, cmdProfileUninstall, cmdProfileUse } from "../commands/profile.js";
 
 // Aliases accepted for this command. Declared here, next to the command
 // itself — a global alias table would be wrong, since the same word means
@@ -19,9 +19,10 @@ export default async function route(rest, { parseArgs, die }) {
   else if (sub === "show" || sub === "get") await cmdProfileShow(a);
   else if (sub === "install" || sub === "add") await cmdProfileInstall(a);
   else if (sub === "use" || sub === "activate") await cmdProfileUse(a);
+  else if (sub === "sync") await cmdProfileSync(a);
   else if (sub === "off" || sub === "deactivate") await cmdProfileOff(a);
   else if (sub === "config") await cmdProfileConfig(a);
   else if (sub === "doctor") await cmdProfileDoctor(a);
   else if (sub === "uninstall" || sub === "remove" || sub === "rm") await cmdProfileUninstall(a);
-  else die(`unknown profile subcommand: ${sub}\nUsage: apx profile <list|show|install|use|off|config|doctor|uninstall>`);
+  else die(`unknown profile subcommand: ${sub}\nUsage: apx profile <list|show|install|use|sync|off|config|doctor|uninstall>`);
 }

package/src/interfaces/cli/routes/transcribe.js

@@ -0,0 +1,10 @@
+// apx transcribe — argument routing.
+//
+// One positional (the audio file, or "-" for stdin) plus flags. No
+// sub-commands, so this hands straight off to the command function.
+
+import { cmdTranscribe } from "../commands/transcribe.js";
+
+export default async function route(rest, { parseArgs }) {
+  await cmdTranscribe(parseArgs(rest));
+}

package/src/interfaces/cli/stdin.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+
+/**
+ * Read all of stdin, synchronously.
+ *
+ * The CLI convention across commands is a `-` flag value (`--prompt -`,
+ * `--body -`) or a bare flag (`apx memory <slug> --replace`) meaning "the text
+ * comes from a pipe". Long multi-line content — an agent's system prompt, a
+ * session body, a memory file — is unusable as a shell argument, so a pipe is
+ * the only sane way to hand it over.
+ *
+ * Sync on purpose: these are one-shot CLI commands that have nothing to do
+ * until the input has arrived, and fd 0 reads are what `apx foo < file` and
+ * `cat x | apx foo` both resolve to.
+ */
+export function readStdinSync() {
+  const chunks = [];
+  const buf = Buffer.alloc(65536);
+  try {
+    while (true) {
+      const bytes = fs.readSync(0, buf, 0, buf.length);
+      if (!bytes) break;
+      chunks.push(buf.subarray(0, bytes).toString("utf8"));
+    }
+  } catch {
+    // EOF on a closed/absent stdin (EAGAIN on a TTY) — whatever arrived is it.
+  }
+  return chunks.join("");
+}