@agentprojectcontext/apx 1.24.0 → 1.27.1

package/src/core/engines/openrouter.js

@@ -0,0 +1,8 @@
+import { createOpenAiCompatibleEngine } from "./openai-compatible.js";
+
+export default createOpenAiCompatibleEngine({
+  id: "openrouter",
+  defaultBaseUrl: "https://openrouter.ai/api/v1",
+  apiKeyEnv: "OPENROUTER_API_KEY",
+  defaultFallbackModel: "openrouter:meta-llama/llama-3.3-70b-instruct",
+});

package/src/core/git-baseline.js

@@ -0,0 +1,147 @@
+// Git baseline helper for the Code module's "changes" view.
+//
+// A code session records a snapshot of the project's working tree when it
+// starts (the "baseline"). The changes tab later diffs the CURRENT working
+// tree against that baseline, so it shows ONLY what the session touched — not
+// every pre-existing uncommitted change.
+//
+// Both snapshots are taken into a TEMPORARY git index (GIT_INDEX_FILE), so we
+// never touch the user's real index or working tree. `git add -A` honours
+// .gitignore, so ignored paths (node_modules, dist, …) stay out of the diff.
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+
+function git(cwd, args, extraEnv = {}) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, ...extraEnv },
+  });
+}
+
+function gitSafe(cwd, args, extraEnv = {}) {
+  try {
+    return git(cwd, args, extraEnv);
+  } catch {
+    return null;
+  }
+}
+
+export function isGitRepo(cwd) {
+  if (!cwd) return false;
+  const out = gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return (out || "").trim() === "true";
+}
+
+// Best-effort `git init` so the Code "changes" diff has something to compare
+// against. Non-destructive: it only creates an empty .git (no commit, no index
+// changes). Returns true if the directory is a git repo afterwards. Callers
+// must guard against initializing dirs that shouldn't be repos (e.g. the apx
+// home / default project).
+export function initGitRepo(cwd) {
+  if (!cwd) return false;
+  if (isGitRepo(cwd)) return true;
+  gitSafe(cwd, ["init"]);
+  return isGitRepo(cwd);
+}
+
+function headSha(cwd) {
+  const out = gitSafe(cwd, ["rev-parse", "HEAD"]);
+  return out ? out.trim() : null;
+}
+
+// Write the CURRENT working-tree state (tracked + untracked, minus .gitignore)
+// to a fresh tree object using a throwaway index. Returns the tree sha.
+function snapshotTree(cwd) {
+  const tmpIndex = path.join(os.tmpdir(), `apx-code-idx-${randomUUID()}`);
+  const env = { GIT_INDEX_FILE: tmpIndex };
+  try {
+    // Seed the temp index from HEAD when there is one (empty repos have none).
+    if (headSha(cwd)) gitSafe(cwd, ["read-tree", "HEAD"], env);
+    git(cwd, ["add", "-A"], env);
+    return git(cwd, ["write-tree"], env).trim();
+  } finally {
+    try {
+      fs.rmSync(tmpIndex, { force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * Capture a baseline of the project's working tree. Non-mutating.
+ * Returns { baselineCommit, baselineTree } or null when cwd isn't a git repo.
+ */
+export function captureBaseline(cwd) {
+  if (!isGitRepo(cwd)) return null;
+  let baselineTree;
+  try {
+    baselineTree = snapshotTree(cwd);
+  } catch {
+    return null;
+  }
+  // The commit object is best-effort (handy for debugging); the tree alone is
+  // enough to diff against. Force an identity so commit-tree never fails on a
+  // machine without user.name/email configured.
+  const idEnv = {
+    GIT_AUTHOR_NAME: "apx",
+    GIT_AUTHOR_EMAIL: "apx@local",
+    GIT_COMMITTER_NAME: "apx",
+    GIT_COMMITTER_EMAIL: "apx@local",
+  };
+  const parent = headSha(cwd);
+  const args = ["commit-tree", baselineTree, "-m", "apx code session baseline"];
+  if (parent) args.push("-p", parent);
+  const commit = gitSafe(cwd, args, idEnv);
+  return { baselineCommit: commit ? commit.trim() : null, baselineTree };
+}
+
+const STATUS_MAP = { A: "added", M: "modified", D: "deleted", T: "modified" };
+
+/**
+ * Diff the current working tree against a recorded baseline tree.
+ * Returns an array of { path, status, additions, deletions, patch }.
+ * Renames are split into add+delete (--no-renames) so the UI stays simple.
+ */
+export function diffAgainstBaseline(cwd, baselineTree) {
+  if (!baselineTree || !isGitRepo(cwd)) return [];
+  let currentTree;
+  try {
+    currentTree = snapshotTree(cwd);
+  } catch {
+    return [];
+  }
+  if (currentTree === baselineTree) return [];
+
+  const base = ["diff", "--no-color", "--no-renames", baselineTree, currentTree];
+
+  // numstat: "<add>\t<del>\t<path>" (counts are "-" for binary files).
+  const counts = new Map();
+  const numstat = gitSafe(cwd, [...base, "--numstat"]) || "";
+  for (const line of numstat.split("\n")) {
+    if (!line.trim()) continue;
+    const [add, del, ...rest] = line.split("\t");
+    const p = rest.join("\t");
+    if (p) counts.set(p, { additions: add === "-" ? null : Number(add), deletions: del === "-" ? null : Number(del) });
+  }
+
+  // name-status drives the file list + status; patch is fetched per file.
+  const nameStatus = gitSafe(cwd, [...base, "--name-status"]) || "";
+  const files = [];
+  for (const line of nameStatus.split("\n")) {
+    if (!line.trim()) continue;
+    const [code, ...rest] = line.split("\t");
+    const p = rest.join("\t");
+    if (!p) continue;
+    const status = STATUS_MAP[code[0]] || "modified";
+    const patch = gitSafe(cwd, [...base, "--", p]) || "";
+    const c = counts.get(p) || { additions: null, deletions: null };
+    files.push({ path: p, status, additions: c.additions, deletions: c.deletions, patch });
+  }
+  return files;
+}

package/src/core/identity.js

@@ -4,6 +4,14 @@ import os from "node:os";
 
 export const IDENTITY_PATH = path.join(os.homedir(), ".apx", "identity.json");
 
+// Stable machine id for the daemon-level "super-agent" mode. Never tied to the
+// persona name, so renaming the persona (identity.json) doesn't break message
+// attribution / history queries.
+export const SUPERAGENT_ACTOR_ID = "super_agent";
+
+// Shown when no persona is configured yet. Brand of the app, not a persona.
+export const SUPERAGENT_DISPLAY_FALLBACK = "APX";
+
 export function readIdentity() {
   try {
     return JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf8"));
@@ -12,6 +20,19 @@ export function readIdentity() {
   }
 }
 
+// Resolve the super-agent's DISPLAY name (the persona shown to users). Order:
+// identity.json persona → legacy super_agent.name → "APX". This is the single
+// source of truth for "what is the super-agent called"; callers must not read
+// super_agent.name directly. The stable id for storage is SUPERAGENT_ACTOR_ID.
+export function resolveAgentName(globalConfig = {}) {
+  const identity = readIdentity();
+  return (
+    identity?.agent_name ||
+    globalConfig?.super_agent?.name ||
+    SUPERAGENT_DISPLAY_FALLBACK
+  );
+}
+
 export function writeIdentity(fields) {
   const existing = readIdentity() || {};
   const now = new Date().toISOString();

package/src/core/logging.js

@@ -5,7 +5,7 @@ import { APX_HOME } from "./config.js";
 export const LOG_DIR = path.join(APX_HOME, "logs");
 export const ERROR_TRACE_PATH = path.join(LOG_DIR, "errors.jsonl");
 // Unified daemon log. Every module (daemon, telegram, whisper, super-agent,
-// tools, overlay) writes here with one consistent format so the user can
+// tools, desktop) writes here with one consistent format so the user can
 // follow the whole system from a single tail.
 export const APX_LOG_PATH = path.join(LOG_DIR, "apx.log");
 

package/src/core/mcp/index.js

@@ -0,0 +1,14 @@
+export {
+  loadAll,
+  readApfMcps,
+  writeApfMcps,
+  readRuntimeMcps,
+  writeRuntimeMcps,
+  readGlobalMcps,
+  writeGlobalMcps,
+  runtimeMcpsPath,
+  globalMcpsPath,
+  SOURCES,
+  PROJECT_SOURCES,
+} from "./sources.js";
+export { McpRegistry } from "./runner.js";

package/src/{daemon/mcp-runner.js → core/mcp/runner.js}

@@ -1,7 +1,7 @@
 // MCP runner: spawn child MCP processes and proxy JSON-RPC tools/call.
 // Speaks the stdio transport: newline-delimited JSON-RPC 2.0 messages.
 import { spawn } from "node:child_process";
-import { loadAll } from "./mcp-sources.js";
+import { loadAll } from "./sources.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -158,17 +158,29 @@ function entryToMeta(e) {
 }
 
 export class McpRegistry {
-  constructor(projectPath) {
-    this.projectPath = projectPath;
+  // Accepts either the project path string (back-compat) or an object
+  // { projectPath, storagePath } so the runtime scope can be aggregated.
+  constructor(arg) {
+    if (typeof arg === "string" || arg == null) {
+      this.projectPath = arg || null;
+      this.storagePath = null;
+    } else {
+      this.projectPath = arg.projectPath || null;
+      this.storagePath = arg.storagePath || null;
+    }
     this.processes = new Map(); // mcp name -> McpProcess
   }
 
+  _load() {
+    return loadAll(this.projectPath, { storagePath: this.storagePath });
+  }
+
   list() {
-    return loadAll(this.projectPath).entries.map(entryToMeta);
+    return this._load().entries.map(entryToMeta);
   }
 
   conflicts() {
-    return loadAll(this.projectPath).conflicts;
+    return this._load().conflicts;
   }
 
   evict(name) {
@@ -180,7 +192,7 @@ export class McpRegistry {
   }
 
   getByName(name) {
-    const e = loadAll(this.projectPath).entries.find((x) => x.name === name);
+    const e = this._load().entries.find((x) => x.name === name);
     return e ? entryToMeta(e) : null;
   }
 

package/src/core/mcp/sources.js

@@ -0,0 +1,246 @@
+// Multi-source MCP discovery: read MCPs from three primary APX scopes plus
+// configs from coexisting AI tools (Cursor, Claude Code, VS Code, Roo, etc.).
+// All discoverable files are read-only; APX-owned writes target apc / runtime /
+// global only.
+//
+// APX scopes (writable by APX):
+//   1. runtime — <storagePath>/mcps.json (a.k.a. ~/.apx/projects/<apxId>/mcps.json)
+//                Per-project, machine-local, NEVER committed. Holds tokens and
+//                user-specific endpoints. File is chmod 0600.
+//   2. apc     — .apc/mcps.json in the repo. Project-shared, committable.
+//   3. global  — ~/.apx/mcps.json (machine-wide). Shared across projects on
+//                this machine, not committed.
+//
+// Foreign-IDE scopes (read-only, never written by APX):
+//   claude — .mcp.json                     key: mcpServers
+//   cursor — .cursor/mcp.json              key: mcpServers
+//   vscode — .vscode/mcp.json              key: servers (different!)
+//   roo    — .roo/mcp.json                 key: mcpServers
+//   gemini — .gemini/settings.json         key: mcpServers
+//
+// Priority (first wins by name; conflicts are reported):
+//   1. runtime   (highest — per-project secrets win)
+//   2. apc       (project-shared)
+//   3. claude
+//   4. cursor
+//   5. vscode
+//   6. roo
+//   7. gemini
+//   8. global    (lowest — machine-wide fallback)
+//
+// Each entry returns:
+//   { name, source, command?, args?, env?, url?, headers?, enabled, raw }
+// `enabled` is APC's extension. Falls back to !disabled if the source uses that
+// instead, then to true.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const APX_HOME = path.join(os.homedir(), ".apx");
+const GLOBAL_MCPS_FILE = path.join(APX_HOME, "mcps.json");
+const RUNTIME_MCPS_FILENAME = "mcps.json";
+
+// Project-relative sources (file path resolved against projectRoot).
+// `id: 'apc'` is APX's primary project-shared store. The rest are read-only
+// foreign IDE configs included so APC sees what the user already configured.
+export const PROJECT_SOURCES = [
+  { id: "apc",    file: ".apc/mcps.json",      key: "mcpServers" },
+  { id: "claude", file: ".mcp.json",           key: "mcpServers" },
+  { id: "cursor", file: ".cursor/mcp.json",    key: "mcpServers" },
+  { id: "vscode", file: ".vscode/mcp.json",    key: "servers"    },
+  { id: "roo",    file: ".roo/mcp.json",       key: "mcpServers" },
+  { id: "gemini", file: ".gemini/settings.json", key: "mcpServers" },
+];
+
+// SOURCES is the full ordered list (for discovery/check). Runtime path depends
+// on the storagePath of the project; we expose a placeholder entry whose
+// `file` is left as a hint, but the actual read path is computed in loadAll.
+export const SOURCES = [
+  { id: "runtime", file: "~/.apx/projects/<apxId>/mcps.json", key: "mcpServers", scope: "runtime" },
+  ...PROJECT_SOURCES.map((s) => ({ ...s, scope: "project" })),
+  { id: "global",  file: "~/.apx/mcps.json", key: "mcpServers", scope: "global" },
+];
+
+function readJsonSafe(absPath) {
+  if (!absPath) return null;
+  if (!fs.existsSync(absPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(absPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Resolve the runtime mcps.json path for a given project. `storagePath` is the
+// project's ~/.apx/projects/<apxId>/ directory.
+export function runtimeMcpsPath(storagePath) {
+  if (!storagePath) return null;
+  return path.join(storagePath, RUNTIME_MCPS_FILENAME);
+}
+
+export function globalMcpsPath() {
+  return GLOBAL_MCPS_FILE;
+}
+
+// Aggregate all MCP sources for a project, in priority order.
+// Backwards-compatible call signature: loadAll(projectRoot) still works.
+//   loadAll(projectRoot)                          // no runtime
+//   loadAll(projectRoot, { storagePath })         // include runtime if file exists
+export function loadAll(projectRoot, opts = {}) {
+  const storagePath = opts.storagePath || null;
+  const merged = new Map(); // name -> entry (first writer wins)
+  const conflicts = []; // [{name, winner, loser}]
+  const sourceMap = {}; // sourceId -> count
+
+  const pipeline = [];
+
+  // 1. runtime (highest)
+  if (storagePath) {
+    pipeline.push({
+      id: "runtime",
+      abs: runtimeMcpsPath(storagePath),
+      key: "mcpServers",
+    });
+  }
+
+  // 2..N. project-relative sources (apc + IDE configs)
+  if (projectRoot) {
+    for (const src of PROJECT_SOURCES) {
+      pipeline.push({
+        id: src.id,
+        abs: path.join(projectRoot, src.file),
+        key: src.key,
+      });
+    }
+  }
+
+  // last. global
+  pipeline.push({
+    id: "global",
+    abs: GLOBAL_MCPS_FILE,
+    key: "mcpServers",
+  });
+
+  for (const src of pipeline) {
+    const raw = readJsonSafe(src.abs);
+    if (!raw) continue;
+    const dict = raw[src.key] || {};
+    sourceMap[src.id] = 0;
+    for (const [name, server] of Object.entries(dict)) {
+      sourceMap[src.id]++;
+      const entry = normalize(name, server, src.id);
+      if (merged.has(name)) {
+        const winner = merged.get(name);
+        conflicts.push({
+          name,
+          winner: winner.source,
+          loser: src.id,
+        });
+      } else {
+        merged.set(name, entry);
+      }
+    }
+  }
+  return {
+    entries: Array.from(merged.values()),
+    conflicts,
+    sourceCounts: sourceMap,
+  };
+}
+
+function normalize(name, server, sourceId) {
+  const enabled =
+    server.enabled === false
+      ? false
+      : server.disabled === true
+      ? false
+      : true;
+  return {
+    name,
+    source: sourceId,
+    command: server.command || null,
+    args: server.args || [],
+    env: server.env || {},
+    url: server.url || null,
+    headers: server.headers || null,
+    transport: server.url ? "http" : "stdio",
+    enabled,
+    raw: server,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// apc scope (project-shared, .apc/mcps.json)
+// ---------------------------------------------------------------------------
+
+export function readApfMcps(projectRoot) {
+  const p = path.join(projectRoot, ".apc", "mcps.json");
+  if (!fs.existsSync(p)) return { mcpServers: {} };
+  try {
+    const json = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (!json.mcpServers) json.mcpServers = {};
+    return json;
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+
+export function writeApfMcps(projectRoot, json) {
+  const p = path.join(projectRoot, ".apc", "mcps.json");
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(json, null, 2) + "\n");
+}
+
+// ---------------------------------------------------------------------------
+// runtime scope (per-project, ~/.apx/projects/<apxId>/mcps.json)
+// File is chmod 0600 — may contain tokens.
+// ---------------------------------------------------------------------------
+
+export function readRuntimeMcps(storagePath) {
+  if (!storagePath) return { mcpServers: {} };
+  const p = runtimeMcpsPath(storagePath);
+  if (!fs.existsSync(p)) return { mcpServers: {} };
+  try {
+    const json = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (!json.mcpServers) json.mcpServers = {};
+    return json;
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+
+export function writeRuntimeMcps(storagePath, json) {
+  if (!storagePath) throw new Error("writeRuntimeMcps: storagePath required");
+  const p = runtimeMcpsPath(storagePath);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(json, null, 2) + "\n");
+  // Tokens may live in this file — protect it.
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch {
+    // chmod is a best-effort on non-POSIX FS (Windows). Ignore errors.
+  }
+}
+
+// ---------------------------------------------------------------------------
+// global scope (machine-wide, ~/.apx/mcps.json)
+// ---------------------------------------------------------------------------
+
+export function readGlobalMcps() {
+  const p = GLOBAL_MCPS_FILE;
+  if (!fs.existsSync(p)) return { mcpServers: {} };
+  try {
+    const json = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (!json.mcpServers) json.mcpServers = {};
+    return json;
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+
+export function writeGlobalMcps(json) {
+  const p = GLOBAL_MCPS_FILE;
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(json, null, 2) + "\n");
+}

package/src/core/memory/active-threads.js

@@ -0,0 +1,124 @@
+// "Hilos activos en otros canales" — a tiny, recency-based awareness block.
+//
+// Unlike the Memory Broker (semantic RAG + remembered notes), this reads the
+// raw cross-channel message log and surfaces the most recent turn from every
+// channel OTHER than the one the user is on right now, within a short window.
+// It fills the gap where a vague "seguimos?" on the web wouldn't semantically
+// match the deploy thread you had on Telegram 12 minutes ago.
+//
+// Bounded + best-effort: only appears when there's recent cross-channel
+// activity, capped at max_lines bullets. Never throws into the request path.
+
+import fs from "node:fs";
+import path from "node:path";
+import { GLOBAL_MESSAGES_DIR } from "../config.js";
+import { parseDayJsonl } from "../messages-store.js";
+
+const BODY_CAP = 70;
+
+function ago(ts) {
+  const then = Date.parse(ts);
+  if (!Number.isFinite(then)) return "";
+  const mins = Math.max(0, Math.round((Date.now() - then) / 60000));
+  if (mins < 60) return `hace ${mins} min`;
+  const hrs = Math.round(mins / 60);
+  return `hace ${hrs} h`;
+}
+
+// Prefer the last USER turn (most recognizable for "lo de antes"); fall back to
+// the last agent turn. Skip tool/system/compact noise and tiny bodies.
+function lastMeaningfulTurn(records) {
+  const pick = (pred) => {
+    for (let i = records.length - 1; i >= 0; i--) {
+      const r = records[i];
+      if (!r || r.type === "tool" || r.type === "system" || r.type === "compact") continue;
+      if (!pred(r)) continue;
+      const body = String(r.body || "").trim();
+      if (body.length >= 4) return r;
+    }
+    return null;
+  };
+  return (
+    pick((r) => r.type === "user" || r.direction === "in") ||
+    pick(() => true)
+  );
+}
+
+function readChannelRecentTurn(baseDir, channel, sinceMs) {
+  const dir = path.join(baseDir, channel);
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return null;
+  }
+  if (!files.length) return null;
+  // Last 2 day files cover a window that crosses midnight without reading all.
+  let records = [];
+  for (const f of files.slice(-2)) {
+    try {
+      records = records.concat(parseDayJsonl(fs.readFileSync(path.join(dir, f), "utf8")));
+    } catch {
+      /* skip bad file */
+    }
+  }
+  const turn = lastMeaningfulTurn(records);
+  if (!turn) return null;
+  const t = Date.parse(turn.ts);
+  if (!Number.isFinite(t) || t < sinceMs) return null;
+  return turn;
+}
+
+// Build the "# Hilos activos en otros canales" block. Returns "" when there's
+// nothing recent on another channel (or the feature is disabled).
+export function buildActiveThreadsBlock(currentChannel, { config, messagesDir } = {}) {
+  try {
+    const cfg = config?.memory?.active_threads || {};
+    if (cfg.enabled === false) return "";
+    const windowHours = cfg.window_hours || 6;
+    const maxLines = cfg.max_lines || 3;
+    const sinceMs = Date.now() - windowHours * 3600_000;
+    const baseDir = messagesDir || GLOBAL_MESSAGES_DIR;
+
+    let channels;
+    try {
+      channels = fs
+        .readdirSync(baseDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+    } catch {
+      return "";
+    }
+
+    const cur = String(currentChannel || "");
+    const rows = [];
+    for (const ch of channels) {
+      if (ch === cur) continue;
+      const turn = readChannelRecentTurn(baseDir, ch, sinceMs);
+      if (!turn) continue;
+      rows.push({
+        channel: ch,
+        ts: turn.ts,
+        body: String(turn.body || "").replace(/\s+/g, " ").trim(),
+      });
+    }
+    if (!rows.length) return "";
+    rows.sort((a, b) => Date.parse(b.ts) - Date.parse(a.ts));
+
+    const lines = rows.slice(0, maxLines).map((r) => {
+      const body = r.body.length > BODY_CAP ? r.body.slice(0, BODY_CAP - 1).trimEnd() + "…" : r.body;
+      return `• ${r.channel} — ${ago(r.ts)}: "${body}"`;
+    });
+
+    return [
+      "# Hilos activos en otros canales",
+      'Charlas recientes en otras superficies (NO es este chat). Si el usuario dice',
+      '"seguimos" / "lo de antes" / "lo de telegram", probablemente sea uno de estos —',
+      "retomalo naturalmente; usá search_messages para el detalle exacto.",
+      "",
+      ...lines,
+    ].join("\n");
+  } catch {
+    return "";
+  }
+}