@adapt-toolkit/a2adapt 0.2.0 → 0.4.0

package/dist/cli.js

@@ -0,0 +1,422 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/cli.ts
+import { spawn, spawnSync } from "node:child_process";
+import { connect } from "node:net";
+import { homedir, userInfo } from "node:os";
+import { resolve, join, dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as fs from "node:fs";
+var STATE_DIR = resolve(process.env.A2ADAPT_STATE_DIR ?? resolve(homedir(), ".a2adapt"));
+var PORT = parseInt(process.env.A2ADAPT_PORT ?? "3030", 10);
+var BROKER_URL = process.env.A2ADAPT_BROKER_URL ?? "wss://a2adapt.adaptframework.solutions/broker";
+var PID_PATH = join(STATE_DIR, "daemon.pid");
+var LOG_PATH = join(STATE_DIR, "daemon.log");
+var SELF = fileURLToPath(import.meta.url);
+var out = (...p) => process.stdout.write(`${p.join(" ")}
+`);
+var err = (...p) => process.stderr.write(`${p.join(" ")}
+`);
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function readPid() {
+  try {
+    const n = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
+    return Number.isFinite(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runningPid() {
+  const pid = readPid();
+  if (pid && isAlive(pid)) return pid;
+  if (pid) {
+    try {
+      fs.rmSync(PID_PATH, { force: true });
+    } catch {
+    }
+  }
+  return null;
+}
+function portOpen(port, timeoutMs = 1e3) {
+  return new Promise((res) => {
+    const sock = connect({ host: "127.0.0.1", port });
+    const done = (ok) => {
+      sock.destroy();
+      res(ok);
+    };
+    sock.setTimeout(timeoutMs);
+    sock.once("connect", () => done(true));
+    sock.once("timeout", () => done(false));
+    sock.once("error", () => done(false));
+  });
+}
+async function waitForPort(port, totalMs = 3e4) {
+  const deadline = Date.now() + totalMs;
+  while (Date.now() < deadline) {
+    if (await portOpen(port)) return true;
+    await sleep(400);
+  }
+  return false;
+}
+async function cmdStart() {
+  const existing = runningPid();
+  if (existing) {
+    out(`a2adapt-mcp is already running (pid ${existing}, port ${PORT}).`);
+    return;
+  }
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  const logFd = fs.openSync(LOG_PATH, "a");
+  const child = spawn(process.execPath, [SELF, "serve"], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: {
+      ...process.env,
+      A2ADAPT_TRANSPORT: "http",
+      A2ADAPT_PORT: String(PORT),
+      A2ADAPT_BROKER_URL: BROKER_URL,
+      A2ADAPT_STATE_DIR: STATE_DIR
+    }
+  });
+  child.unref();
+  if (!child.pid) {
+    err("failed to spawn the daemon.");
+    process.exit(1);
+  }
+  fs.writeFileSync(PID_PATH, String(child.pid));
+  out(`starting a2adapt-mcp (pid ${child.pid})\u2026`);
+  const ready = await waitForPort(PORT);
+  if (ready) {
+    out(`a2adapt-mcp is up on http://localhost:${PORT}/mcp`);
+    out(`  broker: ${BROKER_URL}`);
+    out(`  state:  ${STATE_DIR}`);
+    out(`  logs:   ${LOG_PATH}`);
+  } else {
+    err(`daemon started (pid ${child.pid}) but port ${PORT} did not open within 30s \u2014 check ${LOG_PATH}.`);
+    process.exit(1);
+  }
+}
+async function cmdStop() {
+  const pid = runningPid();
+  if (!pid) {
+    out("a2adapt-mcp is not running.");
+    return;
+  }
+  out(`stopping a2adapt-mcp (pid ${pid})\u2026`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (e) {
+    err(`failed to signal pid ${pid}: ${String(e)}`);
+  }
+  for (let i = 0; i < 25 && isAlive(pid); i++) await sleep(200);
+  if (isAlive(pid)) {
+    err(`pid ${pid} did not exit; sending SIGKILL.`);
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  try {
+    fs.rmSync(PID_PATH, { force: true });
+  } catch {
+  }
+  out("stopped.");
+}
+async function cmdStatus() {
+  const pid = runningPid();
+  if (!pid) {
+    if (await portOpen(PORT)) {
+      out("a2adapt-mcp: running (no pidfile \u2014 likely a stale process or external launcher)");
+      out(`  url:    http://localhost:${PORT}/mcp (reachable)`);
+      return;
+    }
+    out("a2adapt-mcp: stopped");
+    process.exitCode = 1;
+    return;
+  }
+  const up = await portOpen(PORT);
+  out("a2adapt-mcp: running");
+  out(`  pid:    ${pid}`);
+  out(`  url:    http://localhost:${PORT}/mcp ${up ? "(reachable)" : "(port not answering!)"}`);
+  out(`  broker: ${BROKER_URL}`);
+  out(`  state:  ${STATE_DIR}`);
+  out(`  logs:   ${LOG_PATH}`);
+}
+function cmdWatch(which) {
+  const offsets = /* @__PURE__ */ new Map();
+  const scan = (initial) => {
+    let names;
+    try {
+      names = fs.readdirSync(STATE_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (which && name !== which) continue;
+      const logPath = join(STATE_DIR, name, "inbox.log");
+      let size;
+      try {
+        size = fs.statSync(logPath).size;
+      } catch {
+        continue;
+      }
+      let seen = offsets.get(logPath);
+      if (seen === void 0) {
+        seen = initial ? size : 0;
+        offsets.set(logPath, seen);
+        if (initial) continue;
+      }
+      if (size <= seen) {
+        if (size < seen) offsets.set(logPath, size);
+        continue;
+      }
+      let chunk;
+      try {
+        const fd = fs.openSync(logPath, "r");
+        const buf = Buffer.alloc(size - seen);
+        fs.readSync(fd, buf, 0, buf.length, seen);
+        fs.closeSync(fd);
+        chunk = buf.toString("utf8");
+      } catch {
+        continue;
+      }
+      offsets.set(logPath, size);
+      for (const line of chunk.split("\n")) {
+        if (!line.trim()) continue;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        out(
+          `[${name}] new message from ${msg.sender ?? "?"}: ${msg.text ?? ""}` + (msg.date ? `  (${msg.date})` : "")
+        );
+      }
+    }
+  };
+  err(
+    `a2adapt-mcp watch: watching ${which ? `identity "${which}"` : "all identities"} under ${STATE_DIR} (Ctrl-C to stop)`
+  );
+  scan(true);
+  const timer = setInterval(() => scan(false), 1e3);
+  const stop = () => {
+    clearInterval(timer);
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+}
+var SYSTEMD_UNIT = "a2adapt.service";
+var LAUNCHD_LABEL = "solutions.adaptframework.a2adapt";
+function systemdUnitPath() {
+  return join(homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+}
+function launchdPlistPath() {
+  return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function run(cmd, args) {
+  const r = spawnSync(cmd, args, { stdio: "inherit" });
+  return r.status === 0;
+}
+function installSystemd() {
+  const unitPath = systemdUnitPath();
+  fs.mkdirSync(dirname(unitPath), { recursive: true });
+  const unit = `[Unit]
+Description=a2adapt MCP daemon (secure agent-to-agent messaging over ADAPT)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${SELF} serve
+Environment=A2ADAPT_TRANSPORT=http
+Environment=A2ADAPT_PORT=${PORT}
+Environment=A2ADAPT_BROKER_URL=${BROKER_URL}
+Environment=A2ADAPT_STATE_DIR=${STATE_DIR}
+Restart=on-failure
+RestartSec=2
+
+[Install]
+WantedBy=default.target
+`;
+  fs.writeFileSync(unitPath, unit);
+  out(`wrote ${unitPath}`);
+  run("systemctl", ["--user", "daemon-reload"]);
+  if (!run("systemctl", ["--user", "enable", "--now", SYSTEMD_UNIT])) {
+    err("failed to enable/start the service via systemctl --user.");
+    process.exit(1);
+  }
+  if (!run("loginctl", ["enable-linger", userInfo().username])) {
+    err("warning: could not enable linger \u2014 the daemon may not start until you log in.");
+    err(`  run manually: loginctl enable-linger ${userInfo().username}`);
+  }
+  out("");
+  out(`a2adapt-mcp installed as a systemd user service and started.`);
+  out(`  status:  systemctl --user status ${SYSTEMD_UNIT}`);
+  out(`  logs:    journalctl --user -u ${SYSTEMD_UNIT} -f`);
+  out(`  remove:  a2adapt-mcp uninstall-service`);
+}
+function uninstallSystemd() {
+  run("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
+  const unitPath = systemdUnitPath();
+  try {
+    fs.rmSync(unitPath, { force: true });
+    out(`removed ${unitPath}`);
+  } catch (e) {
+    err(`failed to remove ${unitPath}: ${String(e)}`);
+  }
+  run("systemctl", ["--user", "daemon-reload"]);
+  out("a2adapt-mcp service uninstalled.");
+}
+function installLaunchd() {
+  const plistPath = launchdPlistPath();
+  fs.mkdirSync(dirname(plistPath), { recursive: true });
+  const plist = `<?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>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${SELF}</string>
+    <string>serve</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>A2ADAPT_TRANSPORT</key><string>http</string>
+    <key>A2ADAPT_PORT</key><string>${PORT}</string>
+    <key>A2ADAPT_BROKER_URL</key><string>${BROKER_URL}</string>
+    <key>A2ADAPT_STATE_DIR</key><string>${STATE_DIR}</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key><string>${LOG_PATH}</string>
+</dict>
+</plist>
+`;
+  fs.writeFileSync(plistPath, plist);
+  out(`wrote ${plistPath}`);
+  run("launchctl", ["unload", plistPath]);
+  if (!run("launchctl", ["load", "-w", plistPath])) {
+    err("failed to load the launchd agent.");
+    process.exit(1);
+  }
+  out("");
+  out("a2adapt-mcp installed as a launchd agent and started.");
+  out(`  remove:  a2adapt-mcp uninstall-service`);
+}
+function uninstallLaunchd() {
+  const plistPath = launchdPlistPath();
+  run("launchctl", ["unload", plistPath]);
+  try {
+    fs.rmSync(plistPath, { force: true });
+    out(`removed ${plistPath}`);
+  } catch (e) {
+    err(`failed to remove ${plistPath}: ${String(e)}`);
+  }
+  out("a2adapt-mcp service uninstalled.");
+}
+async function cmdInstallService() {
+  await cmdStop();
+  if (process.platform === "linux") return installSystemd();
+  if (process.platform === "darwin") return installLaunchd();
+  err(`install-service: unsupported platform "${process.platform}" (only linux/systemd and macOS/launchd).`);
+  process.exit(1);
+}
+function cmdUninstallService() {
+  if (process.platform === "linux") return uninstallSystemd();
+  if (process.platform === "darwin") return uninstallLaunchd();
+  err(`uninstall-service: unsupported platform "${process.platform}".`);
+  process.exit(1);
+}
+function usage() {
+  out("a2adapt-mcp \u2014 daemon for the a2adapt MCP server");
+  out("");
+  out("Usage: a2adapt-mcp <command>");
+  out("  start     start the daemon in the background");
+  out("  stop      stop the running daemon");
+  out("  restart   stop then start");
+  out("  status    show whether the daemon is running");
+  out("  serve     run in the foreground (used by start; handy for debugging)");
+  out("  watch [identity]  stream one line per new inbound message (wake source for a Monitor)");
+  out("");
+  out("  install-service    install + start a boot-persistent service (systemd/launchd)");
+  out("  uninstall-service  stop + remove that service");
+  out("");
+  out("Config (env): A2ADAPT_BROKER_URL, A2ADAPT_PORT (3030), A2ADAPT_STATE_DIR (~/.a2adapt)");
+  out("(install-service bakes the current config values into the service definition.)");
+}
+async function main() {
+  const cmd = process.argv[2] ?? "help";
+  switch (cmd) {
+    case "serve":
+    case "run":
+      if (!process.env.A2ADAPT_TRANSPORT) process.env.A2ADAPT_TRANSPORT = "http";
+      fs.mkdirSync(STATE_DIR, { recursive: true });
+      fs.writeFileSync(PID_PATH, String(process.pid));
+      {
+        const cleanup = () => {
+          try {
+            fs.rmSync(PID_PATH, { force: true });
+          } catch {
+          }
+        };
+        process.on("exit", cleanup);
+        for (const sig of ["SIGTERM", "SIGINT"]) {
+          process.on(sig, () => {
+            cleanup();
+            process.exit(0);
+          });
+        }
+      }
+      await import(pathToFileURL(join(dirname(SELF), "index.js")).href);
+      break;
+    case "start":
+      await cmdStart();
+      break;
+    case "stop":
+      await cmdStop();
+      break;
+    case "restart":
+      await cmdStop();
+      await cmdStart();
+      break;
+    case "status":
+      await cmdStatus();
+      break;
+    case "watch":
+      cmdWatch(process.argv[3]);
+      break;
+    case "install-service":
+      await cmdInstallService();
+      break;
+    case "uninstall-service":
+      cmdUninstallService();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      usage();
+      break;
+    default:
+      err(`unknown command: ${cmd}
+`);
+      usage();
+      process.exit(1);
+  }
+}
+main().catch((e) => {
+  err(`a2adapt-mcp error: ${e?.stack ?? e}`);
+  process.exit(1);
+});

package/dist/hooks/runner.js

@@ -2,24 +2,122 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/hooks/runner.ts
-async function sessionStart() {
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import { resolve, join } from "node:path";
+var STATE_DIR = resolve(
+  process.env.A2ADAPT_STATE_DIR ?? resolve(homedir(), ".a2adapt")
+);
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function emit(payload) {
+  process.stdout.write(JSON.stringify(payload));
 }
-async function userPromptSubmit() {
+function noop() {
+  emit({ continue: true });
 }
-async function main() {
+function readCursor(dir) {
+  try {
+    return parseInt(fs.readFileSync(join(dir, "inbox_cursor"), "utf8").trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+function readInboxLog(dir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(join(dir, "inbox.log"), "utf8");
+  } catch {
+    return [];
+  }
+  const msgs = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const m = JSON.parse(line);
+      msgs.push({
+        sender: String(m.sender ?? "?"),
+        text: String(m.text ?? ""),
+        date: String(m.date ?? "")
+      });
+    } catch {
+    }
+  }
+  return msgs;
+}
+function collectUnread() {
+  let names;
+  try {
+    names = fs.readdirSync(STATE_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const dir = join(STATE_DIR, name);
+    const all = readInboxLog(dir);
+    if (all.length === 0) continue;
+    const unread = all.slice(readCursor(dir));
+    if (unread.length === 0) continue;
+    out.push({ name, count: unread.length, messages: unread });
+  }
+  return out;
+}
+function renderContext(unread) {
+  const total = unread.reduce((n, u) => n + u.count, 0);
+  const lines = [];
+  for (const u of unread) {
+    lines.push(`\u2022 ${u.name} \u2014 ${u.count} unread:`);
+    for (const m of u.messages.slice(-5)) {
+      lines.push(`    [${m.sender}] ${m.text}${m.date ? `  (${m.date})` : ""}`);
+    }
+    if (u.count > 5) lines.push(`    \u2026and ${u.count - 5} earlier`);
+  }
+  return `a2adapt \u2014 ${total} unread message(s) across ${unread.length} identit${unread.length === 1 ? "y" : "ies"} (arrived while you were away):
+${lines.join("\n")}
+
+To read & clear: choose_identity({ name }) then process_incoming_message(). To wait for live replies, arm a Monitor on the wake source \`a2adapt-mcp watch\` (each new-mail line wakes you).`;
+}
+function sessionStart() {
+  const raw = readStdin();
+  let source = "";
+  if (raw) {
+    try {
+      source = JSON.parse(raw).source ?? "";
+    } catch {
+    }
+  }
+  if (source === "compact") return noop();
+  const unread = collectUnread();
+  if (unread.length === 0) return noop();
+  emit({
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: renderContext(unread)
+    }
+  });
+}
+function main() {
   const kind = process.argv[2] ?? "";
-  switch (kind) {
-    case "session-start":
-      await sessionStart();
-      break;
-    case "user-prompt-submit":
-      await userPromptSubmit();
-      break;
-    default:
-      break;
-  }
-}
-main().catch((err) => {
-  process.stderr.write(`a2adapt hook: ${err?.stack ?? err}
+  try {
+    switch (kind) {
+      case "session-start":
+        sessionStart();
+        return;
+      default:
+        noop();
+        return;
+    }
+  } catch (err) {
+    process.stderr.write(`a2adapt hook: ${err?.stack ?? err}
 `);
-}).finally(() => process.exit(0));
+    noop();
+  }
+}
+main();