debugsk 0.0.1

package/dist/cli.js

@@ -0,0 +1,906 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_os = __toESM(require("os"));
+var import_node_path4 = __toESM(require("path"));
+var import_promises4 = __toESM(require("readline/promises"));
+var import_minimist = __toESM(require("minimist"));
+
+// src/constants.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 7242;
+var DEFAULT_BASE_PATH = "/";
+var DEFAULT_LOGS_DIR = ".logs";
+var DEFAULT_MAX_BODY_KB = 256;
+
+// src/process.ts
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error;
+    return err.code === "EPERM";
+  }
+}
+async function terminateProcess(pid, timeoutMs) {
+  if (!isProcessAlive(pid)) return true;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    const err = error;
+    if (err.code === "ESRCH") return true;
+  }
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isProcessAlive(pid)) return true;
+    await sleep(100);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch (error) {
+    const err = error;
+    if (err.code === "ESRCH") return true;
+  }
+  return !isProcessAlive(pid);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/paths.ts
+var import_node_path = __toESM(require("path"));
+function resolveLogsDir({ cwd, logsDir }) {
+  const dir = logsDir && logsDir.length > 0 ? logsDir : DEFAULT_LOGS_DIR;
+  return import_node_path.default.resolve(cwd, dir);
+}
+function getRuntimeDir(logsDir) {
+  return logsDir;
+}
+function getRuntimePath(logsDir) {
+  return import_node_path.default.join(getRuntimeDir(logsDir), "runtime.json");
+}
+function getPidPath(logsDir) {
+  return import_node_path.default.join(getRuntimeDir(logsDir), "server.pid");
+}
+function getSessionLogPath(logsDir, sessionId, runId, _timestamp) {
+  const safeSession = sanitizePathSegment(sessionId);
+  const safeRun = sanitizePathSegment(runId);
+  return import_node_path.default.join(getRuntimeDir(logsDir), `${safeSession}-${safeRun}.jsonl`);
+}
+function sanitizePathSegment(value) {
+  return value.replace(/[\\/]/g, "_").replace(/\.\./g, "_").trim() || "unknown";
+}
+
+// src/runtime.ts
+var import_promises = __toESM(require("fs/promises"));
+async function readRuntime(logsDir) {
+  try {
+    const raw = await import_promises.default.readFile(getRuntimePath(logsDir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeRuntime(logsDir, info) {
+  await import_promises.default.mkdir(getRuntimeDir(logsDir), { recursive: true });
+  await import_promises.default.writeFile(getRuntimePath(logsDir), JSON.stringify(info, null, 2), "utf8");
+}
+async function writePid(logsDir, pid) {
+  await import_promises.default.mkdir(getRuntimeDir(logsDir), { recursive: true });
+  await import_promises.default.writeFile(getPidPath(logsDir), String(pid), "utf8");
+}
+async function removePid(logsDir) {
+  try {
+    await import_promises.default.unlink(getPidPath(logsDir));
+  } catch {
+    return;
+  }
+}
+async function markStopped(logsDir) {
+  const current = await readRuntime(logsDir);
+  if (!current) return;
+  const updated = {
+    ...current,
+    running: false,
+    stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeRuntime(logsDir, updated);
+}
+
+// src/server.ts
+var import_node_http = __toESM(require("http"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/net.ts
+var import_node_net = __toESM(require("net"));
+async function resolvePort(host, port) {
+  if (!port || port === 0) {
+    return getRandomPort(host);
+  }
+  try {
+    await checkPort(host, port);
+    return port;
+  } catch {
+    return getRandomPort(host);
+  }
+}
+function formatBaseUrl(host, port) {
+  const needsBrackets = host.includes(":") && !host.startsWith("[");
+  const safeHost = needsBrackets ? `[${host}]` : host;
+  return `http://${safeHost}:${port}`;
+}
+function checkPort(host, port) {
+  return new Promise((resolve, reject) => {
+    const server = import_node_net.default.createServer();
+    server.once("error", (error) => {
+      server.close();
+      reject(error);
+    });
+    server.listen(port, host, () => {
+      server.close(() => resolve());
+    });
+  });
+}
+function getRandomPort(host) {
+  return new Promise((resolve, reject) => {
+    const server = import_node_net.default.createServer();
+    server.once("error", (error) => {
+      server.close();
+      reject(error);
+    });
+    server.listen(0, host, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("Failed to resolve port")));
+        return;
+      }
+      const selected = address.port;
+      server.close(() => resolve(selected));
+    });
+  });
+}
+
+// src/version.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+function getPackageVersion() {
+  try {
+    const pkgPath = findPackageJsonPath();
+    const raw = import_node_fs.default.readFileSync(pkgPath, "utf8");
+    const data = JSON.parse(raw);
+    return data.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function findPackageJsonPath() {
+  let current = import_node_path2.default.resolve(__dirname);
+  for (let i = 0; i < 5; i += 1) {
+    const candidate = import_node_path2.default.join(current, "package.json");
+    if (import_node_fs.default.existsSync(candidate)) return candidate;
+    current = import_node_path2.default.dirname(current);
+  }
+  return import_node_path2.default.join(process.cwd(), "package.json");
+}
+
+// src/server.ts
+var REQUIRED_FIELDS = ["timestamp", "message", "sessionId", "runId", "hypothesisId"];
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET,POST,OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Debug-Token",
+  "Access-Control-Max-Age": "86400"
+};
+async function startServer(options) {
+  const logsDir = resolveLogsDir({ cwd: options.cwd, logsDir: options.logsDir });
+  const host = options.host;
+  const basePath = normalizeBasePath(options.basePath);
+  const port = await resolvePort(host, options.port);
+  const baseUrl = formatBaseUrl(host, port);
+  let idleTimer;
+  const server = import_node_http.default.createServer(async (req, res) => {
+    applyCorsHeaders(res);
+    try {
+      const url = new URL(req.url ?? "/", baseUrl);
+      const normalizedPath = stripBasePath(url.pathname, basePath);
+      if (normalizedPath == null) {
+        respondJson(res, 404, { ok: false, error: "not_found" });
+        return;
+      }
+      if (req.method === "OPTIONS") {
+        respondNoContent(res, 204);
+        return;
+      }
+      if (req.method === "GET" && normalizedPath === "/health") {
+        respondJson(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "POST" && normalizedPath.startsWith("/ingest/")) {
+        const streamId = decodeURIComponent(normalizedPath.replace("/ingest/", ""));
+        if (!authorizeRequest(req, options.token)) {
+          respondJson(res, 401, { ok: false, error: "unauthorized" });
+          return;
+        }
+        let payload;
+        try {
+          payload = await readJsonBody(req, options.maxBodyKB);
+        } catch (error) {
+          if (error instanceof BodyTooLargeError) {
+            respondJson(res, 413, { ok: false, error: "body_too_large" });
+            return;
+          }
+          respondJson(res, 400, { ok: false, error: "invalid_json" });
+          return;
+        }
+        if (!payload || typeof payload !== "object") {
+          respondJson(res, 400, { ok: false, error: "invalid_body" });
+          return;
+        }
+        const missing = REQUIRED_FIELDS.filter((field) => !(field in payload));
+        if (missing.length > 0) {
+          respondJson(res, 400, { ok: false, error: "missing_fields", missing });
+          return;
+        }
+        const event = payload;
+        const sessionId = String(event.sessionId);
+        const runId = String(event.runId);
+        const timestamp = event.timestamp;
+        const logPath = getSessionLogPath(logsDir, sessionId, runId, timestamp);
+        await import_promises2.default.mkdir(import_node_path3.default.dirname(logPath), { recursive: true });
+        const enriched = {
+          ...event,
+          _meta: {
+            streamId,
+            receivedAt: Date.now()
+          }
+        };
+        await import_promises2.default.appendFile(logPath, `${JSON.stringify(enriched)}
+`, "utf8");
+        if (options.idleTtlMs && options.idleTtlMs > 0) {
+          resetIdleTimer(options.idleTtlMs);
+        }
+        respondJson(res, 200, { ok: true, written: true, path: logPath });
+        return;
+      }
+      respondJson(res, 404, { ok: false, error: "not_found" });
+    } catch {
+      respondJson(res, 500, { ok: false, error: "internal_error" });
+    }
+  });
+  const close = async () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    await new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  };
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => resolve());
+  });
+  const runtime = {
+    ok: true,
+    version: getPackageVersion(),
+    pid: process.pid,
+    cwd: options.cwd,
+    logsDir,
+    running: true,
+    server: {
+      host,
+      port,
+      baseUrl,
+      basePath,
+      endpoints: {
+        health: `${basePath}/health`,
+        ingestTemplate: `${basePath}/ingest/{streamId}`
+      }
+    },
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    options: {
+      maxBodyKB: options.maxBodyKB,
+      tokenEnabled: Boolean(options.token),
+      idleTtlMs: options.idleTtlMs
+    }
+  };
+  await writeRuntime(logsDir, runtime);
+  await writePid(logsDir, process.pid);
+  if (options.idleTtlMs && options.idleTtlMs > 0) {
+    resetIdleTimer(options.idleTtlMs);
+  }
+  return { server, host, port, basePath, baseUrl, logsDir, close };
+  function resetIdleTimer(ttl) {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(async () => {
+      await close();
+      await markStopped(logsDir);
+      await removePid(logsDir);
+      process.exit(0);
+    }, ttl);
+  }
+}
+function normalizeBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  const trimmed = basePath.startsWith("/") ? basePath : `/${basePath}`;
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+function stripBasePath(pathname, basePath) {
+  if (!basePath) return pathname;
+  if (!pathname.startsWith(basePath)) return null;
+  const sliced = pathname.slice(basePath.length);
+  return sliced.length === 0 ? "/" : sliced;
+}
+function authorizeRequest(req, token) {
+  if (!token) return true;
+  const authHeader = req.headers.authorization;
+  if (authHeader && authHeader === `Bearer ${token}`) return true;
+  const headerToken = req.headers["x-debug-token"];
+  if (typeof headerToken === "string" && headerToken === token) return true;
+  return false;
+}
+function respondJson(res, status, payload) {
+  const data = JSON.stringify(payload);
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Content-Length", Buffer.byteLength(data));
+  res.end(data);
+}
+function respondNoContent(res, status) {
+  res.statusCode = status;
+  res.end();
+}
+function applyCorsHeaders(res) {
+  for (const [key, value] of Object.entries(CORS_HEADERS)) {
+    res.setHeader(key, value);
+  }
+}
+var BodyTooLargeError = class extends Error {
+};
+function readJsonBody(req, maxBodyKB) {
+  const maxBytes = maxBodyKB * 1024;
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let finished = false;
+    req.on("data", (chunk) => {
+      if (finished) return;
+      size += chunk.length;
+      if (size > maxBytes) {
+        finished = true;
+        req.destroy();
+        reject(new BodyTooLargeError());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (finished) return;
+      finished = true;
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        resolve(raw.length === 0 ? {} : JSON.parse(raw));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on("error", (error) => {
+      if (finished) return;
+      finished = true;
+      reject(error);
+    });
+  });
+}
+
+// src/cli.ts
+var args = (0, import_minimist.default)(process.argv.slice(2), {
+  boolean: ["json", "force", "help", "user"],
+  string: ["host", "base-path", "logs-dir", "token"],
+  alias: {
+    h: "help",
+    u: "user"
+  }
+});
+var primary = String(args._[0] ?? "help");
+var secondary = args._[1] ? String(args._[1]) : void 0;
+var scope = primary === "server" || primary === "codex" ? primary : "server";
+var command = scope === "server" ? String(primary === "server" ? secondary ?? "help" : primary) : String(secondary ?? "help");
+var json = Boolean(args.json);
+var SKILL_NAME = "code-debug-skill";
+void main().catch((error) => {
+  outputError(error instanceof Error ? error.message : "unexpected_error");
+  process.exitCode = 1;
+});
+async function main() {
+  if (args.help || command === "help") {
+    printHelp();
+    return;
+  }
+  if (scope === "codex") {
+    await handleCodex(command);
+    return;
+  }
+  switch (command) {
+    case "start":
+      await handleStart();
+      return;
+    case "run":
+      if (!process.env.DEBUGSK_CHILD) {
+        outputError("use_start_command");
+        return;
+      }
+      await handleRun();
+      return;
+    case "status":
+      await handleStatus();
+      return;
+    case "stop":
+      await handleStop();
+      return;
+    default:
+      outputError(`unknown_command:${command}`);
+  }
+}
+function getCommonOptions() {
+  const host = String(args.host ?? DEFAULT_HOST);
+  const port = parseNumber(args.port, DEFAULT_PORT) ?? DEFAULT_PORT;
+  const basePath = String(args["base-path"] ?? DEFAULT_BASE_PATH);
+  const logsDir = args["logs-dir"] ? String(args["logs-dir"]) : void 0;
+  const maxBodyKB = parseNumber(args["max-body-kb"], DEFAULT_MAX_BODY_KB) ?? DEFAULT_MAX_BODY_KB;
+  const token = args.token ? String(args.token) : void 0;
+  const idleTtlMs = parseNumber(args["idle-ttl-ms"], void 0);
+  return { host, port, basePath, logsDir, maxBodyKB, token, idleTtlMs };
+}
+async function handleStart() {
+  const { host, port, basePath, logsDir, maxBodyKB, token, idleTtlMs } = getCommonOptions();
+  const cwd = process.cwd();
+  const resolvedLogsDir = resolveLogsDir({ cwd, logsDir });
+  const runtime = await readRuntime(resolvedLogsDir);
+  if (runtime && !runtime.options) {
+    outputLegacyRuntimeError();
+    return;
+  }
+  if (runtime && isProcessAlive(runtime.pid) && !args.force) {
+    const payload2 = buildStartOutput(runtime, true);
+    outputStart(payload2);
+    return;
+  }
+  if (runtime && isProcessAlive(runtime.pid) && args.force) {
+    await terminateProcess(runtime.pid, 3e3);
+    await markStopped(resolvedLogsDir);
+    await removePid(resolvedLogsDir);
+  }
+  if (runtime && !isProcessAlive(runtime.pid)) {
+    await markStopped(resolvedLogsDir);
+    await removePid(resolvedLogsDir);
+  }
+  const spawnResult = await spawnBackground({
+    host,
+    port,
+    basePath,
+    logsDir,
+    maxBodyKB,
+    token,
+    idleTtlMs
+  });
+  const finalRuntime = await waitForRuntime(resolvedLogsDir, 5e3);
+  if (!finalRuntime) {
+    outputError("start_failed");
+    return;
+  }
+  const ok = await waitForHealth(finalRuntime, 5e3);
+  if (!ok) {
+    outputError("health_check_failed");
+    return;
+  }
+  const payload = buildStartOutput(finalRuntime, false, spawnResult?.pid);
+  outputStart(payload);
+}
+async function handleRun() {
+  const { host, port, basePath, logsDir, maxBodyKB, token, idleTtlMs } = getCommonOptions();
+  const cwd = process.cwd();
+  const started = await startServer({
+    host,
+    port,
+    basePath,
+    logsDir,
+    maxBodyKB,
+    token,
+    idleTtlMs,
+    cwd
+  });
+  installSignalHandlers(started.logsDir, started.close);
+  if (!json) {
+    logInfo(`debugsk server listening at ${started.baseUrl}`);
+  }
+}
+async function handleStatus() {
+  const cwd = process.cwd();
+  const logsDir = args["logs-dir"] ? String(args["logs-dir"]) : void 0;
+  const resolvedLogsDir = resolveLogsDir({ cwd, logsDir });
+  const runtime = await readRuntime(resolvedLogsDir);
+  if (!runtime) {
+    outputStatus({ ok: false, running: false, error: "not_running" });
+    return;
+  }
+  if (!runtime.options) {
+    outputLegacyRuntimeError();
+    return;
+  }
+  const running = isProcessAlive(runtime.pid);
+  const payload = {
+    ...runtime,
+    running
+  };
+  outputStatus(payload);
+}
+async function handleStop() {
+  const cwd = process.cwd();
+  const logsDir = args["logs-dir"] ? String(args["logs-dir"]) : void 0;
+  const resolvedLogsDir = resolveLogsDir({ cwd, logsDir });
+  const runtime = await readRuntime(resolvedLogsDir);
+  if (!runtime) {
+    outputStop({ ok: true, stopped: false, running: false });
+    return;
+  }
+  const stopped = await terminateProcess(runtime.pid, 3e3);
+  if (stopped) {
+    await markStopped(resolvedLogsDir);
+    await removePid(resolvedLogsDir);
+  }
+  outputStop({ ok: true, stopped, pid: runtime.pid });
+}
+async function handleCodex(subcommand) {
+  switch (subcommand) {
+    case "install":
+      await codexInstall(false);
+      return;
+    case "update":
+      await codexInstall(true);
+      return;
+    case "remove":
+      await codexRemove();
+      return;
+    default:
+      outputError(`unknown_command:codex:${subcommand}`);
+  }
+}
+async function codexInstall(force) {
+  const source = await resolveSkillSource();
+  const { dest, scope: scope2 } = await resolveCodexDest({ createIfMissing: true });
+  const exists = await pathExists(dest);
+  if (exists && !force) {
+    outputError("codex_skill_already_installed");
+    return;
+  }
+  await ensureSafeDest(dest);
+  if (exists) {
+    await import_promises3.default.rm(dest, { recursive: true, force: true });
+  }
+  await import_promises3.default.mkdir(import_node_path4.default.dirname(dest), { recursive: true });
+  await import_promises3.default.cp(source, dest, { recursive: true });
+  outputJsonResult({
+    ok: true,
+    action: force ? "update" : "install",
+    scope: scope2,
+    dest,
+    source,
+    replaced: exists
+  });
+}
+async function codexRemove() {
+  const { dest, scope: scope2, homeExists } = await resolveCodexDest({ createIfMissing: false });
+  if (!homeExists) {
+    outputJsonResult({
+      ok: true,
+      action: "remove",
+      scope: scope2,
+      dest,
+      removed: false,
+      reason: "codex_home_missing"
+    });
+    return;
+  }
+  await ensureSafeDest(dest);
+  const exists = await pathExists(dest);
+  if (exists) {
+    await import_promises3.default.rm(dest, { recursive: true, force: true });
+  }
+  outputJsonResult({
+    ok: true,
+    action: "remove",
+    scope: scope2,
+    dest,
+    removed: exists
+  });
+}
+async function resolveSkillSource() {
+  const packageRoot = import_node_path4.default.resolve(__dirname, "..");
+  const repoRoot = import_node_path4.default.resolve(packageRoot, "..", "..");
+  const repoSource = import_node_path4.default.join(repoRoot, "skills", SKILL_NAME);
+  if (await pathExists(repoSource)) return repoSource;
+  const packaged = import_node_path4.default.join(packageRoot, "skills", SKILL_NAME);
+  if (await pathExists(packaged)) return packaged;
+  throw new Error(`missing_skill_source:${SKILL_NAME}`);
+}
+async function resolveCodexDest({
+  createIfMissing
+}) {
+  const useUser = Boolean(args.user);
+  const scope2 = useUser ? "user" : "local";
+  const codexHome = useUser ? import_node_path4.default.join(import_node_os.default.homedir(), ".codex") : import_node_path4.default.join(process.cwd(), ".codex");
+  const exists = await pathExists(codexHome);
+  if (!exists && createIfMissing) {
+    await ensureCodexHome(codexHome, scope2);
+  }
+  return { dest: import_node_path4.default.join(codexHome, "skills", SKILL_NAME), scope: scope2, homeExists: exists };
+}
+async function ensureSafeDest(dest) {
+  const resolved = import_node_path4.default.resolve(dest);
+  const root = import_node_path4.default.parse(resolved).root;
+  if (resolved === root || resolved === import_node_os.default.homedir()) {
+    throw new Error("unsafe_dest");
+  }
+}
+async function ensureCodexHome(codexHome, scope2) {
+  if (await pathExists(codexHome)) return;
+  if (!process.stdin.isTTY) {
+    throw new Error("codex_home_missing");
+  }
+  const prompt = `Create ${codexHome} for ${scope2} scope? [y/N]: `;
+  const approved = await confirmPrompt(prompt);
+  if (!approved) {
+    throw new Error("codex_home_missing");
+  }
+  await import_promises3.default.mkdir(codexHome, { recursive: true });
+}
+async function confirmPrompt(prompt) {
+  const rl = import_promises4.default.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await rl.question(prompt);
+  rl.close();
+  return /^y(es)?$/i.test(answer.trim());
+}
+async function pathExists(target) {
+  try {
+    await import_promises3.default.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function spawnBackground(options) {
+  const nodeArgs = [...process.execArgv, process.argv[1]];
+  const cmdArgs = ["run"];
+  cmdArgs.push("--host", options.host);
+  cmdArgs.push("--port", String(options.port));
+  cmdArgs.push("--base-path", options.basePath);
+  cmdArgs.push("--max-body-kb", String(options.maxBodyKB));
+  if (options.logsDir) cmdArgs.push("--logs-dir", options.logsDir);
+  if (options.token) cmdArgs.push("--token", options.token);
+  if (options.idleTtlMs) cmdArgs.push("--idle-ttl-ms", String(options.idleTtlMs));
+  const spawn = await import("child_process");
+  const child = spawn.spawn(process.execPath, [...nodeArgs, ...cmdArgs], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      DEBUGSK_CHILD: "1"
+    }
+  });
+  child.unref();
+  return child.pid ? { pid: child.pid } : null;
+}
+async function waitForRuntime(logsDir, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const runtime = await readRuntime(logsDir);
+    if (runtime && runtime.pid) return runtime;
+    await sleep2(100);
+  }
+  return null;
+}
+async function waitForHealth(runtime, timeoutMs) {
+  const url = new URL(runtime.server.endpoints.health, runtime.server.baseUrl);
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const ok = await checkHealth(url);
+    if (ok) return true;
+    await sleep2(100);
+  }
+  return false;
+}
+async function checkHealth(url) {
+  const http2 = await import("http");
+  return new Promise((resolve) => {
+    const req = http2.get(url, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on("error", () => resolve(false));
+  });
+}
+function buildStartOutput(runtime, existing, spawnedPid) {
+  const ingestPath = runtime.server.endpoints.ingestTemplate;
+  const ingestUrl = new URL(ingestPath.replace("{streamId}", "{streamId}"), runtime.server.baseUrl);
+  const snippetHeaders = {
+    "Content-Type": "application/json"
+  };
+  const tokenEnabled = runtime.options.tokenEnabled;
+  if (tokenEnabled) {
+    snippetHeaders.Authorization = "Bearer YOUR_TOKEN";
+  }
+  const jsFetch = `fetch("${ingestUrl.toString()}",{method:"POST",headers:${JSON.stringify(
+    snippetHeaders
+  )},body:JSON.stringify({...})}).catch(()=>{});`;
+  return {
+    ok: true,
+    version: runtime.version,
+    pid: runtime.pid,
+    cwd: runtime.cwd,
+    logsDir: runtime.logsDir,
+    server: {
+      host: runtime.server.host,
+      port: runtime.server.port,
+      baseUrl: runtime.server.baseUrl,
+      endpoints: runtime.server.endpoints
+    },
+    snippets: {
+      jsFetch
+    },
+    existing,
+    spawnedPid
+  };
+}
+function installSignalHandlers(logsDir, close) {
+  const shutdown = async () => {
+    await close();
+    await markStopped(logsDir);
+    await removePid(logsDir);
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+}
+function outputJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+function outputJsonResult(payload) {
+  if (json) {
+    outputJson(payload);
+    return;
+  }
+  const action = String(payload.action ?? "result");
+  const ok = payload.ok ? "ok" : "error";
+  const dest = payload.dest ? `dest=${payload.dest}` : "";
+  process.stdout.write(`${action} ${ok} ${dest}
+`);
+}
+function outputError(message) {
+  if (json) {
+    outputJson({ ok: false, error: message });
+  } else {
+    process.stderr.write(`${message}
+`);
+  }
+}
+function outputLegacyRuntimeError() {
+  const error = "legacy_runtime_incompatible";
+  const hint = "delete .logs/runtime.json or the entire .logs directory, then retry";
+  if (json) {
+    outputJson({ ok: false, error, hint });
+  } else {
+    process.stderr.write(`${error}: ${hint}
+`);
+  }
+}
+function logInfo(message) {
+  process.stderr.write(`${message}
+`);
+}
+function outputStart(payload) {
+  if (json) {
+    outputJson(payload);
+    return;
+  }
+  const server = payload.server;
+  const pid = payload.pid;
+  const logsDir = payload.logsDir;
+  process.stdout.write(
+    `started pid=${pid} baseUrl=${server.baseUrl} logsDir=${logsDir}
+`
+  );
+}
+function outputStatus(payload) {
+  if (json) {
+    outputJson(payload);
+    return;
+  }
+  const running = payload.running ? "running" : "stopped";
+  const pid = payload.pid ? `pid=${payload.pid}` : "pid=unknown";
+  process.stdout.write(`status ${running} ${pid}
+`);
+}
+function outputStop(payload) {
+  if (json) {
+    outputJson(payload);
+    return;
+  }
+  const stopped = payload.stopped ? "stopped" : "not-stopped";
+  const pid = payload.pid ? `pid=${payload.pid}` : "";
+  process.stdout.write(`stop ${stopped} ${pid}
+`);
+}
+function printHelp() {
+  const text = `debugsk
+
+Usage:
+  server start --json     Start server in background and print JSON
+  server status --json    Show server status
+  server stop --json      Stop background server
+
+  codex install           Install Codex skill (user scope)
+  codex update            Update Codex skill (user scope)
+  codex remove            Remove Codex skill (user scope)
+
+Aliases:
+  start/status/stop       Same as "server <command>"
+
+Options:
+  --host            (default ${DEFAULT_HOST})
+  --port            (default ${DEFAULT_PORT})
+  --base-path       (default ${DEFAULT_BASE_PATH})
+  --logs-dir        (default ${DEFAULT_LOGS_DIR})
+  --max-body-kb     (default ${DEFAULT_MAX_BODY_KB})
+  --token           (optional)
+  --idle-ttl-ms     (optional)
+  --force           (restart even if already running)
+  --json            (stdout JSON only)
+  -u, --user        (install Codex skill to user scope)
+`;
+  if (json) {
+    outputJson({ ok: true, help: text });
+  } else {
+    process.stdout.write(`${text}
+`);
+  }
+}
+function parseNumber(value, fallback) {
+  if (value === void 0 || value === null || value === "") {
+    return fallback;
+  }
+  const parsed = Number(value);
+  if (Number.isFinite(parsed)) return parsed;
+  return fallback;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=cli.js.map