@just-every/manager 0.2.0

package/dist/chunk-ZQKKKD3J.js

@@ -0,0 +1,38 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+import os from "os";
+import path from "path";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = Number(process.env.MANAGERD_PORT ?? 7765);
+var MANAGERD_HOME = (() => {
+  if (process.env.MANAGERD_HOME) {
+    return path.resolve(process.env.MANAGERD_HOME);
+  }
+  return path.join(os.homedir(), ".managerd");
+})();
+var DATA_DIRS = {
+  root: MANAGERD_HOME,
+  logs: path.join(MANAGERD_HOME, "logs"),
+  sessions: path.join(MANAGERD_HOME, "sessions")
+};
+var DB_PATH = path.join(MANAGERD_HOME, "state.db");
+var PID_FILE = path.join(MANAGERD_HOME, "managerd.pid");
+var DEFAULT_CODEX_HISTORY = path.join(os.homedir(), ".codex", "sessions");
+var DEFAULT_CODEX_TRANSCRIPT = "output.json";
+
+export {
+  __require,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  DATA_DIRS,
+  DB_PATH,
+  PID_FILE,
+  DEFAULT_CODEX_HISTORY,
+  DEFAULT_CODEX_TRANSCRIPT
+};

package/dist/cli.js

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+import {
+  DATA_DIRS,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  PID_FILE
+} from "./chunk-ZQKKKD3J.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import fetch from "node-fetch";
+import fs3 from "fs/promises";
+import fsSync from "fs";
+import path3 from "path";
+import os3 from "os";
+import { fileURLToPath } from "url";
+
+// src/integrations/sync.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { spawnSync } from "child_process";
+var home = os.homedir();
+async function runIntegrationSync(agent) {
+  switch (agent) {
+    case "codex":
+      return syncCodex();
+    case "claude":
+      return syncClaude();
+    case "gemini":
+      return syncGemini();
+    default:
+      throw new Error(`Unknown integration agent: ${agent}`);
+  }
+}
+function syncCodex() {
+  const checks = [];
+  const manualSteps = [];
+  const command = process.env.MANAGER_CODEX_COMMAND ?? "codex";
+  const historyDir = process.env.MANAGER_CODEX_HISTORY ?? path.join(home, ".codex", "sessions");
+  const configPath = path.join(home, ".codex", "config.json");
+  const cmdPath = resolveCommand(command);
+  if (cmdPath) {
+    checks.push({ name: `Codex binary (${command})`, status: "ok", detail: cmdPath });
+  } else {
+    checks.push({ name: `Codex binary (${command})`, status: "missing", detail: "not found on PATH" });
+  }
+  if (fs.existsSync(historyDir)) {
+    checks.push({ name: "History directory", status: "ok", detail: historyDir });
+  } else {
+    checks.push({ name: "History directory", status: "missing", detail: historyDir });
+    manualSteps.push(`Create the history directory: mkdir -p ${historyDir}`);
+  }
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf8");
+      const config = JSON.parse(raw);
+      const configuredHistory = config.history_dir;
+      if (configuredHistory === historyDir) {
+        checks.push({ name: "Codex history_dir", status: "ok", detail: configuredHistory });
+      } else {
+        checks.push({
+          name: "Codex history_dir",
+          status: "warn",
+          detail: `Config uses ${configuredHistory || "unset"}`
+        });
+        manualSteps.push(`Update ${configPath} -> history_dir = "${historyDir}"`);
+      }
+    } catch (err) {
+      checks.push({ name: "Codex config parse", status: "warn", detail: err.message });
+      manualSteps.push(`Fix JSON in ${configPath} so manager can verify settings.`);
+    }
+  } else {
+    checks.push({ name: "Codex config file", status: "missing", detail: configPath });
+    manualSteps.push(`Create ${configPath} with { "history_dir": "${historyDir}" }`);
+  }
+  const status = determineStatus(checks, cmdPath ? "ready" : "not_detected");
+  return { agent: "codex", status, checks, manualSteps };
+}
+function syncClaude() {
+  const checks = [];
+  const manualSteps = [];
+  const configDir = path.join(home, ".config", "claude");
+  const hookPath = path.join(configDir, "hooks", "on_session_start");
+  if (fs.existsSync(configDir)) {
+    checks.push({ name: "Claude config directory", status: "ok", detail: configDir });
+  } else {
+    checks.push({ name: "Claude config directory", status: "missing", detail: configDir });
+    manualSteps.push(`Create ${configDir} (Claude Code stores hooks here).`);
+  }
+  if (fs.existsSync(hookPath)) {
+    const content = fs.readFileSync(hookPath, "utf8");
+    if (content.includes("manager")) {
+      checks.push({ name: "Hook script", status: "ok", detail: hookPath });
+    } else {
+      checks.push({ name: "Hook script", status: "warn", detail: "does not reference manager CLI" });
+      manualSteps.push(`Update ${hookPath} to forward events to manager (see docs/manager-daemon-cli.md).`);
+    }
+  } else {
+    checks.push({ name: "Hook script", status: "missing", detail: hookPath });
+    manualSteps.push(`Create a hook script at ${hookPath} that runs manager's Claude hook helper.`);
+  }
+  return { agent: "claude", status: determineStatus(checks), checks, manualSteps };
+}
+function syncGemini() {
+  const checks = [];
+  const manualSteps = [];
+  const geminiDir = path.join(home, ".gemini");
+  const configPath = path.join(geminiDir, "config.toml");
+  const desiredEndpoint = process.env.MANAGER_GEMINI_OTLP ?? "http://127.0.0.1:4318";
+  if (fs.existsSync(geminiDir)) {
+    checks.push({ name: "Gemini directory", status: "ok", detail: geminiDir });
+  } else {
+    checks.push({ name: "Gemini directory", status: "missing", detail: geminiDir });
+    manualSteps.push("Install Gemini CLI and log in so ~/.gemini is created.");
+  }
+  if (fs.existsSync(configPath)) {
+    const text = fs.readFileSync(configPath, "utf8");
+    const enabled = /telemetry\.enabled\s*=\s*true/.test(text);
+    const endpointMatch = text.includes(desiredEndpoint);
+    checks.push({
+      name: "Telemetry enabled",
+      status: enabled ? "ok" : "warn",
+      detail: enabled ? "enabled" : "telemetry.enabled not true"
+    });
+    checks.push({
+      name: "OTLP endpoint",
+      status: endpointMatch ? "ok" : "warn",
+      detail: endpointMatch ? desiredEndpoint : "endpoint not set to manager"
+    });
+    if (!enabled || !endpointMatch) {
+      manualSteps.push(
+        `Edit ${configPath} telemetry section so exporter targets ${desiredEndpoint}.`
+      );
+    }
+  } else {
+    checks.push({ name: "Gemini config file", status: "missing", detail: configPath });
+    manualSteps.push(`Create ${configPath} and set telemetry endpoint to ${desiredEndpoint}.`);
+  }
+  return { agent: "gemini", status: determineStatus(checks), checks, manualSteps };
+}
+function determineStatus(checks, fallback = "ready") {
+  if (checks.some((check) => check.status === "missing")) {
+    return fallback === "not_detected" && checks.every((c) => c.status === "missing") ? "not_detected" : "partial";
+  }
+  if (checks.some((check) => check.status === "warn")) {
+    return "partial";
+  }
+  return fallback === "not_detected" ? "not_detected" : "ready";
+}
+function resolveCommand(command) {
+  const resolved = spawnSync("which", [command], { encoding: "utf8" });
+  if (resolved.status === 0) {
+    return resolved.stdout.trim();
+  }
+  return null;
+}
+
+// src/integrations/install.ts
+import os2 from "os";
+import path2 from "path";
+import fs2 from "fs/promises";
+import { promisify } from "util";
+import { exec as execCb } from "child_process";
+var exec = promisify(execCb);
+async function installIntegration(agent) {
+  switch (agent) {
+    case "claude":
+      return installClaudeHook();
+    case "gemini":
+      return installGeminiWatcher();
+    case "codex":
+      return "Codex integration does not require installation; history dir is created automatically.";
+    default:
+      throw new Error(`Unknown agent ${agent}`);
+  }
+}
+async function installClaudeHook() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path2.join(os2.homedir(), ".config", "claude");
+  const hookDir = path2.join(configDir, "hooks");
+  const scriptPath = path2.join(hookDir, "managerd-hook.sh");
+  await fs2.mkdir(hookDir, { recursive: true });
+  const script = `#!/usr/bin/env bash
+set -euo pipefail
+payload="$(cat)"
+if [ -z "$payload" ]; then
+  exit 0
+fi
+url="${process.env.MANAGERD_HOOK_URL ?? "http://127.0.0.1:7765/hooks/claude"}"
+curl -fsS -X POST "$url" -H 'content-type: application/json' -d "$payload" >/dev/null 2>&1 || true
+`;
+  await fs2.writeFile(scriptPath, script, { mode: 493 });
+  return `Hook script installed to ${scriptPath}. Point Claude Code hooks at this script to stream events to managerd.`;
+}
+async function installGeminiWatcher() {
+  const sessionsDir = path2.join(os2.homedir(), ".gemini", "tmp");
+  await fs2.mkdir(sessionsDir, { recursive: true });
+  return `Gemini watcher enabled (managerd scans ${sessionsDir}). Ensure Gemini CLI writes session files there.`;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("manager").description("Supervise local AI agents with Manager");
+var daemonCommand = program.command("daemon").description("Manage the managerd background service");
+daemonCommand.command("start").description("Run managerd in the foreground").action(async () => {
+  const { startDaemon } = await import("./daemon-DTD73K4H.js");
+  await startDaemon();
+});
+daemonCommand.command("status").description("Check daemon health").option("--host <host>", "Daemon host override", DEFAULT_HOST).option("--port <port>", "Daemon port override", String(DEFAULT_PORT)).action(async (opts) => {
+  const result = await queryDaemon("/status", opts.host, Number(opts.port));
+  if (!result.ok) {
+    console.error(chalk.red("Daemon unavailable:"), result.error ?? "unknown");
+    process.exitCode = 1;
+    return;
+  }
+  console.log(chalk.green("managerd running"));
+  console.log("Uptime:", Math.round(result.uptimeMs / 1e3), "s");
+  console.log("Codex connector:", result.codex);
+  console.log("Recent sessions:");
+  for (const session of result.sessions ?? []) {
+    console.log(` - ${session.id} [${session.agentType}] ${session.status}`);
+  }
+});
+daemonCommand.command("stop").description("Stop a running managerd instance").action(async () => {
+  const pid = await readPidFile();
+  if (!pid) {
+    console.log("managerd is not running.");
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Sent SIGTERM to managerd (pid ${pid}).`);
+  } catch (err) {
+    console.error(chalk.red("Failed to stop managerd:"), err?.message ?? err);
+  }
+});
+daemonCommand.command("logs").description("Show managerd logs").option("--follow", "Stream logs until interrupted").action(async (opts) => {
+  await tailLogs(Boolean(opts.follow));
+});
+daemonCommand.command("install").description("Install managerd as a user-level systemd service").action(async () => {
+  await installSystemdService();
+});
+var agentCommand = program.command("agent").description("Interact with local agents via managerd");
+agentCommand.command("launch <agent>").description("Launch an agent session through the daemon").option("--cmd <path>", "Override executable path").option("--arg <value...>", "Arguments passed to the agent").option("--raw", "Skip automatic Codex flag injection (testing only)").option("--max-restarts <n>", "Maximum automatic restarts (default: 3)", "3").option("--no-auto-restart", "Disable automatic restarts").option("--host <host>", "Daemon host override", DEFAULT_HOST).option("--port <port>", "Daemon port override", String(DEFAULT_PORT)).action(async (agent, opts) => {
+  if (!["codex", "gemini"].includes(agent)) {
+    console.error(chalk.red("Supported agents: codex, gemini"));
+    process.exitCode = 1;
+    return;
+  }
+  const maxRestarts = Number(opts.maxRestarts ?? 3);
+  const payload = {
+    agent,
+    command: opts.cmd,
+    args: opts.arg ?? [],
+    autoRestart: opts.autoRestart !== false,
+    maxRestarts: Number.isFinite(maxRestarts) ? maxRestarts : 3
+  };
+  if (agent === "codex") {
+    payload.disableManagedFlags = Boolean(opts.raw);
+  }
+  const response = await callDaemon("/rpc/launch", payload, opts.host, Number(opts.port));
+  if (!response.ok) {
+    console.error(chalk.red("Launch failed:"), response.error ?? "unknown");
+    process.exitCode = 1;
+    return;
+  }
+  const { result } = response;
+  console.log(chalk.green(`${agent} session launched`));
+  console.log("Local session ID:", result.localSessionId);
+  console.log("Tool session ID:", result.toolSessionId);
+  console.log("Command:", `${result.command} ${result.args.join(" ")}`);
+});
+agentCommand.command("ingest-gemini <sessionFile>").description("Ingest a Gemini CLI session JSON file into managerd").option("--session-id <id>", "Override Gemini session id").option("--host <host>", "Daemon host override", DEFAULT_HOST).option("--port <port>", "Daemon port override", String(DEFAULT_PORT)).action(async (sessionFile, opts) => {
+  const absolute = path3.resolve(sessionFile);
+  let contents;
+  try {
+    contents = await fs3.readFile(absolute, "utf8");
+  } catch (err) {
+    console.error(chalk.red("Unable to read session file:"), err?.message ?? err);
+    process.exitCode = 1;
+    return;
+  }
+  let data;
+  try {
+    data = JSON.parse(contents);
+  } catch (err) {
+    console.error(chalk.red("Session file is not valid JSON:"), err?.message ?? err);
+    process.exitCode = 1;
+    return;
+  }
+  const sessionId = opts.sessionId ?? data.sessionId ?? data.id ?? inferSessionIdFromPath(absolute);
+  const payload = {
+    sessionId,
+    filePath: absolute,
+    data
+  };
+  const response = await callDaemon("/rpc/gemini/ingest", payload, opts.host, Number(opts.port));
+  if (!response.ok) {
+    console.error(chalk.red("Gemini ingestion failed:"), response.error ?? "unknown");
+    process.exitCode = 1;
+    return;
+  }
+  console.log(chalk.green("Gemini session ingested"));
+  if (response.inserted != null) {
+    console.log("Events inserted:", response.inserted);
+  }
+  if (response.warnings?.length) {
+    console.warn(chalk.yellow("Warnings:"));
+    response.warnings.forEach((warning) => console.warn(" -", warning));
+  }
+});
+program.command("sessions").description("List locally tracked sessions").option("--host <host>", "Daemon host override", DEFAULT_HOST).option("--port <port>", "Daemon port override", String(DEFAULT_PORT)).action(async (opts) => {
+  const result = await queryDaemon("/sessions", opts.host, Number(opts.port));
+  if (!result.ok) {
+    console.error(chalk.red("Unable to read sessions:"), result.error ?? "unknown");
+    process.exitCode = 1;
+    return;
+  }
+  if (!result.sessions?.length) {
+    console.log("No sessions recorded yet.");
+    return;
+  }
+  const rows = result.sessions.map((session) => ({
+    id: session.id.slice(0, 8),
+    agent: session.agentType,
+    status: session.status,
+    command: session.command,
+    started: formatDate(session.createdAt ?? session.created_at),
+    updated: formatDate(session.updatedAt ?? session.updated_at)
+  }));
+  const header = ["ID", "Agent", "Status", "Started", "Updated", "Command"];
+  const lines = [header, ...rows.map((row) => [row.id, row.agent, row.status, row.started, row.updated, row.command])];
+  const widths = header.map((_, index) => Math.max(...lines.map((line) => String(line[index] ?? "").length)));
+  for (const line of lines) {
+    const formatted = line.map((value, idx) => String(value ?? "").padEnd(widths[idx])).join("  ");
+    console.log(formatted);
+  }
+});
+program.command("sessions:events <sessionId>").description("View events captured for a session (ingests Codex transcripts on demand)").option("--host <host>", "Daemon host override", DEFAULT_HOST).option("--port <port>", "Daemon port override", String(DEFAULT_PORT)).option("--limit <n>", "Limit number of events", "20").option("--json", "Print raw JSON").action(async (sessionId, opts) => {
+  const payload = {
+    sessionId,
+    limit: Number(opts.limit ?? 20)
+  };
+  const response = await callDaemon("/rpc/sessions/events", payload, opts.host, Number(opts.port));
+  if (!response.ok) {
+    console.error(chalk.red("Failed to fetch events:"), response.error ?? "unknown");
+    process.exitCode = 1;
+    return;
+  }
+  const { events, warnings, session } = response;
+  if (session) {
+    console.log(chalk.bold(`Session ${session.id}`));
+    console.log(`Agent: ${session.agentType}`);
+    if (session.command) {
+      console.log(`Command: ${session.command}`);
+    }
+    console.log("Started:", formatDate(session.createdAt ?? session.created_at));
+    console.log("Status:", session.status);
+    console.log("");
+  }
+  if (warnings?.length) {
+    console.warn(chalk.yellow("Warnings:"));
+    for (const warning of warnings) {
+      console.warn("-", warning);
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(events, null, 2));
+    return;
+  }
+  if (!events.length) {
+    console.log("No events recorded yet.");
+    return;
+  }
+  for (const event of events) {
+    renderEvent(event);
+  }
+});
+var integrationsCommand = program.command("integrations").description("Inspect agent integrations");
+integrationsCommand.command("sync <agent>").description("Check local integration status (read-only)").option("--json", "Output JSON report").action(async (agent, opts) => {
+  if (!["codex", "claude", "gemini"].includes(agent)) {
+    console.error(chalk.red("Supported agents: codex, claude, gemini"));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const report = await runIntegrationSync(agent);
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    renderIntegrationReport(report);
+  } catch (err) {
+    console.error(chalk.red("Failed to run sync:"), err.message ?? err);
+    process.exitCode = 1;
+  }
+});
+integrationsCommand.command("install <agent>").description("Install helper assets for an integration").action(async (agent) => {
+  if (!["codex", "claude", "gemini"].includes(agent)) {
+    console.error(chalk.red("Supported agents: codex, claude, gemini"));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const message = await installIntegration(agent);
+    console.log(chalk.green("Install complete:"), message);
+  } catch (err) {
+    console.error(chalk.red("Install failed:"), err?.message ?? err);
+    process.exitCode = 1;
+  }
+});
+program.parseAsync(process.argv);
+async function queryDaemon(pathname, host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}${pathname}`);
+    if (!res.ok) return { ok: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (err) {
+    return { ok: false, error: err?.message ?? "connection_error" };
+  }
+}
+async function callDaemon(pathname, payload, host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}${pathname}`, {
+      method: "POST",
+      body: JSON.stringify(payload),
+      headers: { "content-type": "application/json" }
+    });
+    if (!res.ok) return { ok: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (err) {
+    return { ok: false, error: err?.message ?? "connection_error" };
+  }
+}
+function renderEvent(event) {
+  const time = event.timestamp ? new Date(event.timestamp).toLocaleTimeString() : "unknown time";
+  const header = `[${time}] ${event.role ? event.role.toUpperCase() : event.eventType}`;
+  if (event.eventType === "message") {
+    console.log(header);
+    console.log(`  ${event.text ?? event.summary ?? JSON.stringify(event.content)}`);
+    return;
+  }
+  if (event.eventType === "tool_use") {
+    console.log(`${header} TOOL ${event.toolName ?? ""}`.trim());
+    console.log(`  Input: ${truncate(event.toolInput ?? "", 200)}`);
+    return;
+  }
+  if (event.eventType === "tool_result") {
+    console.log(`${header} TOOL RESULT`);
+    console.log(`  Output: ${truncate(event.toolOutput ?? "", 200)}`);
+    return;
+  }
+  if (event.eventType === "error") {
+    console.log(`${header} ERROR ${event.errorType ?? ""}`.trim());
+    console.log(`  ${event.errorMessage}`);
+    return;
+  }
+  console.log(header);
+  console.log("  ", JSON.stringify(event));
+}
+function truncate(value, max = 200) {
+  if (!value) return "";
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+function inferSessionIdFromPath(filePath) {
+  const base = path3.basename(filePath);
+  return base.replace(/\.[^.]+$/, "") || `gemini-${Date.now()}`;
+}
+function formatDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  return date.toLocaleString();
+}
+async function readPidFile() {
+  try {
+    const contents = await fs3.readFile(PID_FILE, "utf8");
+    const pid = Number(contents.trim());
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+async function tailLogs(follow) {
+  const logPath = path3.join(DATA_DIRS.logs, "managerd.log");
+  try {
+    await fs3.access(logPath);
+  } catch {
+    console.log("Logs not found yet. Run managerd once to create logs.");
+    return;
+  }
+  const printCurrent = async () => {
+    const text = await fs3.readFile(logPath, "utf8");
+    if (text) process.stdout.write(text);
+  };
+  if (!follow) {
+    await printCurrent();
+    return;
+  }
+  let position = 0;
+  const stats = await fs3.stat(logPath);
+  if (stats.size > 0) {
+    await printCurrent();
+    position = stats.size;
+  }
+  console.log(chalk.gray("--- streaming managerd logs (Ctrl+C to stop) ---"));
+  const watcher = fsSync.watch(logPath, async (event) => {
+    if (event !== "change") return;
+    try {
+      const handle = await fs3.open(logPath, "r");
+      const current = await handle.stat();
+      if (current.size > position) {
+        const length = current.size - position;
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, position);
+        process.stdout.write(buffer.toString());
+        position = current.size;
+      }
+      await handle.close();
+    } catch (err) {
+      console.error(chalk.red("Failed to read logs:"), err instanceof Error ? err.message : err);
+    }
+  });
+  const cleanup = () => watcher.close();
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+async function installSystemdService() {
+  const serviceDir = path3.join(os3.homedir(), ".config", "systemd", "user");
+  await fs3.mkdir(serviceDir, { recursive: true });
+  const servicePath = path3.join(serviceDir, "managerd.service");
+  const execStart = `${process.execPath} ${getManagerdEntry()}`;
+  const workingDir = path3.dirname(getManagerdEntry());
+  const unit = `[Unit]
+Description=Justevery Manager Daemon
+After=network.target
+
+[Service]
+ExecStart=${execStart}
+Restart=on-failure
+Environment=MANAGERD_STORAGE=memory
+WorkingDirectory=${workingDir}
+
+[Install]
+WantedBy=default.target
+`;
+  await fs3.writeFile(servicePath, unit, "utf8");
+  console.log("Installed systemd service to", servicePath);
+  console.log("Run the following commands to enable it:");
+  console.log("  systemctl --user daemon-reload");
+  console.log("  systemctl --user enable --now managerd.service");
+}
+function getManagerdEntry() {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(here, "managerd.js");
+}
+function renderIntegrationReport(report) {
+  console.log(chalk.bold(`Integration: ${report.agent}`));
+  console.log("Status:", report.status);
+  console.log("\nChecks:");
+  for (const check of report.checks) {
+    const prefix = statusIcon(check.status);
+    const detail = check.detail ? ` \u2014 ${check.detail}` : "";
+    console.log(` ${prefix} ${check.name}${detail}`);
+  }
+  if (report.manualSteps.length) {
+    console.log("\nManual steps:");
+    report.manualSteps.forEach((step, idx) => {
+      console.log(` ${idx + 1}. ${step}`);
+    });
+  } else {
+    console.log("\nNo manual steps required.");
+  }
+}
+function statusIcon(status) {
+  switch (status) {
+    case "ok":
+      return chalk.green("\u2714");
+    case "missing":
+      return chalk.red("\u2716");
+    case "warn":
+      return chalk.yellow("!");
+    default:
+      return chalk.gray("-");
+  }
+}

package/dist/daemon-DTD73K4H.js

@@ -0,0 +1,7 @@
+import {
+  startDaemon
+} from "./chunk-KD5PYPXI.js";
+import "./chunk-ZQKKKD3J.js";
+export {
+  startDaemon
+};

package/dist/managerd.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  startDaemon
+} from "./chunk-KD5PYPXI.js";
+import "./chunk-ZQKKKD3J.js";
+
+// src/managerd.ts
+startDaemon().catch((err) => {
+  console.error("Failed to start managerd", err);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@just-every/manager",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "manager": "dist/cli.js",
+    "managerd": "dist/managerd.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts src/managerd.ts --format esm --target node20 --out-dir dist",
+    "dev": "tsx src/cli.ts",
+    "dev:daemon": "tsx src/managerd.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.5.0",
+    "chalk": "^5.3.0",
+    "commander": "^14.0.0",
+    "execa": "^9.4.0",
+    "node-fetch": "^3.3.2",
+    "pino": "^9.5.0",
+    "pino-pretty": "^11.2.2",
+    "tiny-invariant": "^1.3.3",
+    "tslib": "^2.8.1",
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.7.11",
+    "@types/pino-pretty": "^5.0.0",
+    "@types/uuid": "^10.0.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}