@agentprojectcontext/apx 1.0.3

package/src/cli/commands/messages.js

@@ -0,0 +1,61 @@
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+// Channels that live in ~/.apx/messages/<channel>/ (global, cross-project).
+// Everything else is project-scoped.
+const GLOBAL_CHANNELS = new Set(["telegram", "direct", "whatsapp"]);
+
+function isGlobalChannel(channel) {
+  return channel && GLOBAL_CHANNELS.has(channel);
+}
+
+export async function cmdMessagesTail(args) {
+  const channel = args.flags.channel && args.flags.channel !== true ? args.flags.channel : null;
+  const n = args.flags.n || args.flags.last || "50";
+  const isGlobal = args.flags.global || isGlobalChannel(channel);
+
+  if (isGlobal) {
+    // Read from global store — no project needed
+    const params = new URLSearchParams({ limit: String(n) });
+    if (channel) params.set("channel", channel);
+    const rows = await http.get(`/messages/global?${params}`);
+    if (rows.length === 0) {
+      console.log("(no messages)");
+      return;
+    }
+    for (const r of rows) {
+      const arrow = r.direction === "in" ? "←" : "→";
+      console.log(`${r.ts}  ${arrow} ${(r.channel || channel || "").padEnd(10)} ${r.author || ""}: ${r.body}`);
+    }
+    return;
+  }
+
+  // Project-scoped
+  const pid = await resolveProjectId(args?.flags?.project);
+  const params = new URLSearchParams({ limit: String(n) });
+  if (args.flags.agent && args.flags.agent !== true) params.set("agent", args.flags.agent);
+  if (channel) params.set("channel", channel);
+  const rows = await http.get(`/projects/${pid}/messages?${params}`);
+  if (rows.length === 0) {
+    console.log("(no messages)");
+    return;
+  }
+  for (const r of rows.reverse()) {
+    const arrow = r.direction === "in" ? "←" : "→";
+    console.log(`${r.ts}  ${arrow} ${r.channel.padEnd(8)} ${r.author || ""}: ${r.body}`);
+  }
+}
+
+export async function cmdMessagesSearch(args) {
+  const q = args._[0];
+  if (!q) throw new Error("apx messages search: missing <query>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const rows = await http.get(`/projects/${pid}/messages/search?q=${encodeURIComponent(q)}`);
+  if (rows.length === 0) {
+    console.log("(no matches)");
+    return;
+  }
+  for (const r of rows) {
+    console.log(`${r.ts}  ${r.channel} ${r.author || ""}: ${r.body}`);
+  }
+}

package/src/cli/commands/plugins.js

@@ -0,0 +1,23 @@
+import { http } from "../http.js";
+
+export async function cmdPluginsList() {
+  const data = await http.get("/plugins");
+  const ids = Object.keys(data);
+  if (ids.length === 0) {
+    console.log("(no plugins loaded)");
+    return;
+  }
+  for (const id of ids) {
+    const s = data[id];
+    console.log(`# ${id}`);
+    console.log(JSON.stringify(s, null, 2));
+    console.log("");
+  }
+}
+
+export async function cmdPluginStatus(args) {
+  const id = args._[0];
+  if (!id) throw new Error("apx plugins status: missing <plugin-id>");
+  const s = await http.get(`/plugins/${id}/status`);
+  console.log(JSON.stringify(s, null, 2));
+}

package/src/cli/commands/project.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import { findApfRoot } from "../../core/parser.js";
+import { http } from "../http.js";
+
+function requireRoot() {
+  const root = findApfRoot();
+  if (!root) {
+    throw new Error("not inside an APC project (run `apx init` first)");
+  }
+  return root;
+}
+
+export async function cmdProjectAdd(args) {
+  const target = args._[0] || requireRoot();
+  const result = await http.post("/projects", { path: path.resolve(target) });
+  console.log(`Registered #${result.id}: ${result.path}`);
+}
+
+export async function cmdProjectList() {
+  const projects = await http.get("/projects");
+  if (projects.length === 0) {
+    console.log("(no projects registered — try `apx project add .`)");
+    return;
+  }
+  console.log("ID\tNAME\t\t\tAGENTS\tPATH");
+  for (const p of projects) {
+    console.log(`${p.id}\t${p.name}\t\t${p.agents}\t${p.path}`);
+  }
+}
+
+export async function cmdProjectRemove(args) {
+  const target = args._[0];
+  if (!target) throw new Error("apx project remove: missing <path|id>");
+  const projects = await http.get("/projects");
+  let id;
+  if (/^\d+$/.test(target)) id = parseInt(target, 10);
+  else {
+    const abs = path.resolve(target);
+    const found = projects.find((p) => p.path === abs);
+    if (!found) throw new Error(`not registered: ${target}`);
+    id = found.id;
+  }
+  await http.delete(`/projects/${id}`);
+  console.log(`Removed project #${id}`);
+}
+
+export async function cmdProjectRebuild(args) {
+  const target = args._[0];
+  let id;
+  if (target) {
+    if (/^\d+$/.test(target)) id = parseInt(target, 10);
+    else {
+      const abs = path.resolve(target);
+      const projects = await http.get("/projects");
+      const found = projects.find((p) => p.path === abs);
+      if (!found) throw new Error(`not registered: ${target}`);
+      id = found.id;
+    }
+  } else {
+    const root = requireRoot();
+    const projects = await http.get("/projects");
+    const found = projects.find((p) => p.path === root);
+    if (!found) throw new Error(`current project not registered — run \`apx project add .\``);
+    id = found.id;
+  }
+  const result = await http.post(`/projects/${id}/rebuild`);
+  console.log(`Rebuilt project #${id}: ${result.agents} agents`);
+}
+
+// Resolve a project id from one of:
+//   numeric id   ("2")
+//   absolute path ("/abs/path/to/project")
+//   relative path (resolved against cwd)
+//   project name ("APX testing sandbox")
+// Falls back to walking up from cwd if `target` is null/undefined.
+export async function resolveProjectId(target) {
+  if (target !== undefined && target !== null && target !== "") {
+    if (typeof target === "number" || /^\d+$/.test(String(target))) {
+      return parseInt(target, 10);
+    }
+    const projects = await http.get("/projects");
+    const tgt = String(target);
+
+    // exact path
+    const abs = path.resolve(tgt);
+    const byPath = projects.find((p) => p.path === abs);
+    if (byPath) return byPath.id;
+
+    // exact name
+    const byName = projects.find((p) => p.name === tgt);
+    if (byName) return byName.id;
+
+    // case-insensitive substring on name OR full path — friendly default
+    const tgtLow = tgt.toLowerCase();
+    const fuzzy = projects.filter(
+      (p) =>
+        p.name.toLowerCase().includes(tgtLow) ||
+        p.path.toLowerCase().includes(tgtLow)
+    );
+    if (fuzzy.length === 1) return fuzzy[0].id;
+    if (fuzzy.length > 1) {
+      throw new Error(
+        `--project "${tgt}" is ambiguous; matches: ${fuzzy.map((p) => `${p.id}/${p.name}`).join(", ")}`
+      );
+    }
+    throw new Error(`--project "${tgt}" not found in registered projects`);
+  }
+
+  // No override: walk up from cwd
+  const root = findApfRoot();
+  if (!root) {
+    const registered = await http.get("/projects").catch(() => []);
+    const hint = registered.length
+      ? `registered projects: ${registered.map((p) => `"${p.name}" (id ${p.id})`).join(", ")}`
+      : "no projects registered yet — run `apx project add <path>` first";
+    throw new Error(`not inside an APC project. Use --project <name|id|path>. ${hint}`);
+  }
+  const projects = await http.get("/projects");
+  const found = projects.find((p) => p.path === root);
+  if (found) return found.id;
+  // auto-register
+  const result = await http.post("/projects", { path: root });
+  return result.id;
+}

package/src/cli/commands/routine.js

@@ -0,0 +1,99 @@
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+function parseSpec(args) {
+  // Build spec from --spec '<json>' or from --K=V pairs
+  if (args.flags.spec && args.flags.spec !== true) {
+    try {
+      return JSON.parse(args.flags.spec);
+    } catch (e) {
+      throw new Error(`--spec is not valid JSON: ${e.message}`);
+    }
+  }
+  const spec = {};
+  for (const [k, v] of Object.entries(args.flags)) {
+    if (["name", "kind", "schedule", "spec", "verbose"].includes(k)) continue;
+    if (v === true) continue;
+    // try to JSON-parse the value (numbers, bools), else keep as string
+    let val = v;
+    try { val = JSON.parse(v); } catch {}
+    spec[k] = val;
+  }
+  return spec;
+}
+
+export async function cmdRoutineList(args = {}) {
+  const pid = await resolveProjectId(args?.flags?.project);
+  const rows = await http.get(`/projects/${pid}/routines`);
+  if (rows.length === 0) {
+    console.log("(no routines)");
+    return;
+  }
+  console.log("NAME".padEnd(20) + " EN " + "KIND".padEnd(11) + " SCHEDULE".padEnd(20) + " NEXT_RUN".padEnd(22) + " LAST");
+  for (const r of rows) {
+    console.log(
+      r.name.padEnd(20) + " " +
+      (r.enabled ? "✓" : "✗").padEnd(2) + " " +
+      (r.kind || "?").padEnd(10) + " " +
+      (r.schedule || "?").padEnd(20) + " " +
+      (r.next_run_at || "—").padEnd(22) + " " +
+      (r.last_status === "ok" ? "✓ " : r.last_status === "error" ? "✗ " : "  ") +
+      (r.last_run_at || "—")
+    );
+  }
+}
+
+export async function cmdRoutineGet(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx routine get: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const r = await http.get(`/projects/${pid}/routines/${name}`);
+  console.log(JSON.stringify(r, null, 2));
+}
+
+export async function cmdRoutineAdd(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx routine add: missing <name>");
+  const kind = args.flags.kind === true ? null : args.flags.kind;
+  const schedule = args.flags.schedule === true ? null : args.flags.schedule;
+  if (!kind || !schedule)
+    throw new Error("apx routine add: --kind and --schedule are required");
+  const spec = parseSpec(args);
+  const pid = await resolveProjectId(args?.flags?.project);
+  const r = await http.post(`/projects/${pid}/routines`, { name, kind, schedule, spec });
+  console.log(`added routine "${r.name}" (${r.kind}, ${r.schedule}) → next ${r.next_run_at}`);
+}
+
+export async function cmdRoutineRemove(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx routine remove: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  await http.delete(`/projects/${pid}/routines/${name}`);
+  console.log(`removed routine "${name}"`);
+}
+
+export async function cmdRoutineEnable(args) {
+  await toggle(args, true);
+}
+
+export async function cmdRoutineDisable(args) {
+  await toggle(args, false);
+}
+
+async function toggle(args, enabled) {
+  const name = args._[0];
+  if (!name) throw new Error(`apx routine ${enabled ? "enable" : "disable"}: missing <name>`);
+  const pid = await resolveProjectId(args?.flags?.project);
+  await http.post(
+    `/projects/${pid}/routines/${name}/${enabled ? "enable" : "disable"}`
+  );
+  console.log(`${enabled ? "enabled" : "disabled"} routine "${name}"`);
+}
+
+export async function cmdRoutineRun(args) {
+  const name = args._[0];
+  if (!name) throw new Error("apx routine run: missing <name>");
+  const pid = await resolveProjectId(args?.flags?.project);
+  const r = await http.post(`/projects/${pid}/routines/${name}/run`);
+  console.log(JSON.stringify(r, null, 2));
+}

package/src/cli/commands/runtime.js

@@ -0,0 +1,64 @@
+import { http } from "../http.js";
+import { resolveProjectId } from "./project.js";
+
+export async function cmdRun(args) {
+  const slug = args._[0];
+  if (!slug) throw new Error("apx run: usage: apx run <agent> --runtime <id> \"<prompt>\"");
+  const runtime = args.flags.runtime === true ? null : args.flags.runtime;
+  if (!runtime) throw new Error("apx run: --runtime required (claude-code | codex | opencode | aider)");
+
+  let prompt = args._.slice(1).join(" ").trim();
+  if (!prompt || prompt === "-") {
+    const fs = await import("node:fs");
+    if (!process.stdin.isTTY) {
+      const chunks = [];
+      const buf = Buffer.alloc(65536);
+      try {
+        while (true) {
+          const n = fs.readSync(0, buf, 0, buf.length);
+          if (!n) break;
+          chunks.push(buf.slice(0, n).toString("utf8"));
+        }
+      } catch {}
+      prompt = chunks.join("").trim();
+    }
+  }
+  if (!prompt) throw new Error("apx run: prompt is empty");
+
+  const pid = await resolveProjectId(args?.flags?.project);
+  const timeoutMs = args.flags.timeout
+    ? parseInt(args.flags.timeout, 10) * 1000
+    : undefined;
+
+  const result = await http.post(
+    `/projects/${pid}/agents/${slug}/runtime`,
+    { runtime, prompt, timeoutMs }
+  );
+
+  if (result.output) process.stdout.write(result.output + "\n");
+  if (process.stderr.isTTY || args.flags.verbose) {
+    process.stderr.write(`\n— ${runtime} | exit ${result.exit_code}`);
+    if (result.external_session_path) {
+      process.stderr.write(` | session: ${result.external_session_path}`);
+    }
+    process.stderr.write("\n");
+  }
+  process.exit(result.exit_code === 0 ? 0 : 1);
+}
+
+export async function cmdEnvDetect() {
+  const probes = await http.get("/env/detect");
+  const groups = { runtime: [], engine: [], tool: [] };
+  for (const p of probes) {
+    (groups[p.category] || groups.tool).push(p);
+  }
+  for (const [cat, items] of Object.entries(groups)) {
+    if (!items.length) continue;
+    console.log(`\n${cat.toUpperCase()}:`);
+    for (const p of items) {
+      const mark = p.installed ? "✓" : "·";
+      const ver = p.installed ? p.version : `(${p.reason || "not found"})`;
+      console.log(`  ${mark} ${p.id.padEnd(14)} ${p.binary.padEnd(14)} ${ver}`);
+    }
+  }
+}