@adapt-toolkit/a2adapt 0.2.0 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { connect } from "node:net";
+import { homedir } 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) {
+    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 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("");
+  out("Config (env): A2ADAPT_BROKER_URL, A2ADAPT_PORT (3030), A2ADAPT_STATE_DIR (~/.a2adapt)");
+}
+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";
+      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 "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);
+});