open-agents-ai 0.140.0 → 0.140.2

package/dist/index.js

@@ -5645,6 +5645,86 @@ async function handleCmd(cmd) {
         break;
       }
 
+      // \u2500\u2500 IPFS pin external CID \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'ipfs_pin': {
+        var _ipCid = args.cid || '';
+        if (!_ipCid) { writeResp(id, { ok: false, output: 'cid required' }); break; }
+        // Validate CID format
+        if (!_ipCid.startsWith('bafy') && !_ipCid.startsWith('bafk') && !_ipCid.startsWith('Qm')) {
+          writeResp(id, { ok: false, output: 'Invalid CID format. Must start with bafy, bafk, or Qm' });
+          break;
+        }
+        var _ipReady = await _ensureHelia();
+        if (!_ipReady || !_heliaNode) {
+          writeResp(id, { ok: false, output: 'Helia not available \u2014 cannot pin external CIDs' });
+          break;
+        }
+        try {
+          var { CID: _ipCIDClass } = await import('multiformats/cid');
+          var _ipParsed = _ipCIDClass.parse(_ipCid);
+          for await (var _ipPin of _heliaNode.pins.add(_ipParsed)) { /* pinning */ }
+          // Register in CID registry
+          var _ipRegDir = join(nexusDir, 'ipfs', 'cid-registry');
+          mkdirSync(_ipRegDir, { recursive: true });
+          var _ipRegFile = join(_ipRegDir, 'learning-cids.json');
+          var _ipReg = {};
+          try { if (existsSync(_ipRegFile)) _ipReg = JSON.parse(readFileSync(_ipRegFile, 'utf8')); } catch {}
+          _ipReg['pin-' + Date.now().toString(36)] = {
+            cid: _ipCid,
+            source: args.source || 'manual-pin',
+            pinned: true,
+            timestamp: Date.now(),
+          };
+          writeFileSync(_ipRegFile, JSON.stringify(_ipReg, null, 2));
+          dlog('IPFS: pinned external CID ' + _ipCid.slice(0, 20) + '...');
+          writeResp(id, { ok: true, output: JSON.stringify({ cid: _ipCid, pinned: true }) });
+        } catch (_ipErr) {
+          writeResp(id, { ok: false, output: 'Pin error: ' + (_ipErr.message || _ipErr) });
+        }
+        break;
+      }
+
+      // \u2500\u2500 IPFS list pinned CIDs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'ipfs_ls': {
+        var _ilPins = [];
+        // Merge from Helia pins (if available) + CID registry
+        try {
+          if (_heliaReady && _heliaNode) {
+            for await (var _ilCid of _heliaNode.pins.ls()) {
+              _ilPins.push({ cid: _ilCid.cid.toString(), source: 'helia', pinned: true });
+            }
+          }
+        } catch {}
+        // Merge CID registry metadata
+        try {
+          var _ilRegFile = join(nexusDir, 'ipfs', 'cid-registry', 'learning-cids.json');
+          if (existsSync(_ilRegFile)) {
+            var _ilReg = JSON.parse(readFileSync(_ilRegFile, 'utf8'));
+            for (var _ilKey of Object.keys(_ilReg)) {
+              var _ilEntry = _ilReg[_ilKey];
+              if (!_ilPins.some(function(p) { return p.cid === _ilEntry.cid; })) {
+                _ilPins.push({ cid: _ilEntry.cid, source: _ilEntry.source, pinned: _ilEntry.pinned, timestamp: _ilEntry.timestamp });
+              }
+            }
+          }
+        } catch {}
+        // Also include identity CIDs
+        try {
+          var _ilIdFile = join(nexusDir, '..', 'identity', 'cids.json');
+          if (existsSync(_ilIdFile)) {
+            var _ilIdCids = JSON.parse(readFileSync(_ilIdFile, 'utf8'));
+            for (var _ilIdKey of Object.keys(_ilIdCids)) {
+              var _ilIdCid = _ilIdCids[_ilIdKey];
+              if (_ilIdCid && !_ilPins.some(function(p) { return p.cid === _ilIdCid; })) {
+                _ilPins.push({ cid: _ilIdCid, source: 'identity-' + _ilIdKey, pinned: true });
+              }
+            }
+          }
+        } catch {}
+        writeResp(id, { ok: true, output: JSON.stringify({ pins: _ilPins, count: _ilPins.length }) });
+        break;
+      }
+
       // \u2500\u2500 COHERE distributed learning \u2014 publish insight to mesh \u2500\u2500\u2500\u2500\u2500\u2500
       case 'cohere_publish_insight': {
         if (!cohereActive) { writeResp(id, { ok: false, output: 'COHERE not active' }); break; }
@@ -7214,6 +7294,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "cohere_deny_model",
               "cohere_list_models",
               "ipfs_add",
+              "ipfs_pin",
+              "ipfs_ls",
               "cohere_publish_insight"
             ],
             description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, cohere_stats, cohere_enable, cohere_disable, cohere_allow_model, cohere_deny_model, cohere_list_models, ipfs_add, etc."
@@ -7454,6 +7536,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "ipfs_add":
               result = await this.sendDaemonCmd("ipfs_add", { content: String(args.content ?? args.message ?? "") });
               break;
+            case "ipfs_pin":
+              result = await this.sendDaemonCmd("ipfs_pin", { cid: String(args.cid ?? args.content ?? ""), source: String(args.source ?? "agent") });
+              break;
+            case "ipfs_ls":
+              result = await this.sendDaemonCmd("ipfs_ls", {});
+              break;
             case "cohere_publish_insight":
               result = await this.sendDaemonCmd("cohere_publish_insight", {
                 insight: String(args.insight ?? args.content ?? ""),
@@ -30995,43 +31083,42 @@ function setContentWriteHook(hook) {
 }
 function renderError(message) {
   const redir = _contentWriteHook?.redirect?.();
-  const icon = _emojisEnabled ? "\x1B[38;5;178m\u2716\x1B[0m" : c2.red("E");
+  const icon = _emojisEnabled ? "\x1B[38;5;198m\u2716\x1B[0m" : "\x1B[38;5;198mE\x1B[0m";
+  const text = `
+${icon} \x1B[38;5;198m${message}\x1B[0m
+`;
   if (redir) {
-    redir(`
-${icon} ${message}
-`);
+    redir(text);
     return;
   }
   _contentWriteHook?.begin();
-  process.stdout.write(`
-${icon} ${message}
-`);
+  process.stdout.write(text);
   _contentWriteHook?.end();
 }
 function renderInfo(message) {
   const redir = _contentWriteHook?.redirect?.();
-  const icon = _emojisEnabled ? "\x1B[38;5;178m\u2139\x1B[0m" : "\x1B[38;5;178mi\x1B[0m";
+  const icon = "\x1B[38;5;178mi\x1B[0m";
+  const text = `${icon} \x1B[38;5;252m${message}\x1B[0m
+`;
   if (redir) {
-    redir(`${icon} ${message}
-`);
+    redir(text);
     return;
   }
   _contentWriteHook?.begin();
-  process.stdout.write(`${icon} ${message}
-`);
+  process.stdout.write(text);
   _contentWriteHook?.end();
 }
 function renderWarning(message) {
   const redir = _contentWriteHook?.redirect?.();
-  const icon = _emojisEnabled ? "\x1B[38;5;178m\u26A0\x1B[0m" : "\x1B[38;5;178m!\x1B[0m";
+  const icon = "\x1B[38;5;214m!\x1B[0m";
+  const text = `${icon} \x1B[38;5;214m${message}\x1B[0m
+`;
   if (redir) {
-    redir(`${icon} ${message}
-`);
+    redir(text);
     return;
   }
   _contentWriteHook?.begin();
-  process.stdout.write(`${icon} ${message}
-`);
+  process.stdout.write(text);
   _contentWriteHook?.end();
 }
 function renderVerbose(message) {
@@ -40445,14 +40532,49 @@ var init_voice = __esm({
       async drainQueue() {
         this.speaking = true;
         let isFirst = true;
+        let prefetchedWav = null;
         while (this.speakQueue.length > 0) {
           const item = this.speakQueue.shift();
           if (!isFirst) {
-            await this.sleep(250);
+            await this.sleep(120);
           }
           isFirst = false;
           try {
-            await this.synthesizeAndPlay(item.text, item.volume, item.pitchFactor, item.speedFactor, item.stereoDelayMs);
+            if (this.luxttsActive) {
+              let wavPath = null;
+              if (prefetchedWav && prefetchedWav.item === item) {
+                wavPath = prefetchedWav.path;
+                prefetchedWav = null;
+              }
+              const nextItem = this.speakQueue[0] ?? null;
+              let prefetchPromise = null;
+              if (nextItem && this.luxttsActive) {
+                prefetchPromise = this.synthesizeLuxttsWav(nextItem.text, nextItem.speedFactor);
+              }
+              if (!wavPath) {
+                wavPath = await this.synthesizeLuxttsWav(item.text, item.speedFactor);
+              }
+              if (wavPath) {
+                await this.postProcessAndPlayLuxtts(wavPath, item.volume, item.pitchFactor, item.stereoDelayMs);
+              }
+              if (prefetchPromise && nextItem) {
+                try {
+                  const nextWav = await prefetchPromise;
+                  if (nextWav) {
+                    prefetchedWav = { path: nextWav, item: nextItem };
+                  }
+                } catch {
+                }
+              }
+            } else {
+              await this.synthesizeAndPlay(item.text, item.volume, item.pitchFactor, item.speedFactor, item.stereoDelayMs);
+            }
+          } catch {
+          }
+        }
+        if (prefetchedWav) {
+          try {
+            unlinkSync8(prefetchedWav.path);
           } catch {
           }
         }
@@ -41151,10 +41273,19 @@ Error: ${err2 instanceof Error ? err2.message : String(err2)}`);
             renderWarning(`  Could not install system build deps: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
+        const isJetson = isArm && (existsSync35("/etc/nv_tegra_release") || existsSync35("/usr/local/cuda/targets/aarch64-linux") || (process.env.JETSON_L4T_VERSION ?? "") !== "");
         const installSteps = isArm ? [
           // ARM: install individually so we get clear error messages per package.
           // ALL are fatal because LuxTTS hard-imports them (no lazy/optional imports).
           { cmd: `${pipCmd} -m pip install --quiet "setuptools<81" wheel`, fatal: true, label: "setuptools" },
+          // Jetson: try NVIDIA's prebuilt PyTorch wheel first (has CUDA support)
+          ...isJetson ? [
+            { cmd: `${pipCmd} -m pip install --quiet torch --index-url https://developer.download.nvidia.com/compute/redist/jp/v60/pytorch/ 2>/dev/null || ${pipCmd} -m pip install --quiet torch`, fatal: true, label: "PyTorch (Jetson L4T)" },
+            { cmd: `${pipCmd} -m pip install --quiet onnxruntime-gpu 2>/dev/null || true`, fatal: false, label: "onnxruntime-gpu (Jetson, optional)" }
+          ] : [
+            // Non-Jetson ARM: standard PyTorch (CPU)
+            { cmd: `${pipCmd} -m pip install --quiet torch --index-url https://download.pytorch.org/whl/cpu`, fatal: true, label: "PyTorch (ARM CPU)" }
+          ],
           { cmd: `${pipCmd} -m pip install --quiet numpy`, fatal: true, label: "numpy" },
           { cmd: `${pipCmd} -m pip install --quiet huggingface_hub safetensors`, fatal: true, label: "huggingface_hub + safetensors" },
           { cmd: `${pipCmd} -m pip install --quiet "transformers<=4.57.6"`, fatal: true, label: "transformers" },
@@ -41397,17 +41528,21 @@ if __name__ == '__main__':
        * Speed is passed natively to LuxTTS. Pitch is post-processed via resampling.
        * Volume is applied via WAV sample scaling. Stereo ITD applied for depth.
        */
-      async synthesizeWithLuxtts(text, volume = 1, pitchFactor = 1, speedFactor = 1, stereoDelayMs = 0.6) {
-        if (!this.luxttsCloneRef || !existsSync35(this.luxttsCloneRef)) {
-          return;
-        }
+      /**
+       * Synthesize text to a WAV file via LuxTTS daemon (synthesis only, no playback).
+       * Returns the WAV file path or null on failure.
+       * Used by drainQueue's pre-fetch pipeline for gapless back-to-back playback.
+       */
+      async synthesizeLuxttsWav(text, speedFactor = 1) {
+        if (!this.luxttsCloneRef || !existsSync35(this.luxttsCloneRef))
+          return null;
         const cleaned = text.replace(/\*/g, "").trim();
         if (!cleaned)
-          return;
+          return null;
         const ready = await this.ensureLuxttsDaemon();
         if (!ready)
-          return;
-        const wavPath = join50(tmpdir9(), `oa-luxtts-${Date.now()}.wav`);
+          return null;
+        const wavPath = join50(tmpdir9(), `oa-luxtts-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.wav`);
         try {
           await this.luxttsRequest({
             action: "synthesize",
@@ -41417,8 +41552,15 @@ if __name__ == '__main__':
             speed: speedFactor
           });
         } catch {
-          return;
+          return null;
         }
+        return existsSync35(wavPath) ? wavPath : null;
+      }
+      /**
+       * Post-process (fade-in, volume, pitch, stereo) and play a LuxTTS WAV file.
+       * Cleans up the WAV file after playback.
+       */
+      async postProcessAndPlayLuxtts(wavPath, volume = 1, pitchFactor = 1, stereoDelayMs = 0.6) {
         if (!existsSync35(wavPath))
           return;
         try {
@@ -41493,6 +41635,13 @@ if __name__ == '__main__':
         } catch {
         }
       }
+      /** Combined synthesize + post-process + play for LuxTTS (used by synthesizeAndPlay) */
+      async synthesizeWithLuxtts(text, volume = 1, pitchFactor = 1, speedFactor = 1, stereoDelayMs = 0.6) {
+        const wavPath = await this.synthesizeLuxttsWav(text, speedFactor);
+        if (!wavPath)
+          return;
+        await this.postProcessAndPlayLuxtts(wavPath, volume, pitchFactor, stereoDelayMs);
+      }
       /**
        * Synthesize text to WAV buffer using LuxTTS (no playback).
        * Used for Telegram voice messages and WebSocket streaming.
@@ -42124,6 +42273,85 @@ async function handleSlashCommand(input, ctx) {
       return "handled";
     }
     case "ipfs": {
+      const ipfsSubCmd = (arg || "").trim().split(/\s+/);
+      const ipfsAction = ipfsSubCmd[0]?.toLowerCase() || "";
+      const ipfsArg = ipfsSubCmd.slice(1).join(" ");
+      if (ipfsAction === "pin" && ipfsArg) {
+        const cidToPin = ipfsArg.trim();
+        if (!cidToPin.startsWith("bafy") && !cidToPin.startsWith("bafk") && !cidToPin.startsWith("Qm")) {
+          renderWarning("Invalid CID format. Must start with bafy, bafk, or Qm");
+          return "handled";
+        }
+        try {
+          const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+          const nexus = new NexusTool2(ctx.repoRoot);
+          const result = await nexus.execute({ action: "ipfs_pin", cid: cidToPin, source: "user-pin" });
+          if (result.success) {
+            renderInfo(`Pinned: ${cidToPin}`);
+          } else {
+            renderWarning(`Pin failed: ${result.output}`);
+          }
+        } catch (e) {
+          renderWarning(`Pin failed: ${e.message ?? e}`);
+        }
+        return "handled";
+      }
+      if (ipfsAction === "publish") {
+        try {
+          const { IdentityKernelTool: IdentityKernelTool2 } = __require("@open-agents/execution");
+          const ik = new IdentityKernelTool2(ctx.repoRoot);
+          const result = await ik.execute({ operation: "publish_snapshot" });
+          if (result.success) {
+            const cidMatch = result.output.match(/CID:\s*(bafy\S+|bafk\S+)/);
+            if (cidMatch) {
+              safeLog(`
+  ${c2.bold("Identity Published")}`);
+              safeLog(`  CID: ${c2.bold(cidMatch[1])}`);
+              safeLog(`  ${c2.dim("Share this CID with other agents: /ipfs pin " + cidMatch[1])}
+`);
+            } else {
+              safeLog(result.output);
+            }
+          } else {
+            renderWarning(result.output);
+          }
+        } catch (e) {
+          renderWarning(`Publish failed: ${e.message ?? e}`);
+        }
+        return "handled";
+      }
+      if (ipfsAction === "cids" || ipfsAction === "ls" || ipfsAction === "pins") {
+        try {
+          const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+          const nexus = new NexusTool2(ctx.repoRoot);
+          const result = await nexus.execute({ action: "ipfs_ls" });
+          if (result.success) {
+            const data = JSON.parse(result.output);
+            const pins = data.pins || [];
+            if (pins.length === 0) {
+              renderInfo("No pinned CIDs. Use /ipfs publish to publish your identity.");
+            } else {
+              const lines2 = [`
+  ${c2.bold("Pinned CIDs")} (${pins.length})
+`];
+              for (const p of pins.slice(0, 20)) {
+                const src = p.source ? c2.dim(` (${p.source})`) : "";
+                const pin = p.pinned ? c2.green("pinned") : c2.yellow("registered");
+                lines2.push(`  ${pin}  ${c2.bold(p.cid.slice(0, 30))}...${src}`);
+              }
+              if (pins.length > 20)
+                lines2.push(`  ${c2.dim(`... and ${pins.length - 20} more`)}`);
+              lines2.push("");
+              safeLog(lines2.join("\n"));
+            }
+          } else {
+            renderWarning(result.output);
+          }
+        } catch (e) {
+          renderWarning(`List failed: ${e.message ?? e}`);
+        }
+        return "handled";
+      }
       const lines = [];
       lines.push(`
   ${c2.bold("IPFS / Helia Status")}
@@ -42169,6 +42397,26 @@ async function handleSlashCommand(input, ctx) {
       lines.push(`  ${c2.dim("Helia blocks:")}`);
       lines.push(`    Blocks: ${c2.bold(String(heliaBlocks))}   Size: ${c2.bold(formatFileSize(heliaBytes))}`);
       lines.push(`    Backend: ${heliaBlocks > 0 ? c2.green("helia-ipfs") : c2.yellow("sha256-local (Helia not initialized)")}`);
+      try {
+        const statusFile = join51(ctx.repoRoot, ".oa", "nexus", "status.json");
+        if (existsSync36(statusFile)) {
+          const status = JSON.parse(readFileSync25(statusFile, "utf8"));
+          if (status.peerId) {
+            lines.push(`
+  ${c2.bold("Peer Info")}`);
+            lines.push(`    Peer ID: ${c2.bold(status.peerId.slice(0, 20))}...`);
+            if (status.multiaddrs && status.multiaddrs.length > 0) {
+              lines.push(`    Addresses: ${status.multiaddrs.length}`);
+              for (const addr of status.multiaddrs.slice(0, 3)) {
+                lines.push(`      ${c2.dim(addr)}`);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      lines.push(`
+  ${c2.dim("Commands: /ipfs pin <CID>  /ipfs publish  /ipfs cids")}`);
       lines.push(`
   ${c2.bold("Identity Kernel")}`);
       const idDir = join51(ctx.repoRoot, ".oa", "identity");
@@ -56448,7 +56696,6 @@ ${entry.fullContent}`
         break;
       case "sudo_request":
         contentWrite(() => renderWarning(`Sudo required: ${event.content ?? "elevated privileges needed"}`));
-        contentWrite(() => renderInfo("Enter your password at the prompt below to continue."));
         if (sudoCallback)
           sudoCallback(event.content ?? "");
         break;
@@ -57445,8 +57692,13 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
     if (process.stdout.isTTY) {
       process.stdout.write("\x1B[?1002l\x1B[?1006l");
     }
-    writeContent(() => renderInfo("Password required for sudo. Type below, Enter to submit. Ctrl+O to show/hide."));
-    const pwPrompt = `\x1B[38;5;178m\u{1F511}\x1B[0m `;
+    writeContent(() => {
+      process.stdout.write(`
+  \x1B[5;38;5;198m\u2B24 Enter Password:\x1B[0m \x1B[38;5;245mType below, Enter to submit. Ctrl+O to show/hide.\x1B[0m
+
+`);
+    });
+    const pwPrompt = `\x1B[38;5;198m\u25CF password:\x1B[0m `;
     rl.setPrompt(pwPrompt);
     if (statusBar.isActive) {
       const origProvider = statusBar.inputStateProvider;
@@ -57456,7 +57708,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
           return state;
         return { line: "\u25CF".repeat(state.line.length), cursor: state.cursor };
       };
-      statusBar.setPromptText(pwPrompt, 3);
+      statusBar.setPromptText(pwPrompt, 12);
     }
     showPrompt();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.140.0",
+  "version": "0.140.2",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",