@anhlp/alp-client 0.0.0-stage → 0.10.0

package/dist/mcp-probe.js

@@ -0,0 +1,144 @@
+// packages/client/src/mcp-probe.js
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+var PROTOCOL = "2025-06-18";
+var client = { name: "alp", version: "1" };
+async function probeMcp(server, { cwd, timeoutMs = 15e3 } = {}) {
+  const session = server.url ? await httpSession(server, timeoutMs) : stdioSession(server, cwd, timeoutMs);
+  try {
+    const init = await session.request("initialize", { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: client });
+    await session.notify("notifications/initialized");
+    const tools = [];
+    let cursor;
+    for (let page = 0; page < 20; page++) {
+      const result = await session.request("tools/list", cursor ? { cursor } : {});
+      for (const tool of result.tools ?? []) tools.push({ name: tool.name, ...tool.description ? { description: tool.description } : {} });
+      cursor = result.nextCursor;
+      if (!cursor) break;
+    }
+    return { ...init.serverInfo ? { server: { name: init.serverInfo.name, version: init.serverInfo.version } } : {}, tools };
+  } finally {
+    await session.close();
+  }
+}
+function stdioSession(server, cwd, timeoutMs) {
+  const child = spawn(server.command, server.args ?? [], { cwd: server.cwd ?? cwd, env: { ...process.env, ...server.env ?? {} }, stdio: ["pipe", "pipe", "pipe"], detached: true });
+  const signal = (name) => {
+    try {
+      process.kill(-child.pid, name);
+    } catch {
+      child.kill(name);
+    }
+  };
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < 4e3) stderr += chunk;
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let exited;
+  const failAll = (error) => {
+    for (const { reject } of pending.values()) reject(error);
+    pending.clear();
+  };
+  child.on("error", (error) => {
+    exited = error;
+    failAll(error);
+  });
+  child.on("exit", (code) => {
+    exited = new Error(`${server.command} exited (${code ?? "signal"})${stderr.trim() ? `: ${stderr.trim().split("\n").slice(-3).join(" ")}` : ""}`);
+    failAll(exited);
+  });
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const waiting = pending.get(message.id);
+    if (!waiting) return;
+    pending.delete(message.id);
+    if (message.error) waiting.reject(new Error(`${message.error.message ?? "MCP error"} (${message.error.code})`));
+    else waiting.resolve(message.result ?? {});
+  });
+  child.stdin.on("error", () => {
+  });
+  let id = 0;
+  return {
+    request(method, params) {
+      if (exited) return Promise.reject(exited);
+      const current = ++id;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(current);
+          reject(new Error(`${method} got no answer within ${timeoutMs / 1e3} s`));
+        }, timeoutMs);
+        pending.set(current, { resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        }, reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        } });
+        child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: current, method, params }) + "\n");
+      });
+    },
+    async notify(method) {
+      if (!exited) child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
+    },
+    async close() {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      const done = new Promise((resolve) => child.once("exit", resolve));
+      child.stdin.end();
+      signal("SIGTERM");
+      const timer = setTimeout(() => signal("SIGKILL"), 2e3);
+      await done;
+      clearTimeout(timer);
+    }
+  };
+}
+async function httpSession(server, timeoutMs) {
+  let sessionId;
+  let id = 0;
+  const post = async (body) => {
+    const response = await fetch(server.url, {
+      method: "POST",
+      headers: { ...server.headers ?? {}, "content-type": "application/json", accept: "application/json, text/event-stream", ...sessionId ? { "mcp-session-id": sessionId } : {}, "mcp-protocol-version": PROTOCOL },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    sessionId = response.headers.get("mcp-session-id") ?? sessionId;
+    if (!response.ok) throw new Error(`${server.url} answered ${response.status} ${response.statusText}`);
+    return response;
+  };
+  return {
+    async request(method, params) {
+      const current = ++id;
+      const response = await post({ jsonrpc: "2.0", id: current, method, params });
+      const text = await response.text();
+      const messages = (response.headers.get("content-type") ?? "").includes("text/event-stream") ? text.split("\n").filter((line) => line.startsWith("data:")).map((line) => {
+        try {
+          return JSON.parse(line.slice(5));
+        } catch {
+          return void 0;
+        }
+      }) : [JSON.parse(text)];
+      const message = messages.find((entry) => entry?.id === current);
+      if (!message) throw new Error(`${method}: no answer in the response`);
+      if (message.error) throw new Error(`${message.error.message ?? "MCP error"} (${message.error.code})`);
+      return message.result ?? {};
+    },
+    async notify(method) {
+      await post({ jsonrpc: "2.0", method });
+    },
+    async close() {
+      if (sessionId) await fetch(server.url, { method: "DELETE", headers: { ...server.headers ?? {}, "mcp-session-id": sessionId }, signal: AbortSignal.timeout(timeoutMs) }).catch(() => {
+      });
+    }
+  };
+}
+export {
+  probeMcp,
+  stdioSession
+};

package/dist/prompt.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A select box in the terminal: ↑/↓ (or k/j) move, Enter picks, Ctrl-C or Esc cancels.
+ * Choices are { label, value, hint? }; `initial` is the value highlighted first.
+ * @template T
+ * @param {{ message: string, choices: Array<{ label: string, value: T, hint?: string }>, initial?: T }} question
+ * @param {{ input?: NodeJS.ReadStream, output?: NodeJS.WriteStream }} [io]
+ * @returns {Promise<T>}
+ */
+export function select<T>({ message, choices, initial }: {
+    message: string;
+    choices: Array<{
+        label: string;
+        value: T;
+        hint?: string;
+    }>;
+    initial?: T;
+}, { input, output }?: {
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+}): Promise<T>;
+/**
+ * A line of text, for a value the list does not offer.
+ * @param {string} message
+ * @param {{ input?: NodeJS.ReadStream, output?: NodeJS.WriteStream }} [io]
+ */
+export function text(message: string, { input, output }?: {
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+}): Promise<string>;
+export class Cancelled extends Error {
+    constructor();
+}

package/dist/prompt.js

@@ -0,0 +1,59 @@
+// packages/client/src/prompt.js
+import { emitKeypressEvents } from "node:readline";
+var dim = (text2) => `\x1B[2m${text2}\x1B[22m`;
+var cyan = (text2) => `\x1B[36m${text2}\x1B[39m`;
+var Cancelled = class extends Error {
+  constructor() {
+    super("Setup cancelled.");
+  }
+};
+function select({ message, choices, initial }, { input = process.stdin, output = process.stdout } = {}) {
+  let index = Math.max(0, choices.findIndex((choice) => choice.value === initial));
+  let drawn = 0;
+  const draw = () => {
+    if (drawn) output.write(`\x1B[${drawn}A\x1B[0J`);
+    const lines = [`${cyan("?")} ${message} ${dim("(\u2191/\u2193, Enter)")}`, ...choices.map((choice, at) => at === index ? cyan(`\u276F ${choice.label}`) + (choice.hint ? ` ${dim(choice.hint)}` : "") : `  ${choice.label}${choice.hint ? ` ${dim(choice.hint)}` : ""}`)];
+    output.write(lines.join("\n") + "\n");
+    drawn = lines.length;
+  };
+  return new Promise((resolve, reject) => {
+    emitKeypressEvents(input);
+    const raw = input.isRaw;
+    input.setRawMode?.(true);
+    input.resume();
+    output.write("\x1B[?25l");
+    const done = (settle, value) => {
+      input.off("keypress", onKey);
+      input.setRawMode?.(raw ?? false);
+      input.pause();
+      output.write(`\x1B[${drawn}A\x1B[0J\x1B[?25h`);
+      if (settle === resolve) output.write(`${cyan("\u2714")} ${message} ${cyan(choices[index].label)}
+`);
+      settle(value);
+    };
+    const onKey = (text2, key = {}) => {
+      if (key.ctrl && key.name === "c" || key.name === "escape") return done(reject, new Cancelled());
+      if (key.name === "return" || key.name === "enter") return done(resolve, choices[index].value);
+      if (key.name === "up" || key.name === "k") index = (index + choices.length - 1) % choices.length;
+      else if (key.name === "down" || key.name === "j") index = (index + 1) % choices.length;
+      else return;
+      draw();
+    };
+    input.on("keypress", onKey);
+    draw();
+  });
+}
+async function text(message, { input = process.stdin, output = process.stdout } = {}) {
+  const { createInterface } = await import("node:readline/promises");
+  const rl = createInterface({ input, output });
+  try {
+    return (await rl.question(`${cyan("?")} ${message} `)).trim();
+  } finally {
+    rl.close();
+  }
+}
+export {
+  Cancelled,
+  select,
+  text
+};

package/dist/render.d.ts

@@ -0,0 +1,6 @@
+/** `alp ps`: sessions as a tree, one line each. */
+export function renderPs(sessions: any): any[];
+/** `alp log`: one line per run-log entry, with its time. */
+export function renderLog(rootId: any, entries: any): string[];
+export function ago(since: any, now?: number): string;
+export function duration(ms: any): string;

package/dist/render.js

@@ -0,0 +1,120 @@
+// packages/client/src/render.js
+var TASK_PAST = { create: "created", update: "updated", link: "linked", start: "started", close: "closed", reopen: "reopened", delegate: "delegated", submit: "submitted", release: "released", gate: "gated", clear: "cleared a gate of", orphaned: "reopened (its assignment ended with alpd)" };
+var ago = (since, now = Date.now()) => {
+  const seconds = Math.max(0, Math.round((now - Date.parse(since)) / 1e3));
+  return seconds < 60 ? `${seconds}s` : seconds < 3600 ? `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s` : `${Math.floor(seconds / 3600)}h${String(Math.floor(seconds % 3600 / 60)).padStart(2, "0")}m`;
+};
+var duration = (ms) => ago((/* @__PURE__ */ new Date(0)).toISOString(), ms);
+var tokens = (count) => typeof count !== "number" ? "?" : count >= 1e6 && count % 1e6 < 5e4 ? `${Math.round(count / 1e6)}M` : `${Math.round(count / 1e3)}k`;
+function renderPs(sessions) {
+  const lines = [];
+  const children = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const key = session.parentId ?? "";
+    children.set(key, [...children.get(key) ?? [], session]);
+  }
+  const print = (session, depth) => {
+    const status = session.parked ? `parked (${session.parked})` : session.status === "running" || session.status === "idle" ? session.activeTurnId ? "running" : session.busy ? "waiting" : "idle" : session.lastError?.code ?? session.status;
+    lines.push(`${"  ".repeat(depth)}${session.id}  ${session.agent}  ${session.runtime}:${session.model}  ${session.mode}  ${status}${depth ? "" : `  ${session.projectRoot}${session.title ? `  "${session.title}"` : ""}`}`);
+    for (const child of children.get(session.id) ?? []) print(child, depth + 1);
+  };
+  for (const root of children.get("") ?? []) print(root, 0);
+  return lines;
+}
+function renderLog(rootId, entries) {
+  const lines = [];
+  const agents = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const time = entry.ts.slice(11, 19);
+    let text;
+    switch (entry.event) {
+      case "assignment.started":
+        agents.set(entry.assignmentId, entry.agent);
+        text = `${entry.parentAgent} \u2192 ${entry.agent} (${entry.mode}${entry.isolation === "worktree" ? ", worktree" : ""}, ${entry.model}${entry.wait === false ? ", async" : ""}): ${entry.task.split("\n")[0].slice(0, 120)}`;
+        break;
+      case "assignment.finished":
+        text = `${entry.agent} ${entry.status} after ${duration(entry.durationMs ?? 0)}${entry.handoff ? `, handoff ${entry.handoff.outcome}${entry.handoff.verdict ? `, verdict ${entry.handoff.verdict.result.toUpperCase()}` : ""}: ${entry.handoff.summary.split("\n")[0].slice(0, 120)}` : ""}${entry.error ? `: ${entry.error}` : ""}${entry.reconciled ? " (after a restart)" : ""}`;
+        break;
+      case "mail":
+        if (entry.kind === "board") continue;
+        text = `\u2709 ${entry.kind} ${entry.from} \u2192 ${entry.to === rootId ? "main" : agents.get(entry.to) ?? entry.to}${entry.body ? `: ${entry.body.split("\n")[0].slice(0, 120)}` : ""}`;
+        break;
+      case "board.pin":
+        text = `${entry.kind === "claim" ? "\u2691" : entry.kind === "decision" ? "\u25C6" : "\u2022"} ${entry.agent} pins ${entry.kind} ${entry.pinId}${entry.task ? ` for ${entry.task}` : ""}${entry.paths ? ` [${entry.paths.join(", ")}]` : ""}: ${entry.body.split("\n")[0].slice(0, 120)}`;
+        break;
+      case "task":
+        text = `\u2610 ${entry.agent} ${TASK_PAST[entry.action] ?? entry.action} ${entry.id} "${entry.title}" \u2192 ${entry.status}${entry.detail ? `: ${entry.detail.split("\n")[0].slice(0, 120)}` : ""}`;
+        break;
+      case "board.unpin":
+        text = `\u2690 ${entry.pinId} by ${entry.agent} ${entry.reason === "session_ended" ? "released when its session ended" : "taken down"}`;
+        break;
+      case "human.question":
+        text = `? ${entry.agent} asks the user [${entry.questionId}]: ${entry.body.split("\n")[0].slice(0, 120)}`;
+        break;
+      case "verify":
+        text = `${entry.skipped ? "\u2013" : entry.passed ? "\u2713" : "\u2717"} verify in the ${entry.where}${entry.taskId ? ` for ${entry.taskId}` : ""}${entry.assignmentId ? ` (${entry.assignmentId})` : ""}: ${entry.skipped ? `skipped: ${entry.skipped}` : entry.detail}`;
+        break;
+      case "epic.landed":
+        text = `\u25C6 ${entry.agent} closed ${entry.id} "${entry.title}": ${entry.tasks} tasks, ${entry.reworked} reworked`;
+        break;
+      case "notice":
+        text = `${entry.level === "error" ? "\u203C" : entry.level === "warning" ? "!" : "\u2139"} ${entry.text}`;
+        break;
+      case "assignment.parked":
+        text = `\u23F8 ${entry.agent} ${entry.assignmentId} parked: ${entry.reason}`;
+        break;
+      case "assignment.resumed":
+        text = `\u25B6 ${entry.agent} ${entry.assignmentId} resumed`;
+        break;
+      case "instructions":
+        text = `# ${entry.agent} instructions ${entry.sha} (ALP.md ${entry.parts?.project}, AGENT.md ${entry.parts?.agent}, ${entry.chars} chars)`;
+        break;
+      case "context":
+        text = entry.level === "soon" ? `\u25D4 ${entry.agent} context ${tokens(entry.tokens)}, compacts at ${tokens(entry.compactAt)}: told it is near` : `\u25D4 ${entry.agent} context ${entry.percent}% full: ${entry.level === "now" ? "told to hand off now" : "told to plan a handoff"}`;
+        break;
+      case "skill":
+        text = Array.isArray(entry.roles) ? `\u2726 ${entry.agent} saved skill ${entry.name} for ${entry.roles.join(", ")}` : `\u2726 ${entry.agent} uses skill ${entry.skill}${entry.via === "skill" ? " (Skill tool)" : ""}`;
+        break;
+      case "compacted":
+        text = entry.failed ? `\u2717 ${entry.agent}'s context could not be compacted${entry.error ? `: ${entry.error}` : ""}` : `\u25D1 ${entry.agent}'s context compacted${entry.preTokens !== void 0 ? ` from ${tokens(entry.preTokens)}` : ""}${entry.postTokens !== void 0 ? ` to ${tokens(entry.postTokens)}` : ""}${entry.trigger === "manual" ? " on request" : ""}`;
+        break;
+      case "assignment.interrupted":
+        text = `\u23F9 ${entry.agent} ${entry.assignmentId} interrupted: ${entry.reason}; the next alpd continues it`;
+        break;
+      case "assignment.recovered":
+        text = `\u21BB ${entry.agent} ${entry.assignmentId} reopened after alpd restarted`;
+        break;
+      case "session.restarted":
+        text = `\u21BB ${entry.agent}'s native process stopped (${entry.error}); restart ${entry.restarts}`;
+        break;
+      case "session.revived":
+        text = `\u25B6 ${entry.agent} running again`;
+        break;
+      case "session.revive_failed":
+        text = `\u2717 ${entry.agent} could not be restarted: ${entry.error}`;
+        break;
+      case "human.answer":
+        text = `\u21B3 ${entry.questionId} ${entry.outcome}${entry.answer !== void 0 ? `: ${entry.answer.split("\n")[0].slice(0, 120)}` : ""}`;
+        break;
+      case "hook":
+        text = entry.skipped ? `\u21AA ${entry.agent}'s ${entry.on} hook ${entry.hook} skipped: the workspace's hooks are not trusted` : `${entry.blocked ? "\u26D4" : entry.error || entry.exitCode !== 0 || entry.timedOut ? "\u2717" : "\u21AA"} ${entry.agent}'s ${entry.on} hook ${entry.hook} ${entry.error ? `could not run: ${entry.error}` : entry.timedOut ? "timed out" : `exit ${entry.exitCode}`}${entry.durationMs !== void 0 ? ` in ${duration(entry.durationMs)}` : ""}${entry.blocked ? ", refused it" : ""}${entry.output ? `: ${entry.output.split("\n")[0].slice(0, 120)}` : ""}`;
+        break;
+      case "hook.trust":
+        text = `${entry.trusted ? "\u2713 the user trusts" : "\u2717 the user did not trust"} the hooks of ${entry.project}${entry.outcome ? ` (${entry.outcome})` : ""}`;
+        break;
+      case "runtime.slip":
+        text = `\u26A0 ALP could not handle ${entry.agent}'s ${entry.method}: ${entry.error}; the session went on`;
+        break;
+      default:
+        text = `${entry.event}${entry.branch ? ` ${entry.branch}` : ""}${entry.status ? ` ${entry.status}` : ""}`;
+    }
+    lines.push(`${time}  ${text}`);
+  }
+  return lines;
+}
+export {
+  ago,
+  duration,
+  renderLog,
+  renderPs
+};

package/dist/service.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Where and how alpd for `home` is defined as a service on `platform`, or undefined
+ * where ALP has no service support. Each ALP_HOME gets its own service.
+ */
+export function serviceFor({ home, env, platform, uid }: {
+    home: any;
+    env?: NodeJS.ProcessEnv | undefined;
+    platform?: NodeJS.Platform | undefined;
+    uid?: number | undefined;
+}): {
+    kind: string;
+    name: string;
+    file: string;
+    install: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    start: (string | string[])[][];
+    uninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    afterUninstall?: undefined;
+} | {
+    kind: string;
+    name: string;
+    file: string;
+    install: (string | string[])[][];
+    start: (string | string[])[][];
+    uninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    afterUninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+} | undefined;
+/** The service definition that runs `entry` with `execPath` for `home`. */
+export function serviceDefinition(service: any, { home, entry, execPath, env }: {
+    home: any;
+    entry: any;
+    execPath?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}): string;
+/** The program an installed definition runs: [node, alpd.js], or undefined when it is not installed. */
+export function installedProgram(service: any): Promise<any[] | undefined>;
+/** Writes the definition and loads it, which starts alpd. */
+export function installService(service: any, options: any, run?: typeof runCommand): Promise<void>;
+/** Starts an installed service's alpd. */
+export function startService(service: any, run?: typeof runCommand): Promise<void>;
+/** Unloads the service, which stops its alpd, and removes the definition; false when none was installed. */
+export function uninstallService(service: any, run?: typeof runCommand): Promise<boolean>;
+import { runCommand } from './command.js';

package/dist/service.js

@@ -0,0 +1,143 @@
+// packages/client/src/service.js
+import { createHash } from "node:crypto";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { runCommand } from "./command.js";
+var CARRIED = ["ALP_RUN_LOG_DIR", "ALP_CODEX_BIN", "ALP_CLAUDE_BIN", "ALP_ANTIGRAVITY_BIN", "ALP_GH_BIN"];
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var quoteUnit = (value) => `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+function serviceFor({ home, env = process.env, platform = process.platform, uid = process.getuid?.() ?? 0 }) {
+  const custom = path.resolve(home) !== path.join(os.homedir(), ".alp");
+  const suffix = custom ? createHash("sha256").update(path.resolve(home)).digest("hex").slice(0, 8) : "";
+  if (platform === "darwin") {
+    const label = `com.alp.alpd${suffix ? `.${suffix}` : ""}`;
+    const directory = env.ALP_SERVICE_DIR || path.join(os.homedir(), "Library", "LaunchAgents");
+    const launchctl = env.ALP_LAUNCHCTL || "launchctl";
+    const target = `gui/${uid}/${label}`;
+    const file = path.join(directory, `${label}.plist`);
+    return {
+      kind: "launchd",
+      name: label,
+      file,
+      install: [[launchctl, ["bootout", target], { ignore: true }], [launchctl, ["bootstrap", `gui/${uid}`, file]]],
+      start: [[launchctl, ["kickstart", target]]],
+      uninstall: [[launchctl, ["bootout", target], { ignore: true }]]
+    };
+  }
+  if (platform === "linux") {
+    const name = `alpd${suffix ? `-${suffix}` : ""}`;
+    const directory = env.ALP_SERVICE_DIR || path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "systemd", "user");
+    const systemctl = env.ALP_SYSTEMCTL || "systemctl";
+    return {
+      kind: "systemd",
+      name,
+      file: path.join(directory, `${name}.service`),
+      install: [[systemctl, ["--user", "daemon-reload"]], [systemctl, ["--user", "enable", "--now", `${name}.service`]]],
+      start: [[systemctl, ["--user", "start", `${name}.service`]]],
+      uninstall: [[systemctl, ["--user", "disable", "--now", `${name}.service`], { ignore: true }]],
+      afterUninstall: [[systemctl, ["--user", "daemon-reload"], { ignore: true }]]
+    };
+  }
+  return void 0;
+}
+function serviceDefinition(service, { home, entry, execPath = process.execPath, env = process.env }) {
+  const variables = { ALP_HOME: path.resolve(home), PATH: env.PATH ?? "" };
+  for (const name of CARRIED) if (env[name]) variables[name] = env[name];
+  const program = [execPath, entry, "--service"];
+  const fatal = path.join(path.resolve(home), "logs", "alpd.service.log");
+  if (service.kind === "launchd") {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(service.name)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${program.map((arg) => `    <string>${escapeXml(arg)}</string>`).join("\n")}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${Object.entries(variables).map(([key, value]) => `    <key>${escapeXml(key)}</key>
+    <string>${escapeXml(value)}</string>`).join("\n")}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>Crashed</key>
+    <true/>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(fatal)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(fatal)}</string>
+</dict>
+</plist>
+`;
+  }
+  return `[Unit]
+Description=ALP daemon (alpd) for ${path.resolve(home)}
+
+[Service]
+ExecStart=${program.map(quoteUnit).join(" ")}
+${Object.entries(variables).map(([key, value]) => `Environment=${quoteUnit(`${key}=${value}`)}`).join("\n")}
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${fatal}
+StandardError=append:${fatal}
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function installedProgram(service) {
+  const text = await readFile(service.file, "utf8").catch(() => void 0);
+  if (text === void 0) return void 0;
+  if (service.kind === "launchd") {
+    const array = text.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/)?.[1] ?? "";
+    const unescape = (value) => value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+    return [...array.matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => unescape(match[1])).slice(0, 2);
+  }
+  const line = text.match(/^ExecStart=(.*)$/m)?.[1] ?? "";
+  return [...line.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1].replace(/\\(.)/g, "$1")).slice(0, 2);
+}
+async function runAll(steps, run) {
+  for (const [command, args, { ignore = false } = {}] of steps) {
+    const result = await run(command, args);
+    if (result.code !== 0 && !ignore) throw new Error(`${command} ${args.join(" ")} failed: ${(result.stderr || result.stdout).trim() || `exit ${result.code}`}`);
+  }
+}
+async function installService(service, options, run = runCommand) {
+  await mkdir(path.dirname(service.file), { recursive: true });
+  await mkdir(path.join(path.resolve(options.home), "logs"), { recursive: true, mode: 448 });
+  await writeFile(service.file, serviceDefinition(service, options), { mode: 420 });
+  await runAll(service.install, run);
+}
+async function startService(service, run = runCommand) {
+  await runAll(service.start, run);
+}
+async function uninstallService(service, run = runCommand) {
+  if (await installedProgram(service) === void 0) return false;
+  await runAll(service.uninstall, run);
+  await unlink(service.file).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+  await runAll(service.afterUninstall ?? [], run);
+  return true;
+}
+export {
+  installService,
+  installedProgram,
+  serviceDefinition,
+  serviceFor,
+  startService,
+  uninstallService
+};

package/dist/setup.d.ts

@@ -0,0 +1,2 @@
+/** Write Phở and Cafe's agent profiles into a project's .alp/settings.json, without installing software or calling models. */
+export function setup(args: any, home: any): Promise<void>;