@agentprojectcontext/apx 1.73.1 → 1.74.1

package/src/host/daemon/api/voice.js

@@ -104,6 +104,10 @@ export function register(app, { projects, plugins, registries }) {
       const channel = body.channel || "voice";
       let suggestions = [];
       let toolsUsed = [];
+      // Attribution for the persisted turn (see the appendGlobalMessage below).
+      let replyModel = null;
+      let replyUsage = null;
+      let replyName = null;
 
       const channelCtx = buildVoiceChannelContext(channel, {
         projectId: body.projectId,
@@ -125,6 +129,9 @@ export function register(app, { projects, plugins, registries }) {
             previousMessages,
           });
           const raw = (result?.text || "").trim();
+          replyModel = result?.model || null;
+          replyUsage = result?.usage || null;
+          replyName = result?.name || null;
           // Surface the tools the agent actually executed this turn so
           // the overlay can show "lo que APX hizo" instead of echoing
           // the transcript. Dedup by name (a list_tasks before+after
@@ -188,7 +195,19 @@ export function register(app, { projects, plugins, registries }) {
         const logCh = channelCtx.channel || channel;
         if (logCh && logCh !== "api") {
           appendGlobalMessage({ channel: logCh, direction: "in", type: "user", author: "user", body: userText });
-          if (replyText) appendGlobalMessage({ channel: logCh, direction: "out", type: "agent", body: replyText });
+          if (replyText) {
+            appendGlobalMessage({
+              channel: logCh,
+              direction: "out",
+              type: "agent",
+              author: replyName || undefined,
+              body: replyText,
+              meta: {
+                ...(replyModel ? { model: replyModel } : {}),
+                ...(replyUsage ? { usage: replyUsage } : {}),
+              },
+            });
+          }
         }
       } catch { /* best-effort */ }
 

package/src/host/daemon/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 // APX daemon entry point. Boots config + projects + Express + plugins.
+// Must run before any outbound fetch — see the module header for why.
+import "#core/net/ipv4-first.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/src/host/daemon/plugins/desktop/index.js

@@ -199,9 +199,20 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
       }
     }
 
-    // Persist assistant response
+    // Persist assistant response, stamped with the model that answered and the
+    // turn's token usage so the web thread viewer can attribute it.
     try {
-      await appendGlobalMessage({ channel: CHANNEL, direction: "out", type: "agent", body: finalText });
+      await appendGlobalMessage({
+        channel: CHANNEL,
+        direction: "out",
+        type: "agent",
+        author: result?.name || undefined,
+        body: finalText,
+        meta: {
+          ...(result?.model ? { model: result.model } : {}),
+          ...(result?.usage ? { usage: result.usage } : {}),
+        },
+      });
     } catch {}
 
   } catch (e) {

package/src/host/daemon/whisper-server.js

@@ -15,7 +15,9 @@ import {
   WHISPER_LOCAL_PORT,
   DEFAULT_LOCAL,
   getConfig,
+  setLocalServerEnsure,
 } from "#core/voice/transcription.js";
+import { envWithPath } from "#core/util/path-env.js";
 import { pythonForWhisper } from "./stt-venv.js";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -82,7 +84,21 @@ async function _killOrphanWhisper() {
   }
 }
 
+// Serializes concurrent ensures. Two voice messages arriving together (or a
+// desktop utterance racing a Telegram note) would otherwise each see a dead
+// port and spawn their own python, and the loser then trips
+// "address already in use".
+let _ensureInFlight = null;
+
 export async function ensureWhisperServer(opts) {
+  if (_ensureInFlight) return _ensureInFlight;
+  _ensureInFlight = _ensureWhisperServer(opts).finally(() => {
+    _ensureInFlight = null;
+  });
+  return _ensureInFlight;
+}
+
+async function _ensureWhisperServer(opts) {
   const model = opts.model || DEFAULT_LOCAL.model;
   const backend = opts.backend || "faster";
 
@@ -129,9 +145,15 @@ async function _spawnWhisper(opts, model, backend, retried) {
 
   // Prefer APX's dedicated venv interpreter (isolated mlx/faster-whisper);
   // fall back to system python3 for the legacy user-site install.
+  //
+  // envWithPath: both whisper backends shell out to `ffmpeg` to decode
+  // .oga/.webm. Booted from launchd the daemon's PATH is /usr/bin:/bin:
+  // /usr/sbin:/sbin, so a Homebrew ffmpeg is invisible and every transcription
+  // dies with "[Errno 2] No such file or directory: 'ffmpeg'".
   const proc = spawn(pythonForWhisper(), args, {
     stdio: ["ignore", "pipe", "inherit"],
     detached: false,
+    env: envWithPath(),
   });
 
   _serverProcess = proc;
@@ -236,3 +258,8 @@ export const WHISPER_PATHS = {
   whisper_server: WHISPER_SERVER,
   port: WHISPER_LOCAL_PORT,
 };
+
+// Hand core the ability to revive the subprocess on demand. Importing this
+// module (the daemon does, to preload at boot) is what wires it up — core
+// itself never reaches into host/.
+setLocalServerEnsure(ensureWhisperServer);

package/src/interfaces/cli/commands/exec.js

@@ -58,6 +58,69 @@ export function resolveExecChannel(args) {
   return CHANNELS.CLI;
 }
 
+// Braille spinner frames for the live "pensando…" indicator.
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+
+/**
+ * A single-line progress indicator drawn on stderr while the super-agent turn
+ * runs, so `apx exec` never looks frozen. Renders only on an interactive stderr
+ * (TTY); when piped/redirected it is a no-op so stdout stays clean for scripts.
+ * Set APX_NO_SPINNER=1 to disable.
+ */
+function createExecStatus() {
+  const active =
+    process.stderr.isTTY && process.env.APX_NO_SPINNER !== "1" && !process.env.NO_COLOR;
+  let label = "pensando…";
+  let frame = 0;
+  let timer = null;
+  const t0 = Date.now();
+
+  const draw = () => {
+    const secs = Math.floor((Date.now() - t0) / 1000);
+    process.stderr.write(`\r\x1b[2K${dim(SPINNER[frame])} ${label} ${dim(secs + "s")}`);
+    frame = (frame + 1) % SPINNER.length;
+  };
+
+  return {
+    start() {
+      if (!active || timer) return;
+      draw();
+      timer = setInterval(draw, 90);
+      timer.unref?.();
+    },
+    set(next) {
+      if (next) label = next;
+    },
+    clear() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (active) process.stderr.write("\r\x1b[2K");
+    },
+  };
+}
+
+/** Map a stream event to the label shown next to the spinner. */
+function labelForEvent(event) {
+  switch (event?.type) {
+    case "skill_inspector":
+      return "cargando skills…";
+    case "model_routed":
+    case "model_start": {
+      const m = event.model || event.to || event.engine;
+      return m ? `pensando… ${dim(m)}` : "pensando…";
+    }
+    case "tool_start":
+      return `${event.trace?.tool || event.tool || "herramienta"}…`;
+    case "tool_result":
+      return "pensando…";
+    default:
+      return null;
+  }
+}
+
 async function readPromptFromStdin() {
   const fs = await import("node:fs");
   if (process.stdin.isTTY) return "";
@@ -99,11 +162,26 @@ export async function cmdExec(args) {
   if (args.flags["max-tokens"]) body.maxTokens = parseInt(args.flags["max-tokens"], 10);
 
   if (useSuperAgent) {
-    const result = await http.post(`/projects/${pid}/super-agent/chat`, body);
-    process.stdout.write(result.text + "\n");
+    // Stream the turn so we can render a live progress indicator instead of a
+    // silent hang. `confirm: false` opts out of the interactive confirmation
+    // round-trip (which the CLI can't answer), keeping the same semantics as the
+    // blocking POST /super-agent/chat endpoint.
+    const status = createExecStatus();
+    status.start();
+    let result;
+    try {
+      result = await http.streamPost(
+        `/projects/${pid}/super-agent/chat/stream`,
+        { ...body, confirm: false },
+        (event) => status.set(labelForEvent(event))
+      );
+    } finally {
+      status.clear();
+    }
+    process.stdout.write((result?.text ?? "") + "\n");
     if (process.stderr.isTTY || args.flags.verbose) {
       process.stderr.write(
-        `\n— ${result.name || "super-agent"} | model=${result.trace ? "tools" : "engine"} | in=${result.usage?.input_tokens || "?"} out=${result.usage?.output_tokens || "?"}${result.model ? ` | ${result.model}` : ""}\n`
+        `\n— ${result?.name || "super-agent"} | model=${result?.trace ? "tools" : "engine"} | in=${result?.usage?.input_tokens || "?"} out=${result?.usage?.output_tokens || "?"}${result?.model ? ` | ${result.model}` : ""}\n`
       );
     }
     return;