@agentprojectcontext/apx 1.15.6 → 1.17.0

package/src/cli-ts/commands/daemon.ts

@@ -0,0 +1,112 @@
+import type { CommandModule, Argv, ArgumentsCamelCase } from "yargs";
+import { getHttp } from "../http.js";
+import { println, error, success, dim } from "../ui.js";
+import { spawn } from "node:child_process";
+
+// ---------- status ----------
+
+const statusCmd: CommandModule = {
+  command: "status",
+  describe: "Show daemon status",
+  handler: async () => {
+    try {
+      const http = await getHttp();
+      const health = (await http.get("/health")) as {
+        status: string; version?: string; uptime_s?: number;
+      };
+      success(`Daemon running  version=${health.version ?? "?"}  uptime=${health.uptime_s ?? "?"}s`);
+    } catch {
+      error("Daemon is not running.");
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- start ----------
+
+const startCmd: CommandModule = {
+  command: "start",
+  describe: "Start the APX daemon in the background",
+  handler: async () => {
+    try {
+      const http = await getHttp();
+      await http.get("/health");
+      println(dim("Daemon is already running."));
+    } catch {
+      const daemon = spawn("apx-daemon", [], {
+        detached: true,
+        stdio: "ignore",
+      });
+      daemon.unref();
+      success("Daemon started.");
+    }
+  },
+};
+
+// ---------- stop ----------
+
+const stopCmd: CommandModule = {
+  command: "stop",
+  describe: "Gracefully stop the APX daemon",
+  handler: async () => {
+    try {
+      const http = await getHttp();
+      await http.post("/admin/shutdown", {});
+      success("Daemon stopped.");
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- logs ----------
+
+const logsCmd: CommandModule = {
+  command: "logs",
+  describe: "Stream daemon logs",
+  builder: (yargs: Argv) =>
+    yargs.option("tail", {
+      alias: "n",
+      type: "number",
+      default: 50,
+      describe: "Number of lines to show",
+    }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const tail = (args.tail as number) ?? 50;
+      const { homedir } = await import("node:os");
+      const { createReadStream } = await import("node:fs");
+      const { createInterface } = await import("node:readline");
+      const logPath = `${homedir()}/.apx/daemon.log`;
+      try {
+        const rl = createInterface({ input: createReadStream(logPath), crlfDelay: Infinity });
+        const lines: string[] = [];
+        for await (const line of rl) lines.push(line);
+        const tailLines = lines.slice(-tail);
+        tailLines.forEach((l) => println(l));
+      } catch {
+        error(`Log file not found: ${logPath}`);
+        process.exit(1);
+      }
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- parent ----------
+
+export const daemonCmd: CommandModule = {
+  command: "daemon",
+  describe: "Manage the APX background daemon",
+  builder: (yargs: Argv) =>
+    yargs
+      .command(statusCmd)
+      .command(startCmd)
+      .command(stopCmd)
+      .command(logsCmd)
+      .demandCommand(1, "Specify a daemon subcommand"),
+  handler: () => {},
+};

package/src/cli-ts/commands/exec.ts

@@ -0,0 +1,109 @@
+import type { CommandModule, Argv, ArgumentsCamelCase } from "yargs";
+import { getHttp, type StreamEvent } from "../http.js";
+import { error } from "../ui.js";
+
+interface GlobalArgs { project?: string }
+
+async function resolveProjectId(project?: string): Promise<string> {
+  const http = await getHttp();
+  const projects = (await http.get("/projects")) as Array<{ id: string; name: string; path: string }>;
+  if (!projects?.length) throw new Error("No projects registered. Run: apx init");
+  if (project) {
+    const match = projects.find(
+      (p) => p.id === project || p.name === project || p.path === project || p.path?.endsWith("/" + project),
+    );
+    if (!match) throw new Error(`Project not found: ${project}`);
+    return match.id;
+  }
+  return projects[0]!.id;
+}
+
+export const execCmd: CommandModule = {
+  command: "exec <agent> [prompt..]",
+  aliases: ["run"],
+  describe: "Run a one-shot prompt through an agent (non-interactive)",
+  builder: (yargs: Argv) =>
+    yargs
+      .positional("agent", { type: "string", demandOption: true, describe: "Agent slug" })
+      .positional("prompt", { type: "string", array: true, describe: "Prompt text" })
+      .option("model", { type: "string", describe: "Override model" })
+      .option("max-tokens", { type: "number", describe: "Max output tokens" })
+      .option("temperature", { type: "number", describe: "Sampling temperature (0–1)" })
+      .option("format", {
+        choices: ["text", "json"] as const,
+        default: "text" as const,
+        describe: "Output format",
+      })
+      .option("stream", {
+        type: "boolean",
+        default: true,
+        describe: "Stream output as it arrives",
+      }),
+  handler: async (
+    args: ArgumentsCamelCase<Record<string, unknown>>,
+  ) => {
+    try {
+      const project = args.project as string | undefined;
+      const agent = args.agent as string;
+      const promptArgs = args.prompt as string[] | undefined;
+      const model = args.model as string | undefined;
+      const maxTokens = args.maxTokens as number | undefined;
+      const temperature = args.temperature as number | undefined;
+      const format = args.format as "text" | "json";
+      const stream = args.stream as boolean;
+
+      // Build prompt from args + stdin
+      let prompt = (promptArgs ?? []).join(" ");
+      if (!process.stdin.isTTY) {
+        const chunks: Buffer[] = [];
+        for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+        const piped = Buffer.concat(chunks).toString().trim();
+        if (piped) prompt = prompt ? prompt + "\n\n" + piped : piped;
+      }
+      if (!prompt) throw new Error("No prompt provided. Pass text as argument or via stdin.");
+
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      const body = {
+        prompt,
+        model,
+        maxTokens,
+        temperature,
+      };
+
+      if (stream) {
+        // Try streaming endpoint first
+        try {
+          const result = await http.streamPost(
+            `/projects/${pid}/super-agent/chat/stream`,
+            { ...body, contextNote: `Agent: ${agent}` },
+            (ev: StreamEvent) => {
+              if (ev.type === "chunk" && typeof ev.chunk === "string") {
+                process.stdout.write(ev.chunk);
+              }
+              if (ev.type === "event" && ev.event === "assistant_text" && typeof (ev as Record<string, unknown>).text === "string") {
+                process.stdout.write((ev as Record<string, unknown>).text as string);
+              }
+            },
+          ) as { text?: string };
+          if (!result?.text) process.stdout.write("\n");
+          return;
+        } catch {
+          // Fall through to non-streaming
+        }
+      }
+
+      const result = (await http.post(`/projects/${pid}/agents/${agent}/exec`, body)) as {
+        text: string; usage?: { input_tokens: number; output_tokens: number };
+      };
+      if (format === "json") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      } else {
+        process.stdout.write(result.text + "\n");
+      }
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};

package/src/cli-ts/commands/mcp.ts

@@ -0,0 +1,235 @@
+import type { CommandModule, Argv, ArgumentsCamelCase } from "yargs";
+import { getHttp } from "../http.js";
+import { println, error, success, dim, highlight, table } from "../ui.js";
+
+interface GlobalArgs { project?: string }
+
+async function resolveProjectId(project?: string): Promise<string> {
+  const http = await getHttp();
+  const projects = (await http.get("/projects")) as Array<{ id: string; name: string; path: string }>;
+  if (!projects?.length) throw new Error("No projects registered. Run: apx init");
+  if (project) {
+    const match = projects.find(
+      (p) => p.id === project || p.name === project || p.path === project || p.path?.endsWith("/" + project),
+    );
+    if (!match) throw new Error(`Project not found: ${project}`);
+    return match.id;
+  }
+  return projects[0]!.id;
+}
+
+// ---------- list ----------
+
+const listCmd: CommandModule = {
+  command: "list",
+  aliases: ["ls"],
+  describe: "List registered MCP servers",
+  handler: async (args: ArgumentsCamelCase<GlobalArgs>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project as string | undefined);
+      const mcps = (await http.get(`/projects/${pid}/mcps`)) as Array<{
+        name: string; transport?: string; enabled?: boolean; source?: string;
+      }>;
+      if (!mcps?.length) { println(dim("No MCP servers configured.")); return; }
+      table(
+        mcps.map((m) => ({
+          Name: m.name,
+          Transport: m.transport || "-",
+          Enabled: m.enabled ? "✓" : "✗",
+          Source: m.source || "-",
+        })),
+        ["Name", "Transport", "Enabled", "Source"],
+      );
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- add ----------
+
+const addCmd: CommandModule = {
+  command: "add <name>",
+  describe: "Register an MCP server",
+  builder: (yargs: Argv) =>
+    yargs
+      .positional("name", { type: "string", demandOption: true, describe: "MCP server name" })
+      .option("command", { alias: "c", type: "string", describe: "Command to launch MCP server" })
+      .option("url", { type: "string", describe: "Remote MCP server URL (for HTTP transport)" })
+      .option("env", {
+        type: "array",
+        string: true,
+        describe: "Environment variables (KEY=VALUE)",
+      })
+      .option("enabled", { type: "boolean", default: true, describe: "Enable the server" }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const project = args.project as string | undefined;
+      const name = args.name as string;
+      const command = args.command as string | undefined;
+      const url = args.url as string | undefined;
+      const env = args.env as string[] | undefined;
+      const enabled = args.enabled as boolean;
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      // Parse env KEY=VALUE pairs
+      const envRecord: Record<string, string> = {};
+      for (const e of env ?? []) {
+        const idx = e.indexOf("=");
+        if (idx > 0) envRecord[e.slice(0, idx)] = e.slice(idx + 1);
+      }
+      const body: Record<string, unknown> = {
+        name,
+        enabled,
+      };
+      if (command) body.command = command;
+      if (url) body.url = url;
+      if (Object.keys(envRecord).length) body.env = envRecord;
+
+      await http.post(`/projects/${pid}/mcps`, body);
+      success(`MCP server registered: ${highlight(name)}`);
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- remove ----------
+
+const removeCmd: CommandModule = {
+  command: "remove <name>",
+  aliases: ["rm"],
+  describe: "Remove an MCP server",
+  builder: (yargs: Argv) =>
+    yargs.positional("name", { type: "string", demandOption: true, describe: "MCP server name" }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const project = args.project as string | undefined;
+      const name = args.name as string;
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      await http.delete(`/projects/${pid}/mcps/${name}`);
+      success(`MCP server removed: ${name}`);
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- enable / disable ----------
+
+const enableCmd: CommandModule = {
+  command: "enable <name>",
+  describe: "Enable an MCP server",
+  builder: (yargs: Argv) =>
+    yargs.positional("name", { type: "string", demandOption: true }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const project = args.project as string | undefined;
+      const name = args.name as string;
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      await http.post(`/projects/${pid}/mcps`, { name, enabled: true });
+      success(`Enabled: ${name}`);
+    } catch (err: unknown) { error(String(err)); process.exit(1); }
+  },
+};
+
+const disableCmd: CommandModule = {
+  command: "disable <name>",
+  describe: "Disable an MCP server",
+  builder: (yargs: Argv) =>
+    yargs.positional("name", { type: "string", demandOption: true }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const project = args.project as string | undefined;
+      const name = args.name as string;
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      await http.post(`/projects/${pid}/mcps`, { name, enabled: false });
+      success(`Disabled: ${name}`);
+    } catch (err: unknown) { error(String(err)); process.exit(1); }
+  },
+};
+
+// ---------- tools ----------
+
+const toolsCmd: CommandModule = {
+  command: "tools <name>",
+  describe: "List tools exposed by an MCP server",
+  builder: (yargs: Argv) =>
+    yargs.positional("name", { type: "string", demandOption: true }),
+  handler: async (args: ArgumentsCamelCase<Record<string, unknown>>) => {
+    try {
+      const project = args.project as string | undefined;
+      const name = args.name as string;
+      const http = await getHttp();
+      const pid = await resolveProjectId(project);
+      const result = (await http.post(`/mcp/run`, {
+        project: pid,
+        name,
+        tool: "list_tools",
+        params: {},
+      })) as { result?: { tools?: Array<{ name: string; description?: string }> } };
+      const tools = result?.result?.tools ?? [];
+      if (!tools.length) { println(dim("No tools found.")); return; }
+      table(
+        tools.map((t) => ({ Tool: t.name, Description: t.description?.slice(0, 60) || "-" })),
+        ["Tool", "Description"],
+      );
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- check ----------
+
+const checkCmd: CommandModule = {
+  command: "check",
+  describe: "Validate MCP configuration",
+  handler: async (args: ArgumentsCamelCase<GlobalArgs>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project as string | undefined);
+      const result = (await http.get(`/projects/${pid}/mcps/check`)) as {
+        conflicts?: string[];
+        entries?: Array<{ name: string; ok: boolean; error?: string }>;
+      };
+      if (result.conflicts?.length) {
+        println("\x1b[93m⚠ Conflicts:\x1b[0m");
+        result.conflicts.forEach((c) => println("  " + c));
+      }
+      result.entries?.forEach((e) => {
+        if (e.ok) success(e.name);
+        else error(`${e.name}: ${e.error}`);
+      });
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- parent ----------
+
+export const mcpCmd: CommandModule = {
+  command: "mcp",
+  describe: "Manage MCP (Model Context Protocol) servers",
+  builder: (yargs: Argv) =>
+    yargs
+      .command(listCmd)
+      .command(addCmd)
+      .command(removeCmd)
+      .command(enableCmd)
+      .command(disableCmd)
+      .command(toolsCmd)
+      .command(checkCmd)
+      .demandCommand(1, "Specify an mcp subcommand"),
+  handler: () => {},
+};

package/src/cli-ts/commands/session.ts

@@ -0,0 +1,224 @@
+import type { CommandModule, Argv, ArgumentsCamelCase } from "yargs";
+import { getHttp } from "../http.js";
+import { println, error, success, dim, bold, table, highlight } from "../ui.js";
+
+interface Session {
+  filename?: string;
+  title?: string;
+  started_at?: string;
+  ended_at?: string;
+  agent?: string;
+  status?: string;
+}
+
+interface GlobalArgs {
+  project?: string;
+}
+
+async function resolveProjectId(project?: string): Promise<string> {
+  const http = await getHttp();
+  const projects = (await http.get("/projects")) as Array<{
+    id: string;
+    name: string;
+    path: string;
+  }>;
+  if (!projects?.length) throw new Error("No projects registered. Run: apx init");
+
+  if (project) {
+    const match = projects.find(
+      (p) =>
+        p.id === project ||
+        p.name === project ||
+        p.path === project ||
+        p.path?.endsWith("/" + project),
+    );
+    if (!match) throw new Error(`Project not found: ${project}`);
+    return match.id;
+  }
+  // Default to first project
+  return projects[0]!.id;
+}
+
+// ---------- list ----------
+
+const listCmd: CommandModule<GlobalArgs, GlobalArgs & { last: number; format: string }> = {
+  command: "list",
+  aliases: ["ls"],
+  describe: "List sessions for the current project",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs
+      .option("last", {
+        alias: "n",
+        type: "number",
+        default: 20,
+        describe: "Number of recent sessions to show",
+      })
+      .option("format", {
+        choices: ["table", "json"] as const,
+        default: "table" as const,
+        describe: "Output format",
+      }),
+  handler: async (args: ArgumentsCamelCase<GlobalArgs & { last: number; format: string }>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project);
+      const sessions = (await http.get(`/projects/${pid}/sessions`)) as Session[];
+      if (!sessions?.length) {
+        println(dim("No sessions found."));
+        return;
+      }
+      const slice = sessions.slice(-args.last);
+      if (args.format === "json") {
+        process.stdout.write(JSON.stringify(slice, null, 2) + "\n");
+        return;
+      }
+      table(
+        slice.map((s) => ({
+          Title: s.title || s.filename || "(no title)",
+          Agent: s.agent || "-",
+          Started: s.started_at ? new Date(s.started_at).toLocaleString() : "-",
+          Status: s.status || "open",
+        })),
+        ["Title", "Agent", "Started", "Status"],
+      );
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- new ----------
+
+const newCmd: CommandModule<GlobalArgs, GlobalArgs & { title?: string; body?: string; agent?: string }> = {
+  command: "new",
+  describe: "Create a new session",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs
+      .option("title", {
+        type: "string",
+        describe: "Session title",
+      })
+      .option("body", {
+        type: "string",
+        describe: "Initial session body / context",
+      })
+      .option("agent", {
+        type: "string",
+        describe: "Agent slug to associate the session with",
+      }),
+  handler: async (args: ArgumentsCamelCase<GlobalArgs & { title?: string; body?: string; agent?: string }>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project);
+      const agentSlug = args.agent || "default";
+      const session = (await http.post(`/projects/${pid}/agents/${agentSlug}/sessions`, {
+        title: args.title || `Session ${new Date().toLocaleDateString()}`,
+        body: args.body,
+      })) as { filename: string; path: string };
+      success(`Session created: ${highlight(session.filename)}`);
+      if (session.path) println(dim(session.path));
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- get / show ----------
+
+const getCmd: CommandModule<GlobalArgs, GlobalArgs & { id: string; body: boolean }> = {
+  command: "get <id>",
+  aliases: ["show"],
+  describe: "Show a session by filename or ID",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs
+      .positional("id", { type: "string", demandOption: true, describe: "Session filename or ID" })
+      .option("body", {
+        type: "boolean",
+        default: false,
+        describe: "Print session body / markdown",
+      }),
+  handler: async (args: ArgumentsCamelCase<GlobalArgs & { id: string; body: boolean }>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project);
+      const session = (await http.get(`/projects/${pid}/sessions/${args.id}`)) as Record<string, unknown>;
+      if (args.body) {
+        process.stdout.write(String(session.body_md || session.body || "") + "\n");
+        return;
+      }
+      process.stdout.write(JSON.stringify(session, null, 2) + "\n");
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- delete ----------
+
+const deleteCmd: CommandModule<GlobalArgs, GlobalArgs & { id: string }> = {
+  command: "delete <id>",
+  aliases: ["rm"],
+  describe: "Delete a session",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs.positional("id", { type: "string", demandOption: true, describe: "Session filename or ID" }),
+  handler: async (args: ArgumentsCamelCase<GlobalArgs & { id: string }>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project);
+      await http.delete(`/projects/${pid}/sessions/${args.id}`);
+      success(`Session deleted: ${args.id}`);
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- compact ----------
+
+const compactCmd: CommandModule<GlobalArgs, GlobalArgs & { id?: string; model?: string }> = {
+  command: "compact [id]",
+  describe: "Summarize and compact a session's conversation history",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs
+      .positional("id", { type: "string", describe: "Session ID (defaults to latest)" })
+      .option("model", { type: "string", describe: "Model to use for summarization" }),
+  handler: async (args: ArgumentsCamelCase<GlobalArgs & { id?: string; model?: string }>) => {
+    try {
+      const http = await getHttp();
+      const pid = await resolveProjectId(args.project);
+      const path = args.id
+        ? `/projects/${pid}/sessions/${args.id}/compact`
+        : `/sessions/${pid}/compact`;
+      const result = (await http.post(path, { model: args.model, project: pid })) as {
+        compacted_turns?: number;
+        summary?: string;
+      };
+      success(`Compacted ${result.compacted_turns ?? "?"} turns.`);
+      if (result.summary) println(dim(result.summary));
+    } catch (err: unknown) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  },
+};
+
+// ---------- parent command ----------
+
+export const sessionCmd: CommandModule<GlobalArgs, GlobalArgs> = {
+  command: "session",
+  aliases: ["sessions"],
+  describe: "Manage APC sessions",
+  builder: (yargs: Argv<GlobalArgs>) =>
+    yargs
+      .command(listCmd as CommandModule)
+      .command(newCmd as CommandModule)
+      .command(getCmd as CommandModule)
+      .command(deleteCmd as CommandModule)
+      .command(compactCmd as CommandModule)
+      .demandCommand(1, "Specify a session subcommand"),
+  handler: () => {},
+};