@agentprojectcontext/apx 1.25.0 → 1.27.2

package/src/host/daemon/api.js

@@ -0,0 +1,152 @@
+// Express REST API for APX. See APC docs reference/apx-daemon.
+//
+// Routes are split by domain under ./api/*.js — each module exports
+// `register(app, ctx)`. This file is purely orchestration: middlewares,
+// context construction, mount order, 404 catch-all.
+import express from "express";
+
+import {
+  traceIdMiddleware,
+  buildAuthMiddleware,
+  makeProjectResolver,
+  makeTopProjectResolver,
+} from "./api/shared.js";
+
+import { register as registerTools } from "./api/tools.js";
+import { register as registerHealth } from "./api/health.js";
+import { register as registerProjects } from "./api/projects.js";
+import { register as registerAgents } from "./api/agents.js";
+import { register as registerSessions } from "./api/sessions.js";
+import { register as registerMcps } from "./api/mcps.js";
+import { register as registerMessages } from "./api/messages.js";
+import { register as registerTelegram } from "./api/telegram.js";
+import { register as registerPlugins } from "./api/plugins.js";
+import { register as registerEngines } from "./api/engines.js";
+import { register as registerExec } from "./api/exec.js";
+import { register as registerSuperAgent } from "./api/super-agent.js";
+import { register as registerCode } from "./api/code.js";
+import { register as registerConversations } from "./api/conversations.js";
+import { register as registerConnections } from "./api/connections.js";
+import { register as registerRuntimes } from "./api/runtimes.js";
+import { register as registerRoutines } from "./api/routines.js";
+import { register as registerArtifacts } from "./api/artifacts.js";
+import { register as registerTasks } from "./api/tasks.js";
+import { register as registerConfig } from "./api/config.js";
+import { register as registerRun } from "./api/run.js";
+import { register as registerTopLevel } from "./api/top-level.js";
+import { register as registerSessionsSearch } from "./api/sessions-search.js";
+import { register as registerTranscribe } from "./api/transcribe.js";
+import { register as registerTts } from "./api/tts.js";
+import { register as registerEmbeddings } from "./api/embeddings.js";
+import { register as registerVoice } from "./api/voice.js";
+import { register as registerDesktop } from "./api/desktop.js";
+import { register as registerDeck } from "./api/deck.js";
+import { register as registerPairing } from "./api/pairing.js";
+import { register as registerAdmin } from "./api/admin.js";
+import { register as registerAdminConfig } from "./api/admin-config.js";
+import { register as registerIdentity } from "./api/identity.js";
+import { register as registerWeb } from "./api/web.js";
+
+export function buildApi({
+  projects,
+  registries,
+  plugins,
+  scheduler,
+  version,
+  startedAt,
+  addProjectGlobally,
+  config,
+  token,
+  tokenStore,
+}) {
+  const telegram = plugins?.get("telegram");
+  const app = express();
+
+  // ---- Global middleware -------------------------------------------
+  app.use(express.json({ limit: "2mb" }));
+  app.use(traceIdMiddleware);
+  // Prefer the multi-token store when provided (production path); fall
+  // back to the single `token` argument for legacy callers and tests
+  // that haven't migrated yet.
+  if (tokenStore) app.use(buildAuthMiddleware(tokenStore));
+  else if (token) app.use(buildAuthMiddleware(token));
+
+  // ---- Shared resolvers (closed over `projects`) -------------------
+  const project = makeProjectResolver(projects);
+  const resolveTopProject = makeTopProjectResolver(projects);
+
+  // ---- Context passed to every domain register() -------------------
+  const ctx = {
+    express,
+    projects,
+    registries,
+    plugins,
+    scheduler,
+    telegram,
+    version,
+    startedAt,
+    addProjectGlobally,
+    config,
+    project,
+    resolveTopProject,
+    token,
+    tokenStore,
+  };
+
+  // ---- Tool routers — must mount BEFORE wildcard registry below ----
+  registerTools(app, ctx);
+
+  // ---- Health (unauthenticated) ------------------------------------
+  registerHealth(app, ctx);
+
+  // ---- Projects + per-project surfaces -----------------------------
+  registerProjects(app, ctx);
+  registerAgents(app, ctx);
+  registerSessions(app, ctx);
+  registerMcps(app, ctx);
+  registerMessages(app, ctx);
+  registerEngines(app, ctx);
+  registerExec(app, ctx);
+  registerSuperAgent(app, ctx);
+  registerCode(app, ctx);
+  registerConversations(app, ctx);
+  registerConnections(app, ctx);
+  registerRuntimes(app, ctx);
+  registerRoutines(app, ctx);
+  registerArtifacts(app, ctx);
+  registerTasks(app, ctx);
+  registerConfig(app, ctx);
+
+  // ---- Top-level shortcuts (MCP server clients) --------------------
+  registerRun(app, ctx);
+  registerTopLevel(app, ctx);
+  registerSessionsSearch(app, ctx);
+
+  // ---- Channels & plugin surfaces ----------------------------------
+  registerTelegram(app, ctx);
+  registerPlugins(app, ctx);
+  registerTranscribe(app, ctx);
+  registerTts(app, ctx);
+  registerEmbeddings(app, ctx);
+  registerVoice(app, ctx);
+  registerDesktop(app, ctx);
+  registerDeck(app, ctx);
+  registerPairing(app, ctx);
+
+  // ---- Admin -------------------------------------------------------
+  registerAdmin(app, ctx);
+  registerAdminConfig(app, ctx);
+  registerIdentity(app, ctx);
+
+  // ---- Web admin panel (static SPA, must mount before 404) ---------
+  // Serves src/interfaces/web/dist when present + the /admin/web-token
+  // localhost-only token endpoint. No-op until the panel is built.
+  registerWeb(app, ctx);
+
+  // ---- 404 catch-all (MUST be last) --------------------------------
+  app.use((req, res) =>
+    res.status(404).json({ error: `no route ${req.method} ${req.path}` })
+  );
+
+  return app;
+}

package/src/{daemon → host/daemon}/compact.js

@@ -25,7 +25,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseConversation } from "./conversations.js";
-import { callEngine } from "./engines/index.js";
+import { callEngine } from "../../core/engines/index.js";
 
 const KEEP_LAST = 6;
 

package/src/{daemon → host/daemon}/db.js

@@ -2,15 +2,15 @@
 // Projects are identified by path; no SQLite — filesystem is the source of truth.
 import fs from "node:fs";
 import path from "node:path";
-import { appendMessageToFs } from "../core/messages-store.js";
+import { appendMessageToFs } from "../../core/messages-store.js";
 import { effectiveConfig } from "./project-config.js";
-import { readAgents } from "../core/parser.js";
-import { getOrCreateApxId } from "../core/scaffold.js";
+import { readAgents } from "../../core/parser.js";
+import { getOrCreateApxId } from "../../core/scaffold.js";
 import {
   ensureProjectStorage,
   DEFAULT_PROJECT_ID,
   DEFAULT_PROJECT_STORE,
-} from "../core/config.js";
+} from "../../core/config.js";
 
 export class ProjectManager {
   constructor(globalConfig = {}) {
@@ -106,13 +106,27 @@ export class ProjectManager {
   list() {
     return Array.from(this.byId.values()).map((e) => {
       let name = path.basename(e.path);
+      // Tipología del proyecto: personal | company | app | software | other.
+      // El field es opcional en .apc/project.json; default = "other". El
+      // panel web lo usa para elegir ícono y agrupar; el daemon no le pone
+      // semántica especial. "default" es reservado para el proyecto id=0.
+      let kind = e.id === 0 ? "default" : "other";
       try {
         const meta = JSON.parse(
           fs.readFileSync(path.join(e.path, ".apc", "project.json"), "utf8")
         );
         if (meta.name) name = meta.name;
+        if (typeof meta.kind === "string" && meta.kind.trim()) {
+          kind = meta.kind.trim();
+        }
       } catch {}
-      return { id: e.id, path: e.path, name, agents: readAgents(e.path).length };
+      return {
+        id: e.id,
+        path: e.path,
+        name,
+        kind,
+        agents: readAgents(e.path).length,
+      };
     });
   }
 

package/src/{daemon/overlay-ws.js → host/daemon/desktop-ws.js}

@@ -1,16 +1,16 @@
-// Singleton WebSocket hub for the overlay channel.
-// Imported by api.js (to register connections) and by plugins/overlay.js (to broadcast).
+// Singleton WebSocket hub for the desktop channel.
+// Imported by api.js (to register connections) and by plugins/desktop.js (to broadcast).
 
 const _clients = new Set(); // Set<WebSocket>
-let _messageHandler = null; // (ws, data) => void — set by overlay plugin
+let _messageHandler = null; // (ws, data) => void — set by desktop plugin
 
-export const overlayClients = _clients;
+export const desktopClients = _clients;
 
-export function setOverlayMessageHandler(fn) {
+export function setDesktopMessageHandler(fn) {
   _messageHandler = fn;
 }
 
-export function registerOverlayClient(ws) {
+export function registerDesktopClient(ws) {
   _clients.add(ws);
   ws.on("close", () => _clients.delete(ws));
   ws.on("error", () => _clients.delete(ws));
@@ -23,7 +23,7 @@ export function registerOverlayClient(ws) {
   });
 }
 
-export function broadcastOverlay(msg) {
+export function broadcastDesktop(msg) {
   const payload = typeof msg === "string" ? msg : JSON.stringify(msg);
   for (const ws of _clients) {
     try {

package/src/host/daemon/engine-sessions.js

@@ -0,0 +1,245 @@
+// Read-only helpers for locating + summarising sessions stored by external
+// engines (Claude Code, Codex) and APX itself. Lives in the daemon so super-
+// agent tools (call_runtime, etc.) can pull "what was that prior session
+// about?" context without depending on the CLI module tree.
+//
+// Mirrors a subset of src/interfaces/cli/commands/sessions.js — kept narrow on
+// purpose: only enough to (a) find a session by id across engines and (b) read
+// title + last-prompt so the runtime gets context when resuming.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const homeDir = (opts) => (opts && opts.home) || os.homedir();
+
+function encodeClaudeProjectPath(cwd) {
+  return String(cwd || "").replace(/[^A-Za-z0-9]/g, "-");
+}
+
+function safeStatMtime(p) {
+  try {
+    return fs.statSync(p).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+// Walk every project folder under ~/.claude/projects looking for <id>.jsonl.
+export function findClaudeSessionById(id, opts = {}) {
+  const root = path.join(homeDir(opts), ".claude", "projects");
+  if (!fs.existsSync(root)) return null;
+  let entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch {
+    return null;
+  }
+  for (const name of entries) {
+    const file = path.join(root, name, `${id}.jsonl`);
+    if (fs.existsSync(file)) {
+      return {
+        engine: "claude",
+        id,
+        path: file,
+        cwd: name,
+        mtime: safeStatMtime(file),
+      };
+    }
+  }
+  return null;
+}
+
+// Walk ~/.codex/sessions/YYYY/MM/DD/ looking for a rollout file whose header
+// claims the given id.
+export function findCodexSessionById(id, opts = {}) {
+  const root = path.join(homeDir(opts), ".codex", "sessions");
+  if (!fs.existsSync(root)) return null;
+  let hit = null;
+  const walk = (dir) => {
+    if (hit) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (hit) return;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!e.name.startsWith("rollout-") || !e.name.endsWith(".jsonl")) continue;
+      let head;
+      try {
+        const fd = fs.openSync(full, "r");
+        const buf = Buffer.alloc(8192);
+        const n = fs.readSync(fd, buf, 0, buf.length, 0);
+        fs.closeSync(fd);
+        head = buf.subarray(0, n).toString("utf8");
+      } catch {
+        continue;
+      }
+      const m = head.match(/"id":"([^"]+)"/);
+      if (m && m[1] === id) {
+        hit = {
+          engine: "codex",
+          id,
+          path: full,
+          cwd: (head.match(/"cwd":"([^"]+)"/) || [])[1] || null,
+          mtime: safeStatMtime(full),
+        };
+        return;
+      }
+    }
+  };
+  walk(root);
+  return hit;
+}
+
+// Locate an APX-native session inside ~/.apx/projects/*/agents/*/sessions/.
+export function findApxSessionById(id, opts = {}) {
+  const projectsRoot = path.join(homeDir(opts), ".apx", "projects");
+  if (!fs.existsSync(projectsRoot)) return null;
+  let projectIds;
+  try {
+    projectIds = fs.readdirSync(projectsRoot);
+  } catch {
+    return null;
+  }
+  for (const projectId of projectIds) {
+    const agentsDir = path.join(projectsRoot, projectId, "agents");
+    if (!fs.existsSync(agentsDir)) continue;
+    let slugs;
+    try {
+      slugs = fs.readdirSync(agentsDir);
+    } catch {
+      continue;
+    }
+    for (const slug of slugs) {
+      const sdir = path.join(agentsDir, slug, "sessions");
+      let files;
+      try {
+        files = fs.readdirSync(sdir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith(".md")) continue;
+        const baseId = f.slice(0, -3);
+        const file = path.join(sdir, f);
+        if (baseId === id) {
+          return {
+            engine: "apx",
+            id,
+            path: file,
+            mtime: safeStatMtime(file),
+            agentSlug: slug,
+            apxId: projectId,
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// Try every implemented engine in order; first hit wins. Returns null if no
+// engine knows the id. Callers that need collision detection should call the
+// per-engine helpers directly.
+export function findEngineSessionById(id, opts = {}) {
+  return (
+    findClaudeSessionById(id, opts) ||
+    findCodexSessionById(id, opts) ||
+    findApxSessionById(id, opts)
+  );
+}
+
+// Pull a short summary of an external session: title (aiTitle / thread_name /
+// frontmatter title) + last user prompt where we can find it. Used to seed a
+// runtime "resume" call with context.
+export function readEngineSessionContext(meta) {
+  if (!meta || !meta.engine || !meta.path) return null;
+  if (meta.engine === "claude") return readClaudeContext(meta.path);
+  if (meta.engine === "codex") return readCodexContext(meta.path);
+  if (meta.engine === "apx") return readApxContext(meta.path);
+  return null;
+}
+
+function readClaudeContext(file) {
+  let title = null;
+  let lastPrompt = null;
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    if (!line.includes('"aiTitle"') && !line.includes('"lastPrompt"')) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (d.type === "ai-title" && d.aiTitle) title = d.aiTitle;
+    else if (d.type === "last-prompt" && d.lastPrompt) lastPrompt = d.lastPrompt;
+  }
+  return { title, lastPrompt };
+}
+
+function readCodexContext(file) {
+  let title = null;
+  let lastPrompt = null;
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    let d;
+    try {
+      d = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!title) {
+      title = d?.payload?.thread_name || d?.thread_name || null;
+    }
+    const role = d?.payload?.role || d?.role;
+    const content = d?.payload?.content || d?.content;
+    if (role === "user" && typeof content === "string" && content.trim()) {
+      lastPrompt = content.trim();
+    }
+  }
+  return { title, lastPrompt };
+}
+
+function readApxContext(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  let title = null;
+  if (text.startsWith("---\n")) {
+    const end = text.indexOf("\n---", 4);
+    if (end !== -1) {
+      for (const line of text.slice(4, end).split("\n")) {
+        const m = line.match(/^title:\s*(.*)$/);
+        if (m) {
+          title = m[1].trim();
+          break;
+        }
+      }
+    }
+  }
+  return { title, lastPrompt: null };
+}

package/src/{daemon → host/daemon}/index.js

@@ -14,20 +14,22 @@ import {
   LOG_PATH,
   APX_HOME,
   TOKEN_PATH,
-} from "../core/config.js";
+} from "../../core/config.js";
 import { ProjectManager } from "./db.js";
-import { McpRegistry } from "./mcp-runner.js";
+import { McpRegistry } from "../../core/mcp/runner.js";
 import { PluginManager } from "./plugins/index.js";
 import { RoutineScheduler } from "./routines.js";
 import { buildApi } from "./api.js";
+import { createTokenStore } from "./token-store.js";
 import { triggerWakeup } from "./wakeup.js";
-import { registerOverlayClient } from "./overlay-ws.js";
-import { log as logToUnified } from "../core/logging.js";
+import { registerDesktopClient } from "./desktop-ws.js";
+import { log as logToUnified } from "../../core/logging.js";
+import { initMemory, stopMemory } from "../../core/memory/index.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PKG = JSON.parse(
-  fs.readFileSync(path.join(__dirname, "..", "..", "package.json"), "utf8")
+  fs.readFileSync(path.join(__dirname, "..", "..", "..", "package.json"), "utf8")
 );
 
 // When the daemon is spawned detached by the CLI, stdout is already redirected
@@ -125,7 +127,13 @@ class RegistryCache {
   }
   ensure(projectEntry) {
     if (!this.byProjectId.has(projectEntry.id)) {
-      this.byProjectId.set(projectEntry.id, new McpRegistry(projectEntry.path));
+      this.byProjectId.set(
+        projectEntry.id,
+        new McpRegistry({
+          projectPath: projectEntry.path,
+          storagePath: projectEntry.storagePath || null,
+        })
+      );
     }
     return this.byProjectId.get(projectEntry.id);
   }
@@ -175,6 +183,8 @@ async function main() {
     log,
   });
 
+  const tokenStore = createTokenStore({ masterToken: token });
+
   const startedAt = Date.now();
   const app = buildApi({
     projects,
@@ -183,6 +193,7 @@ async function main() {
     scheduler,
     config: cfg,
     token,
+    tokenStore,
     version: PKG.version,
     startedAt,
     addProjectGlobally: (absPath) => {
@@ -203,18 +214,23 @@ async function main() {
     log(`projects: ${projects.list().length} | plugins: ${Object.keys(plugins.status()).join(", ") || "(none)"}`);
     plugins.startAll();
     scheduler.start();
+    // Cross-channel memory: ensure ~/.apx/memory.md exists, open the vector
+    // store, and start the incremental RAG indexer. Best-effort — never blocks
+    // boot and never throws into the daemon.
+    initMemory({ config: cfg, log }).catch((e) => log(`memory: init failed: ${e?.message || e}`));
     // Fire wake-up message after a short delay so plugins (Telegram) are ready
     setTimeout(() => triggerWakeup(cfg, log), 3000);
-    // Preload whisper-server in the background so first overlay transcription is fast.
+    // Preload whisper-server in the background so first desktop transcription is fast.
     // Adopts an existing one if already on the port; otherwise spawns fresh.
     import("./transcription.js").then(({ preloadWhisperServer }) => {
       preloadWhisperServer((m) => log(m));
     }).catch(() => {});
   });
 
-  // Attach WebSocket upgrade for overlay channel on /overlay/ws
+  // Attach WebSocket upgrade for the desktop channel on /desktop/ws
+  // (legacy /overlay/ws still accepted for one release).
   server.on("upgrade", async (req, socket, head) => {
-    if (req.url !== "/overlay/ws") { socket.destroy(); return; }
+    if (req.url !== "/desktop/ws" && req.url !== "/overlay/ws") { socket.destroy(); return; }
     // Lazy-import ws to avoid hard dep on startup
     let WebSocketServer;
     try { ({ WebSocketServer } = await import("ws")); } catch {
@@ -222,7 +238,7 @@ async function main() {
     }
     const wss = new WebSocketServer({ noServer: true });
     wss.handleUpgrade(req, socket, head, (ws) => {
-      registerOverlayClient(ws);
+      registerDesktopClient(ws);
     });
   });
 
@@ -238,6 +254,7 @@ async function main() {
     log(`received ${signal}, shutting down...`);
     scheduler.stop();
     plugins.stopAll();
+    stopMemory();
     registries.shutdown();
     // Best-effort shutdown of whisper-server subprocess.
     import("./transcription.js").then(({ shutdownWhisperServer }) => {