@agentprojectcontext/apx 1.24.0 → 1.27.1

package/src/core/voice/engines/piper.js

@@ -0,0 +1,93 @@
+// Piper TTS adapter — local, offline, no API key.
+// Calls the `piper` CLI (https://github.com/rhasspy/piper). Requires the user
+// to have installed piper and at least one voice model (.onnx + .onnx.json).
+//
+// Config (~/.apx/config.json → voice.tts.piper):
+//   {
+//     "bin": "piper",                 // override binary path/name
+//     "model": "/abs/path/to/<voice>.onnx",
+//     "speaker": 0,                   // optional speaker id for multi-voice models
+//     "extra_args": []                // raw extra CLI args
+//   }
+//
+// Detection is graceful: isAvailable() returns false when piper is not on PATH
+// or no model is configured. Selector then falls back to other engines.
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+
+function which(bin) {
+  return new Promise((resolve) => {
+    execFile("which", [bin], (err, stdout) => {
+      if (err) return resolve(null);
+      const out = String(stdout || "").trim();
+      resolve(out || null);
+    });
+  });
+}
+
+export default {
+  id: "piper",
+
+  async isAvailable(config = {}) {
+    const bin = config.bin || "piper";
+    if (!(await which(bin))) return false;
+    if (config.model && !fs.existsSync(config.model)) return false;
+    return true;
+  },
+
+  async synthesize({ text, voice, outDir, config = {}, format = "wav" }) {
+    if (!text) throw new Error("piper: empty text");
+    const bin = config.bin || "piper";
+    const model = voice || config.model;
+    if (!model) {
+      throw new Error("piper: no model configured (set voice.tts.piper.model in ~/.apx/config.json)");
+    }
+    if (!fs.existsSync(model)) {
+      throw new Error(`piper: model not found at ${model}`);
+    }
+
+    fs.mkdirSync(outDir, { recursive: true });
+    const audioPath = path.join(outDir, `piper-${randomUUID()}.${format === "wav" ? "wav" : "wav"}`);
+
+    const args = ["--model", model, "--output_file", audioPath];
+    if (config.speaker !== undefined && config.speaker !== null && config.speaker !== "") {
+      args.push("--speaker", String(config.speaker));
+    }
+    if (Array.isArray(config.extra_args)) args.push(...config.extra_args.map(String));
+
+    await new Promise((resolve, reject) => {
+      const proc = spawn(bin, args, { stdio: ["pipe", "pipe", "pipe"] });
+      let stderr = "";
+      proc.stderr.on("data", (c) => { stderr += c.toString(); });
+      proc.on("error", reject);
+      proc.on("exit", (code) => {
+        if (code === 0) return resolve();
+        reject(new Error(`piper exited ${code}: ${stderr.slice(0, 300)}`));
+      });
+      proc.stdin.end(text);
+    });
+
+    // Best-effort duration estimate from WAV header.
+    let duration = 0;
+    try {
+      const fd = fs.openSync(audioPath, "r");
+      const head = Buffer.alloc(44);
+      fs.readSync(fd, head, 0, 44, 0);
+      fs.closeSync(fd);
+      const sampleRate = head.readUInt32LE(24);
+      const byteRate = head.readUInt32LE(28);
+      const dataSize = fs.statSync(audioPath).size - 44;
+      if (sampleRate && byteRate) duration = dataSize / byteRate;
+    } catch { /* ignore */ }
+
+    return {
+      audio_path: audioPath,
+      duration_s: duration || null,
+      mime: "audio/wav",
+      provider: "piper",
+    };
+  },
+};

package/src/core/voice/index.js

@@ -0,0 +1,3 @@
+// Public re-exports for the voice subsystem.
+export { synthesize, listProviders, TTS_TMP_DIR, ensureTtsTmpDir } from "./tts.js";
+export { selectTtsEngine, listAvailableTtsEngines, TTS_ENGINE_IDS, AUTO_PREFERENCE } from "./engines/index.js";

package/src/core/voice/tts.js

@@ -0,0 +1,89 @@
+// Unified TTS facade. Callers don't pick the engine — the selector does.
+//
+//   synthesize({ text, voice?, language?, format?, provider? })
+//     → { audio_path, duration_s, mime, provider }
+//
+// All audio files land under ~/.apx/tmp/tts/<uuid>.<ext>. Callers are
+// responsible for cleaning up (Telegram plugin already uses similar temp
+// files via /telegram/send_voice).
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { readConfig } from "../config.js";
+import {
+  selectTtsEngine,
+  listAvailableTtsEngines,
+  resolveMode,
+  resolveChainOrder,
+} from "./engines/index.js";
+
+export const TTS_TMP_DIR = path.join(os.homedir(), ".apx", "tmp", "tts");
+
+export function ensureTtsTmpDir() {
+  fs.mkdirSync(TTS_TMP_DIR, { recursive: true });
+  return TTS_TMP_DIR;
+}
+
+/**
+ * Generate speech audio for `text`. Throws on real errors. Falls back to mock
+ * silently only when provider="auto" AND nothing real is configured.
+ *
+ * @param {object} opts
+ * @param {string} opts.text       Text to speak. Required.
+ * @param {string} [opts.voice]    Engine-specific voice id/path/name.
+ * @param {string} [opts.language] ISO 639-1 hint (rarely used; engines mostly
+ *                                  auto-detect via multilingual models).
+ * @param {string} [opts.format]   "mp3" | "wav" | "ogg" — engine may override.
+ * @param {string} [opts.provider] Force a specific engine (skips selector).
+ * @param {string} [opts.style]    Natural-language speaking-style instruction
+ *                                  (engines that support it, e.g. Gemini, use
+ *                                  it; others ignore it).
+ * @param {object} [opts.globalConfig]  Pass-in for tests; falls back to readConfig().
+ * @returns {Promise<{audio_path, duration_s, mime, provider}>}
+ */
+export async function synthesize({
+  text,
+  voice,
+  language,
+  format,
+  provider,
+  style,
+  globalConfig,
+  signal,
+} = {}) {
+  if (typeof text !== "string" || !text.trim()) {
+    throw new Error("synthesize: text required");
+  }
+  const cfg = globalConfig || readConfig() || {};
+  const { provider: selectedProvider, adapter, engineConfig } = await selectTtsEngine({
+    globalConfig: cfg,
+    provider,
+  });
+
+  const outDir = ensureTtsTmpDir();
+  return adapter.synthesize({
+    text,
+    voice,
+    language,
+    format,
+    style,
+    outDir,
+    config: engineConfig,
+    parentEnginesCfg: cfg.engines,
+    signal,
+  }).then((r) => ({ ...r, provider: r.provider || selectedProvider }));
+}
+
+/** List engines and whether they look usable right now. */
+export async function listProviders(globalConfig) {
+  const cfg = globalConfig || readConfig() || {};
+  const ttsCfg = cfg?.voice?.tts || {};
+  const engines = await listAvailableTtsEngines(cfg);
+  return {
+    configured_provider: ttsCfg.provider || "auto",
+    mode: resolveMode(ttsCfg),
+    order: resolveChainOrder(ttsCfg),
+    engines,
+  };
+}

package/src/{daemon → host/daemon}/apc-runtime-context.js

@@ -16,7 +16,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { generateSessionId } from "../core/session-store.js";
+import { generateSessionId } from "../../core/session-store.js";
 
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 

package/src/host/daemon/api/admin-config.js

@@ -0,0 +1,159 @@
+// GET   /admin/config             redacted view of ~/.apx/config.json
+// PATCH /admin/config             { set?: { "a.b.c": value }, unset?: ["a.b"] }
+//                                  applies + writes the file + reloads in-memory
+//
+// The PATCH variant is intentional: PUT would force the caller to send the
+// whole credentials block, and a UI that forgot one field would wipe secrets.
+// Dotted keys make every edit narrowly-scoped.
+import { readConfig, writeConfig } from "../../../core/config.js";
+import { resolveAgentName } from "../../../core/identity.js";
+import { setDottedKey, unsetDottedKey } from "../project-config.js";
+
+const SECRET_PATHS = [
+  "engines.anthropic.api_key",
+  "engines.openai.api_key",
+  "engines.groq.api_key",
+  "engines.openrouter.api_key",
+  "engines.gemini.api_key",
+  "voice.tts.elevenlabs.api_key",
+  "voice.tts.openai.api_key",
+  "voice.tts.gemini.api_key",
+  "memory.embeddings.openai.api_key",
+  "memory.embeddings.gemini.api_key",
+  "telegram.channels.*.bot_token",
+];
+
+function getDotted(obj, dotted) {
+  const parts = dotted.split(".");
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function secretMarker(value) {
+  if (typeof value !== "string" || !value.length) return value;
+  const suffix = value.slice(-5);
+  return `*** set *** (...${suffix})`;
+}
+
+function isSecretMarker(value) {
+  return typeof value === "string" && value.startsWith("*** set ***");
+}
+
+// Returns a deep copy with `*** set ***` for every present secret value.
+function redact(cfg) {
+  const out = JSON.parse(JSON.stringify(cfg || {}));
+  const mark = (val) => (typeof val === "string" && val.length ? secretMarker(val) : val);
+
+  // Engine api keys + voice tts keys
+  for (const path of SECRET_PATHS) {
+    if (path.includes("*")) continue;
+    const parts = path.split(".");
+    let cur = out;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!cur[parts[i]] || typeof cur[parts[i]] !== "object") { cur = null; break; }
+      cur = cur[parts[i]];
+    }
+    if (cur && cur[parts[parts.length - 1]]) {
+      cur[parts[parts.length - 1]] = mark(cur[parts[parts.length - 1]]);
+    }
+  }
+  // Telegram channels — array, redact bot_token per item (keep the suffix so
+  // the UI can show which token is set, e.g. "*** set *** (...AB12)").
+  const channels = out?.telegram?.channels;
+  if (Array.isArray(channels)) {
+    for (const ch of channels) {
+      if (ch && typeof ch.bot_token === "string" && ch.bot_token.length) {
+        ch.bot_token = mark(ch.bot_token);
+      }
+    }
+  }
+  return out;
+}
+
+function mergeRedactedChannels(nextChannels, priorChannels) {
+  if (!Array.isArray(nextChannels)) return nextChannels;
+  const priorByName = new Map(
+    (Array.isArray(priorChannels) ? priorChannels : [])
+      .filter((c) => c && typeof c.name === "string")
+      .map((c) => [c.name, c])
+  );
+  return nextChannels.map((channel) => {
+    if (!channel || typeof channel !== "object") return channel;
+    const prior = priorByName.get(channel.name);
+    if (prior?.bot_token && (channel.bot_token === undefined || isSecretMarker(channel.bot_token))) {
+      return { ...channel, bot_token: prior.bot_token };
+    }
+    return channel;
+  });
+}
+
+export function register(app, { config, scheduler, plugins }) {
+  app.get("/admin/config", (_req, res) => {
+    try {
+      const fresh = readConfig();
+      res.json({ config: redact(fresh) });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.patch("/admin/config", (req, res) => {
+    const { set, unset } = req.body || {};
+    let cfg;
+    try {
+      cfg = readConfig();
+    } catch (e) {
+      return res.status(500).json({ error: e.message });
+    }
+    if (set && typeof set === "object") {
+      for (const [k, v] of Object.entries(set)) {
+        if (isSecretMarker(v)) continue;
+        if (k === "telegram.channels") {
+          setDottedKey(cfg, k, mergeRedactedChannels(v, cfg.telegram?.channels));
+          continue;
+        }
+        // A literal empty string means "clear this secret" — passthrough.
+        // null also clears.
+        setDottedKey(cfg, k, v);
+      }
+    }
+    if (Array.isArray(unset)) {
+      for (const k of unset) unsetDottedKey(cfg, k);
+    }
+    try {
+      writeConfig(cfg);
+    } catch (e) {
+      return res.status(500).json({ error: e.message });
+    }
+    // Hot-reload in-memory config so subsequent calls see the change.
+    const fresh = readConfig();
+    for (const key of Object.keys(config)) delete config[key];
+    Object.assign(config, fresh);
+    if (scheduler) scheduler.globalConfig = config;
+    if (plugins) plugins.config = config;
+    res.json({ ok: true, config: redact(fresh) });
+  });
+
+  // Convenience: GET the resolved super_agent prompt (used by SettingsScreen)
+  app.get("/admin/super-agent", (_req, res) => {
+    try {
+      const fresh = readConfig();
+      const sa = fresh.super_agent || {};
+      res.json({
+        enabled: !!sa.enabled,
+        name: resolveAgentName(fresh),
+        model: sa.model || "",
+        system: sa.system || "",
+        permission_mode: sa.permission_mode || "permiso",
+        allowed_tools: sa.allowed_tools || [],
+        model_fallback: sa.model_fallback || { enabled: false, models: [], order: [] },
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+}

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

@@ -0,0 +1,72 @@
+// POST /admin/reload     — re-read ~/.apx/config.json into the live config
+//                          object and propagate to scheduler/plugins.
+// POST /admin/shutdown    — clean exit (50 ms grace so the response flushes).
+//
+// Both are auth-gated (the global middleware applies).
+import { readConfig } from "../../../core/config.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function register(app, { scheduler, plugins, config }) {
+  // Daemon logs: errors.jsonl (structured) or apx.log (plain), newest first.
+  app.get("/admin/logs", (req, res) => {
+    const dir = path.join(os.homedir(), ".apx", "logs");
+    const which = req.query.file === "apx" ? "apx.log" : "errors.jsonl";
+    const file = path.join(dir, which);
+    const limit = Math.min(parseInt(req.query.limit, 10) || 200, 2000);
+    if (!fs.existsSync(file)) return res.json({ file: which, entries: [], lines: [] });
+    const all = fs.readFileSync(file, "utf8").split("\n").filter(Boolean);
+    const tail = all.slice(-limit).reverse();
+    if (which === "errors.jsonl") {
+      const entries = tail.map((l) => { try { return JSON.parse(l); } catch { return { raw: l }; } });
+      return res.json({ file: which, entries });
+    }
+    res.json({ file: which, lines: tail });
+  });
+
+  app.post("/admin/reload", (_req, res) => {
+    try {
+      const fresh = readConfig();
+      // Mutate in place so every closure that captured `config` sees the new
+      // values (super-agent, model router, telegram, …).
+      for (const key of Object.keys(config)) delete config[key];
+      Object.assign(config, fresh);
+      if (scheduler) scheduler.globalConfig = config;
+      if (plugins) plugins.config = config;
+      res.json({
+        ok: true,
+        super_agent_model: config.super_agent?.model || null,
+        fallback_order: config.super_agent?.model_fallback?.order || [],
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.post("/admin/shutdown", (_req, res) => {
+    res.json({ ok: true });
+    setTimeout(() => process.exit(0), 50);
+  });
+
+  app.get("/admin/fs/dirs", (req, res) => {
+    const requested = String(req.query.path || os.homedir());
+    const base = path.resolve(requested.replace(/^~(?=$|\/)/, os.homedir()));
+    try {
+      const stat = fs.statSync(base);
+      const dir = stat.isDirectory() ? base : path.dirname(base);
+      const entries = fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+        .map((entry) => path.join(dir, entry.name))
+        .sort((a, b) => a.localeCompare(b));
+      res.json({
+        path: dir,
+        parent: path.dirname(dir) === dir ? null : path.dirname(dir),
+        entries,
+      });
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+}