@agentprojectcontext/apx 1.0.3

package/src/daemon/env-detect.js

@@ -0,0 +1,69 @@
+// Best-effort detection of installed agent CLIs and LLM runners.
+// We just probe the binary with `--version` (or equivalent) and don't fail if
+// it isn't there — caller decides what to do with absence.
+import { runProcess } from "./runtimes/_spawn.js";
+
+const PROBES = [
+  // Coding-agent CLIs (runtimes/)
+  { id: "claude-code", binary: "claude",    args: ["--version"], category: "runtime" },
+  { id: "codex",       binary: "codex",     args: ["--version"], category: "runtime" },
+  { id: "opencode",    binary: "opencode",  args: ["--version"], category: "runtime" },
+  { id: "aider",       binary: "aider",     args: ["--version"], category: "runtime" },
+  { id: "gemini-cli",  binary: "gemini",    args: ["--version"], category: "runtime" },
+  { id: "cursor-agent",binary: "cursor-agent", args: ["--version"], category: "runtime" },
+
+  // Local LLM runners (engines/)
+  { id: "ollama",      binary: "ollama",    args: ["--version"], category: "engine" },
+  { id: "llama-cpp",   binary: "llama",     args: ["--version"], category: "engine" },
+
+  // Tooling
+  { id: "node",        binary: "node",      args: ["--version"], category: "tool" },
+  { id: "python3",     binary: "python3",   args: ["--version"], category: "tool" },
+  { id: "uv",          binary: "uv",        args: ["--version"], category: "tool" },
+  { id: "git",         binary: "git",       args: ["--version"], category: "tool" },
+];
+
+export async function detectAll() {
+  const results = [];
+  for (const p of PROBES) {
+    const r = await probe(p);
+    results.push(r);
+  }
+  return results;
+}
+
+async function probe(p) {
+  const start = Date.now();
+  try {
+    const r = await runProcess({
+      command: p.binary,
+      args: p.args,
+      timeoutMs: 3000,
+    });
+    if (r.exitCode === 0 || (r.stdout && r.stdout.trim())) {
+      return {
+        id: p.id,
+        binary: p.binary,
+        category: p.category,
+        installed: true,
+        version: r.stdout.trim().split("\n")[0] || r.stderr.trim().split("\n")[0] || "unknown",
+        latency_ms: Date.now() - start,
+      };
+    }
+    return {
+      id: p.id,
+      binary: p.binary,
+      category: p.category,
+      installed: false,
+      reason: r.error || `exit ${r.exitCode}`,
+    };
+  } catch (e) {
+    return {
+      id: p.id,
+      binary: p.binary,
+      category: p.category,
+      installed: false,
+      reason: e.message,
+    };
+  }
+}

package/src/daemon/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// APX daemon entry point. Boots config + projects + Express + plugins.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  readConfig,
+  writeConfig,
+  effectiveHost,
+  effectivePort,
+  addProject as addProjectInConfig,
+  PID_PATH,
+  LOG_PATH,
+  APX_HOME,
+} from "../core/config.js";
+import { ProjectManager } from "./db.js";
+import { McpRegistry } from "./mcp-runner.js";
+import { PluginManager } from "./plugins/index.js";
+import { RoutineScheduler } from "./routines.js";
+import { buildApi } from "./api.js";
+import { triggerWakeup } from "./wakeup.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PKG = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "..", "..", "package.json"), "utf8")
+);
+
+// When the daemon is spawned detached by the CLI, stdout is already redirected
+// to ~/.apx/daemon.log via `stdio: ["ignore", out, out]`. So a single
+// process.stdout.write reaches the file once. In foreground (npm start), it
+// still prints to the console. No double-append.
+const log = (msg) => {
+  process.stdout.write(`[${new Date().toISOString()}] ${msg}\n`);
+};
+
+function ensureHome() {
+  fs.mkdirSync(APX_HOME, { recursive: true });
+}
+
+function writePid() {
+  try {
+    fs.writeFileSync(PID_PATH, String(process.pid));
+  } catch {}
+}
+
+function clearPid() {
+  try {
+    if (fs.existsSync(PID_PATH)) fs.unlinkSync(PID_PATH);
+  } catch {}
+}
+
+class RegistryCache {
+  constructor() {
+    this.byProjectId = new Map();
+  }
+  ensure(projectEntry) {
+    if (!this.byProjectId.has(projectEntry.id)) {
+      this.byProjectId.set(projectEntry.id, new McpRegistry(projectEntry.path));
+    }
+    return this.byProjectId.get(projectEntry.id);
+  }
+  for(projectEntry) {
+    return this.ensure(projectEntry);
+  }
+  shutdown() {
+    for (const r of this.byProjectId.values()) r.shutdown();
+    this.byProjectId.clear();
+  }
+}
+
+async function main() {
+  ensureHome();
+
+  const cfg = readConfig();
+  const host = effectiveHost(cfg);
+  const port = effectivePort(cfg);
+
+  const projects = new ProjectManager(cfg);
+  const registries = new RegistryCache();
+
+  // Load registered projects from config.
+  for (const entry of cfg.projects) {
+    try {
+      const p = projects.register(entry.path);
+      registries.ensure(p);
+      log(`loaded project #${p.id} ${p.path}`);
+    } catch (e) {
+      log(`skipping project ${entry.path}: ${e.message}`);
+    }
+  }
+
+  const plugins = new PluginManager({ projects, config: cfg, log, registries });
+  plugins.initAll();
+  plugins.startAll();
+
+  const scheduler = new RoutineScheduler({
+    projects,
+    plugins,
+    globalConfig: cfg,
+    log,
+  });
+  scheduler.start();
+
+  const startedAt = Date.now();
+  const app = buildApi({
+    projects,
+    registries,
+    plugins,
+    scheduler,
+    config: cfg,
+    version: PKG.version,
+    startedAt,
+    addProjectGlobally: (absPath) => {
+      try {
+        const fresh = readConfig();
+        addProjectInConfig(fresh, absPath);
+      } catch (e) {
+        log(`could not persist project to global config: ${e.message}`);
+      }
+    },
+  });
+
+  plugins.installRoutes(app);
+
+  const server = app.listen(port, host, () => {
+    writePid();
+    log(`apx-daemon ${PKG.version} listening on http://${host}:${port}`);
+    log(`projects: ${projects.list().length} | plugins: ${Object.keys(plugins.status()).join(", ") || "(none)"}`);
+    // Fire wake-up message after a short delay so plugins (Telegram) are ready
+    setTimeout(() => triggerWakeup(cfg, log), 3000);
+  });
+
+  function shutdown(signal) {
+    log(`received ${signal}, shutting down...`);
+    scheduler.stop();
+    plugins.stopAll();
+    registries.shutdown();
+    server.close(() => {
+      clearPid();
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 5000).unref();
+  }
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("uncaughtException", (e) => {
+    log(`uncaughtException: ${e.stack || e.message}`);
+  });
+}
+
+main().catch((e) => {
+  log(`fatal: ${e.stack || e.message}`);
+  process.exit(1);
+});

package/src/daemon/mcp-runner.js

@@ -0,0 +1,218 @@
+// 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";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+class McpProcess {
+  constructor({ name, command, args = [], env = {} }) {
+    this.name = name;
+    this.command = command;
+    this.args = args;
+    this.env = env;
+    this.proc = null;
+    this.buffer = "";
+    this.pending = new Map(); // id -> { resolve, reject, timer }
+    this._nextId = 1;
+    this._initPromise = null;
+    this._initialized = false;
+    this._stderrBuf = "";
+  }
+
+  start() {
+    if (this.proc) return;
+    this.proc = spawn(this.command, this.args, {
+      env: { ...process.env, ...this.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.proc.stdout.setEncoding("utf8");
+    this.proc.stderr.setEncoding("utf8");
+
+    this.proc.stdout.on("data", (chunk) => this._onStdout(chunk));
+    this.proc.stderr.on("data", (chunk) => {
+      this._stderrBuf += chunk;
+      if (this._stderrBuf.length > 4096) {
+        this._stderrBuf = this._stderrBuf.slice(-4096);
+      }
+    });
+
+    this.proc.on("exit", (code) => {
+      const err = new Error(
+        `MCP "${this.name}" exited with code ${code}. stderr: ${this._stderrBuf.trim()}`
+      );
+      for (const { reject, timer } of this.pending.values()) {
+        clearTimeout(timer);
+        reject(err);
+      }
+      this.pending.clear();
+      this.proc = null;
+      this._initialized = false;
+      this._initPromise = null;
+    });
+  }
+
+  _onStdout(chunk) {
+    this.buffer += chunk;
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg.id !== undefined && this.pending.has(msg.id)) {
+        const { resolve, reject, timer } = this.pending.get(msg.id);
+        clearTimeout(timer);
+        this.pending.delete(msg.id);
+        if (msg.error) reject(new Error(msg.error.message || "MCP error"));
+        else resolve(msg.result);
+      }
+    }
+  }
+
+  _send(method, params, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.start();
+    const id = this._nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP "${this.name}" call ${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+      try {
+        this.proc.stdin.write(payload + "\n");
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  async _ensureInitialized() {
+    if (this._initialized) return;
+    if (!this._initPromise) {
+      this._initPromise = (async () => {
+        await this._send(
+          "initialize",
+          {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "apx-daemon", version: "0.1.0" },
+          },
+          10_000
+        );
+        try {
+          this.proc.stdin.write(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              method: "notifications/initialized",
+            }) + "\n"
+          );
+        } catch {}
+        this._initialized = true;
+      })();
+    }
+    return this._initPromise;
+  }
+
+  async listTools() {
+    await this._ensureInitialized();
+    return this._send("tools/list", {});
+  }
+
+  async callTool(name, args) {
+    await this._ensureInitialized();
+    return this._send("tools/call", { name, arguments: args || {} });
+  }
+
+  stop() {
+    if (this.proc) {
+      try {
+        this.proc.kill();
+      } catch {}
+      this.proc = null;
+    }
+  }
+}
+
+function entryToMeta(e) {
+  return {
+    name: e.name,
+    command: e.command,
+    args: e.args,
+    env: e.env,
+    url: e.url,
+    headers: e.headers || {},
+    transport: e.transport || "stdio",
+    source: e.source,
+    enabled: e.enabled,
+  };
+}
+
+export class McpRegistry {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.processes = new Map(); // mcp name -> McpProcess
+  }
+
+  list() {
+    return loadAll(this.projectPath).entries.map(entryToMeta);
+  }
+
+  conflicts() {
+    return loadAll(this.projectPath).conflicts;
+  }
+
+  evict(name) {
+    const proc = this.processes.get(name);
+    if (proc) {
+      proc.stop();
+      this.processes.delete(name);
+    }
+  }
+
+  getByName(name) {
+    const e = loadAll(this.projectPath).entries.find((x) => x.name === name);
+    return e ? entryToMeta(e) : null;
+  }
+
+  _ensureProcess(name) {
+    let proc = this.processes.get(name);
+    if (proc && proc.proc) return proc;
+    const meta = this.getByName(name);
+    if (!meta) throw new Error(`MCP "${name}" not registered`);
+    if (!meta.enabled) throw new Error(`MCP "${name}" is disabled`);
+    if (meta.transport === "http" || meta.url) {
+      throw new Error(
+        `MCP "${name}" uses HTTP transport (url=${meta.url}); HTTP/SSE transport arrives in v0.2. Use a stdio MCP for now.`
+      );
+    }
+    if (!meta.command) throw new Error(`MCP "${name}" has no command — invalid registration`);
+    proc = new McpProcess(meta);
+    this.processes.set(name, proc);
+    return proc;
+  }
+
+  async call(name, tool, args) {
+    const proc = this._ensureProcess(name);
+    return proc.callTool(tool, args);
+  }
+
+  async listTools(name) {
+    const proc = this._ensureProcess(name);
+    return proc.listTools();
+  }
+
+  shutdown() {
+    for (const p of this.processes.values()) p.stop();
+    this.processes.clear();
+  }
+}

package/src/daemon/mcp-sources.js

@@ -0,0 +1,114 @@
+// Multi-source MCP discovery: read .apc/mcps.json plus configs from coexisting
+// AI tools (Cursor, Claude Code, VS Code, Roo, etc.) and merge them with APC
+// taking precedence. Read-only — never modifies any external file.
+//
+// References (formats validated against official docs):
+//   .apc/mcps.json                  APC (this project)              key: mcpServers
+//   .mcp.json                       Claude Code (project scope)     key: mcpServers
+//   .cursor/mcp.json                Cursor                          key: mcpServers
+//   .vscode/mcp.json                VS Code / Copilot               key: servers (different!)
+//   .roo/mcp.json                   Roo Code                        key: mcpServers
+//   .gemini/settings.json           Gemini CLI                      key: mcpServers
+//
+// Priority (first wins by name):
+//   1. apc  — .apc/mcps.json
+//   2. claude — .mcp.json
+//   3. cursor — .cursor/mcp.json
+//   4. vscode — .vscode/mcp.json
+//   5. roo    — .roo/mcp.json
+//   6. gemini — .gemini/settings.json
+//
+// 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 path from "node:path";
+
+export const 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" },
+];
+
+export function loadAll(projectRoot) {
+  const merged = new Map(); // name -> entry (first writer wins)
+  const conflicts = []; // [{name, winner, loser, sources}]
+  const sourceMap = {}; // sourceId -> count
+
+  for (const src of SOURCES) {
+    const abs = path.join(projectRoot, src.file);
+    if (!fs.existsSync(abs)) continue;
+    let raw;
+    try {
+      raw = JSON.parse(fs.readFileSync(abs, "utf8"));
+    } catch (e) {
+      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,
+  };
+}
+
+// Read just .apc/mcps.json and return the parsed object (for editing).
+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");
+}

package/src/daemon/plugins/index.js

@@ -0,0 +1,91 @@
+// Plugin registry. Each plugin exports a default object:
+//
+//   {
+//     id,                      // unique identifier (e.g. "telegram")
+//     init(ctx) → instance,    // called once on daemon boot. ctx provides:
+//                              //   projects: ProjectManager
+//                              //   config:   global cfg from ~/.apx/config.json
+//                              //   log:      log function
+//     // instance shape:
+//     //   { start(), stop(), status() → object, routes?(app) }
+//   }
+//
+// Plugins are discovered by static import here. Adding a new plugin = importing
+// it and pushing into PLUGINS.
+import telegramPlugin from "./telegram.js";
+
+export const PLUGINS = [telegramPlugin];
+
+export class PluginManager {
+  constructor({ projects, config, log, registries }) {
+    this.projects = projects;
+    this.config = config;
+    this.log = log;
+    this.registries = registries;
+    this.instances = new Map();
+  }
+
+  initAll() {
+    for (const p of PLUGINS) {
+      try {
+        const inst = p.init({
+          projects: this.projects,
+          config: this.config,
+          log: this.log,
+          plugins: this,        // self-reference so plugins can call siblings
+          registries: this.registries,
+        });
+        this.instances.set(p.id, inst);
+        this.log(`plugin ${p.id} initialized`);
+      } catch (e) {
+        this.log(`plugin ${p.id} init failed: ${e.message}`);
+      }
+    }
+  }
+
+  startAll() {
+    for (const [id, inst] of this.instances) {
+      try {
+        inst.start?.();
+      } catch (e) {
+        this.log(`plugin ${id} start failed: ${e.message}`);
+      }
+    }
+  }
+
+  stopAll() {
+    for (const [, inst] of this.instances) {
+      try {
+        inst.stop?.();
+      } catch {}
+    }
+  }
+
+  get(id) {
+    return this.instances.get(id);
+  }
+
+  status() {
+    const out = {};
+    for (const [id, inst] of this.instances) {
+      try {
+        out[id] = inst.status?.() || { running: !!inst };
+      } catch (e) {
+        out[id] = { error: e.message };
+      }
+    }
+    return out;
+  }
+
+  installRoutes(app) {
+    for (const [id, inst] of this.instances) {
+      if (typeof inst.routes === "function") {
+        try {
+          inst.routes(app);
+        } catch (e) {
+          this.log(`plugin ${id} route install failed: ${e.message}`);
+        }
+      }
+    }
+  }
+}