nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-2FTTDCD4.js

@@ -0,0 +1,675 @@
+import {
+  isCompiledBinary,
+  resolveCliEntrypointPath
+} from "./chunk-ISNCLGUZ.js";
+
+// packages/cli/agentRunControl.ts
+import { homedir as nodeHomedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import * as nodeFs from "node:fs";
+import { spawn as nodeSpawn } from "node:child_process";
+function resolveNoloHome(env, homedir = nodeHomedir) {
+  const fromEnv = env?.NOLO_HOME;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
+  return join(homedir(), ".nolo");
+}
+function resolveRunsDir(env, homedir = nodeHomedir) {
+  return join(resolveNoloHome(env, homedir), "runs");
+}
+function resolveRunRecordPath(runId, env, homedir = nodeHomedir) {
+  return join(resolveRunsDir(env, homedir), `${runId}.json`);
+}
+function resolveRunLogPath(runId, env, homedir = nodeHomedir) {
+  return join(resolveRunsDir(env, homedir), `${runId}.log`);
+}
+function defaultGenerateRunId() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const random = Math.random().toString(36).slice(2, 8);
+  return `run-${timestamp}-${random}`;
+}
+function writeRunRecord(record, deps = {}) {
+  const fs = deps.fs ?? nodeFs;
+  const path = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
+  fs.mkdirSync(resolveRunsDir(deps.env, deps.homedir), { recursive: true });
+  fs.writeFileSync(path, JSON.stringify(record, null, 2));
+}
+var FILE_EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["writeFile", "editFile"]);
+var DEFAULT_ACTIVITY_WRITE_INTERVAL_MS = 2e3;
+function createRunActivityTracker(runId, deps = {}, options = {}) {
+  const fs = deps.fs ?? nodeFs;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const minWriteIntervalMs = options.minWriteIntervalMs ?? DEFAULT_ACTIVITY_WRITE_INTERVAL_MS;
+  let lastEventAt = now().toISOString();
+  let inFlight = null;
+  const counters = { llmCalls: 0, toolCalls: 0, fileEdits: 0 };
+  let writeTimer;
+  let lastWriteAt = 0;
+  function serializeActivity() {
+    const nowDate = now();
+    const nowMs = nowDate.getTime();
+    return {
+      lastEventAt,
+      inFlight: inFlight ? {
+        kind: inFlight.kind,
+        name: inFlight.name,
+        sinceMs: Math.max(0, nowMs - inFlight.startMs)
+      } : null,
+      counters: { ...counters },
+      updatedAt: nowDate.toISOString()
+    };
+  }
+  function doWrite() {
+    writeTimer = void 0;
+    const record = readRunRecord(runId, deps);
+    if (!record) return;
+    const activity = serializeActivity();
+    writeRunRecord({ ...record, activity }, deps);
+    lastWriteAt = now().getTime();
+  }
+  function scheduleWrite() {
+    if (writeTimer !== void 0) return;
+    const elapsed = now().getTime() - lastWriteAt;
+    const delay = Math.max(0, minWriteIntervalMs - elapsed);
+    writeTimer = setTimeout(doWrite, delay);
+  }
+  function onLoopEvent(event) {
+    lastEventAt = new Date(event.atMs).toISOString();
+    switch (event.kind) {
+      case "llm-start":
+        inFlight = { kind: "llm", name: "llm", startMs: event.atMs };
+        break;
+      case "llm-end":
+        inFlight = null;
+        counters.llmCalls += 1;
+        break;
+      case "tool-start":
+        inFlight = { kind: "tool", name: event.name, startMs: event.atMs };
+        break;
+      case "tool-end":
+        inFlight = null;
+        counters.toolCalls += 1;
+        if (FILE_EDIT_TOOL_NAMES.has(event.name)) {
+          counters.fileEdits += 1;
+        }
+        break;
+    }
+    scheduleWrite();
+  }
+  function getActivity() {
+    return serializeActivity();
+  }
+  function flush() {
+    doWrite();
+  }
+  function dispose() {
+    if (writeTimer !== void 0) {
+      clearTimeout(writeTimer);
+      writeTimer = void 0;
+    }
+  }
+  return { onLoopEvent, getActivity, flush, dispose };
+}
+function readRunRecord(runId, deps = {}) {
+  const fs = deps.fs ?? nodeFs;
+  const path = resolveRunRecordPath(runId, deps.env, deps.homedir);
+  try {
+    return JSON.parse(fs.readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listRunRecords(deps = {}) {
+  const fs = deps.fs ?? nodeFs;
+  const dir = resolveRunsDir(deps.env, deps.homedir);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const runId = entry.slice(0, -".json".length);
+    const record = readRunRecord(runId, deps);
+    if (record) records.push(record);
+  }
+  return records.sort(
+    (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
+  );
+}
+function findRunRecordByPid(pid, deps = {}) {
+  return listRunRecords(deps).find((record) => record.pid === pid);
+}
+function findRunRecord(target, deps = {}) {
+  if (/^\d+$/.test(target)) {
+    const pid = Number(target);
+    const byPid = findRunRecordByPid(pid, deps);
+    if (byPid) return byPid;
+  }
+  return readRunRecord(target, deps) ?? void 0;
+}
+function stripBackgroundFlag(args) {
+  const result = [];
+  for (const arg of args) {
+    if (arg === "--bg" || arg.startsWith("--bg=")) continue;
+    result.push(arg);
+  }
+  return result;
+}
+function absolutizeSkillArgs(args, baseCwd = process.cwd()) {
+  const result = [];
+  const resolveIfPath = (value) => {
+    if (isAbsolute(value)) return value;
+    const looksLikePath = value.includes("/") || value.endsWith(".md");
+    return looksLikePath ? resolve(baseCwd, value) : value;
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--skill" && typeof args[i + 1] === "string") {
+      result.push(arg, resolveIfPath(args[i + 1]));
+      i++;
+      continue;
+    }
+    const eqMatch = arg.match(/^--skill=(.+)$/);
+    if (eqMatch) {
+      result.push(`--skill=${resolveIfPath(eqMatch[1])}`);
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+function rewriteMsgFileArg(args, messagePath) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--msg-file" && typeof args[i + 1] === "string") {
+      result.push(arg, messagePath);
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--msg-file=")) {
+      result.push(`--msg-file=${messagePath}`);
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+function buildAgentRunChildCommand(options) {
+  const execPath = process.execPath;
+  const entrypoint = options.cliEntrypointPath || resolveCliEntrypointPath();
+  const commandParts = options.commandPath ?? [];
+  let strippedArgs = stripBackgroundFlag(options.rawArgs);
+  if (options.messagePath) {
+    strippedArgs = rewriteMsgFileArg(strippedArgs, options.messagePath);
+  }
+  strippedArgs = absolutizeSkillArgs(strippedArgs);
+  if (isCompiledBinary() || entrypoint === execPath) {
+    return { execPath, childArgs: [...commandParts, ...strippedArgs] };
+  }
+  return { execPath, childArgs: [entrypoint, ...commandParts, ...strippedArgs] };
+}
+async function spawnLocalBackgroundRun(input, deps = {}) {
+  const env = deps.env ?? process.env;
+  const homedir = deps.homedir ?? nodeHomedir;
+  const fs = deps.fs ?? nodeFs;
+  const spawn = deps.spawn ?? nodeSpawn;
+  const generateRunId = deps.generateRunId ?? defaultGenerateRunId;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const runId = generateRunId();
+  const logPath = resolveRunLogPath(runId, env, homedir);
+  const recordPath = resolveRunRecordPath(runId, env, homedir);
+  const runsDir = resolveRunsDir(env, homedir);
+  fs.mkdirSync(runsDir, { recursive: true });
+  let messagePath;
+  if (typeof input.message === "string") {
+    messagePath = join(runsDir, `${runId}.msg.md`);
+    fs.writeFileSync(messagePath, input.message);
+  }
+  const record = {
+    runId,
+    agentKey: input.agentKey,
+    cwd: input.cwd,
+    ...messagePath ? { msgFile: messagePath } : input.msgFile ? { msgFile: input.msgFile } : {},
+    startedAt: now().toISOString(),
+    ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
+    status: "running",
+    logPath
+  };
+  fs.writeFileSync(recordPath, JSON.stringify(record, null, 2));
+  const { execPath, childArgs } = buildAgentRunChildCommand({
+    rawArgs: input.rawArgs,
+    commandPath: input.commandPath,
+    cliEntrypointPath: input.cliEntrypointPath,
+    messagePath
+  });
+  const childEnv = {
+    ...env,
+    NOLO_AGENT_RUN_CHILD: "1",
+    NOLO_AGENT_RUN_ID: runId
+  };
+  const logFd = fs.openSync(logPath, "a");
+  const proc = spawn(execPath, childArgs, {
+    cwd: input.cwd,
+    env: childEnv,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  proc.unref();
+  if (typeof proc.pid === "number") {
+    record.pid = proc.pid;
+    fs.writeFileSync(recordPath, JSON.stringify(record, null, 2));
+  }
+  return { runId, pid: proc.pid, logPath };
+}
+function finalizeRunRecord(runId, update, deps = {}) {
+  const record = readRunRecord(runId, deps);
+  if (!record) return;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  record.status = update.status;
+  if (typeof update.exitCode === "number") record.exitCode = update.exitCode;
+  if (update.dialogId) record.dialogId = update.dialogId;
+  record.endedAt = now().toISOString();
+  writeRunRecord(record, deps);
+}
+function isPidGone(pid, deps = {}) {
+  const kill = deps.kill ?? ((p, s) => process.kill(p, s));
+  try {
+    kill(pid, "0");
+    return false;
+  } catch (error) {
+    const code = error.code;
+    return code === "ESRCH";
+  }
+}
+function checkStaleRun(runId, deps = {}) {
+  const record = readRunRecord(runId, deps);
+  if (!record) return null;
+  if (record.status !== "running") return record;
+  if (typeof record.pid !== "number") return record;
+  if (!isPidGone(record.pid, deps)) return record;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  record.status = "failed";
+  record.note = "process gone: pid no longer exists";
+  record.endedAt = now().toISOString();
+  writeRunRecord(record, deps);
+  return record;
+}
+function formatDuration(startedAt, endedAt) {
+  const start = new Date(startedAt).getTime();
+  const end = endedAt ? new Date(endedAt).getTime() : Date.now();
+  const elapsedMs = Math.max(0, end - start);
+  const seconds = Math.floor(elapsedMs / 1e3) % 60;
+  const minutes = Math.floor(elapsedMs / 6e4) % 60;
+  const hours = Math.floor(elapsedMs / 36e5);
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function readLastLogLines(logPath, count, deps) {
+  const fs = deps.fs ?? nodeFs;
+  try {
+    const content = fs.readFileSync(logPath, "utf8");
+    const lines = content.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    return lines.slice(-count);
+  } catch {
+    return [];
+  }
+}
+function readLogContent(logPath, tailCount, deps) {
+  const fs = deps.fs ?? nodeFs;
+  try {
+    const content = fs.readFileSync(logPath, "utf8");
+    if (typeof tailCount === "number" && tailCount > 0) {
+      const lines = content.split("\n");
+      if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+      return `${lines.slice(-tailCount).join("\n")}
+`;
+    }
+    return content;
+  } catch {
+    return "";
+  }
+}
+var RUNNING_STATUSES = /* @__PURE__ */ new Set(["running"]);
+function isRunningStatus(status) {
+  return RUNNING_STATUSES.has(status);
+}
+function parseJsonFlag(args) {
+  let json = false;
+  const rest = [];
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg.startsWith("--json=")) {
+      const value = arg.slice("--json=".length);
+      json = value === "" || value === "true" || value === "1";
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { json, rest };
+}
+function defaultSleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function runAgentPsCommand(args, deps) {
+  const { json } = parseJsonFlag(args);
+  const records = listRunRecords(deps);
+  for (const record of records) {
+    if (record.status === "running" && typeof record.pid === "number") {
+      checkStaleRun(record.runId, deps);
+    }
+  }
+  const refreshed = records.map((r) => readRunRecord(r.runId, deps)).filter(Boolean);
+  if (json) {
+    deps.output.write(JSON.stringify(refreshed) + "\n");
+    return 0;
+  }
+  if (refreshed.length === 0) {
+    deps.output.write("No local runs found.\n");
+    return 0;
+  }
+  deps.output.write("RUN ID                          STATUS   PID      AGENT\n");
+  for (const record of refreshed) {
+    const pid = record.pid?.toString() ?? "-";
+    deps.output.write(
+      `${record.runId.padEnd(32)} ${record.status.padEnd(8)} ${pid.padEnd(8)} ${record.agentKey}
+`
+    );
+  }
+  return 0;
+}
+function parseStatusArgs(args) {
+  let target = "";
+  let json = false;
+  let watch = false;
+  let intervalMs = 2e3;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg.startsWith("--json=")) {
+      const value = arg.slice("--json=".length);
+      json = value === "" || value === "true" || value === "1";
+      continue;
+    }
+    if (arg === "--watch") {
+      watch = true;
+      continue;
+    }
+    if (arg.startsWith("--watch=")) {
+      const value = arg.slice("--watch=".length);
+      watch = value === "" || value === "true" || value === "1";
+      continue;
+    }
+    if (arg === "--interval-ms") {
+      const next = args[i + 1];
+      if (next && /^\d+$/.test(next)) {
+        intervalMs = Number(next);
+        i += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith("--interval-ms=")) {
+      const value = arg.slice("--interval-ms=".length);
+      if (/^\d+$/.test(value)) intervalMs = Number(value);
+      continue;
+    }
+    if (!arg.startsWith("-") && !target) {
+      target = arg;
+    }
+  }
+  return { target, json, watch, intervalMs };
+}
+function printStatusTick(record, deps) {
+  const elapsed = formatDuration(record.startedAt, record.endedAt);
+  const note = record.note ? ` (${record.note})` : "";
+  deps.output.write(
+    `[${(/* @__PURE__ */ new Date()).toISOString()}] ${record.runId} status=${record.status} elapsed=${elapsed}${note}
+`
+  );
+}
+async function runAgentStatusCommand(args, deps) {
+  const { target, json, watch, intervalMs } = parseStatusArgs(args);
+  if (!target) {
+    deps.output.write("Usage: nolo agent status <runId|pid> [--json] [--watch] [--interval-ms N]\n");
+    return 1;
+  }
+  const initial = findRunRecord(target, deps);
+  if (!initial) {
+    deps.output.write(`Run not found: ${target}
+`);
+    return 1;
+  }
+  const reconciled = checkStaleRun(initial.runId, deps) ?? initial;
+  if (json) {
+    const record = readRunRecord(reconciled.runId, deps) ?? reconciled;
+    deps.output.write(JSON.stringify(record) + "\n");
+    return 0;
+  }
+  if (!watch) {
+    const record = readRunRecord(reconciled.runId, deps) ?? reconciled;
+    return printStatusOnce(record, deps);
+  }
+  return runStatusWatch(reconciled.runId, intervalMs, deps);
+}
+function formatActivitySummary(activity) {
+  if (!activity) return void 0;
+  const { counters, inFlight, lastEventAt } = activity;
+  const parts = [`${counters.fileEdits} edits, ${counters.toolCalls} tools`];
+  if (inFlight) {
+    const elapsedSec = Math.floor(
+      (Date.now() - new Date(lastEventAt).getTime()) / 1e3
+    );
+    parts.push(`in-flight ${inFlight.kind}${inFlight.name ? ` ${inFlight.name}` : ""} ${elapsedSec}s`);
+  }
+  return `activity: ${parts.join(", ")}`;
+}
+function printStatusOnce(record, deps) {
+  deps.output.write(`runId:    ${record.runId}
+`);
+  deps.output.write(`status:   ${record.status}
+`);
+  deps.output.write(`pid:      ${record.pid ?? "-"}
+`);
+  deps.output.write(`agent:    ${record.agentKey}
+`);
+  deps.output.write(`cwd:      ${record.cwd ?? "-"}
+`);
+  deps.output.write(`started:  ${record.startedAt}
+`);
+  deps.output.write(`elapsed:  ${formatDuration(record.startedAt, record.endedAt)}
+`);
+  if (record.endedAt) deps.output.write(`ended:    ${record.endedAt}
+`);
+  if (typeof record.exitCode === "number") deps.output.write(`exitCode: ${record.exitCode}
+`);
+  if (record.dialogId) deps.output.write(`dialog:   ${record.dialogId}
+`);
+  if (record.note) deps.output.write(`note:     ${record.note}
+`);
+  const activitySummary = formatActivitySummary(record.activity);
+  if (activitySummary) deps.output.write(`${activitySummary}
+`);
+  deps.output.write(`log:      ${record.logPath}
+`);
+  const logLines = readLastLogLines(record.logPath, 20, deps);
+  if (logLines.length > 0) {
+    deps.output.write("\n--- last log lines ---\n");
+    for (const line of logLines) {
+      deps.output.write(`${line}
+`);
+    }
+  }
+  return 0;
+}
+async function runStatusWatch(runId, intervalMs, deps) {
+  const sleep = deps.sleep ?? defaultSleep;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  let stopped = false;
+  const setSignalHandler = deps.setSignalHandler ?? ((handler) => {
+    process.once("SIGINT", handler);
+  });
+  const clearSignalHandler = deps.clearSignalHandler ?? (() => {
+    process.removeAllListeners("SIGINT");
+  });
+  setSignalHandler(() => {
+    stopped = true;
+  });
+  try {
+    let record = readRunRecord(runId, deps);
+    if (!record) {
+      deps.output.write(`Run not found: ${runId}
+`);
+      return 1;
+    }
+    printStatusTick(record, deps);
+    while (!stopped && isRunningStatus(record.status)) {
+      await sleep(intervalMs);
+      if (stopped) break;
+      record = checkStaleRun(runId, deps);
+      if (!record) {
+        deps.output.write(`Run not found: ${runId}
+`);
+        return 1;
+      }
+      printStatusTick(record, deps);
+    }
+    if (stopped) {
+      deps.output.write(`watch stopped by signal
+`);
+    }
+    return 0;
+  } finally {
+    clearSignalHandler();
+  }
+}
+function parseLogsArgs(args, onTail) {
+  let runId = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--tail") {
+      const next = args[i + 1];
+      if (next && /^\d+$/.test(next)) {
+        onTail(Number(next));
+        i += 1;
+      }
+      continue;
+    }
+    if (arg.startsWith("--tail=")) {
+      const value = arg.slice("--tail=".length);
+      if (/^\d+$/.test(value)) onTail(Number(value));
+      continue;
+    }
+    if (!arg.startsWith("-") && !runId) {
+      runId = arg;
+    }
+  }
+  return runId;
+}
+async function runAgentLogsCommand(args, deps) {
+  let tailCount;
+  const runId = parseLogsArgs(args, (count) => {
+    tailCount = count;
+  });
+  if (!runId) {
+    deps.output.write("Usage: nolo agent logs <runId> [--tail N]\n");
+    return 1;
+  }
+  const record = readRunRecord(runId, deps) ?? findRunRecordByPid(Number(runId), deps);
+  if (!record) {
+    deps.output.write(`Run not found: ${runId}
+`);
+    return 1;
+  }
+  const fs = deps.fs ?? nodeFs;
+  if (!fs.existsSync(record.logPath)) {
+    deps.output.write(`Log not found: ${record.logPath}
+`);
+    return 1;
+  }
+  const content = readLogContent(record.logPath, tailCount, deps);
+  deps.output.write(content);
+  return 0;
+}
+async function runSignalCommand(args, signal, verb, deps) {
+  const target = args[0];
+  if (!target) {
+    deps.output.write(`Usage: nolo agent ${verb} <runId|pid>
+`);
+    return 1;
+  }
+  const record = findRunRecord(target, deps);
+  if (!record) {
+    deps.output.write(`Run not found: ${target}
+`);
+    return 1;
+  }
+  if (typeof record.pid !== "number") {
+    deps.output.write(`Run has no pid: ${record.runId}
+`);
+    return 1;
+  }
+  const kill = deps.kill ?? ((pid, sig) => process.kill(pid, sig));
+  try {
+    kill(record.pid, signal);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") {
+      deps.output.write(`Process ${record.pid} already exited.
+`);
+    } else {
+      deps.output.write(`Failed to ${verb} ${record.runId}: ${error}
+`);
+      return 1;
+    }
+  }
+  finalizeRunRecord(record.runId, { status: "killed" }, deps);
+  deps.output.write(`Sent ${signal} to ${record.runId} (pid ${record.pid}).
+`);
+  return 0;
+}
+async function runAgentStopCommand(args, deps) {
+  return runSignalCommand(args, "SIGTERM", "stop", deps);
+}
+async function runAgentKillCommand(args, deps) {
+  return runSignalCommand(args, "SIGKILL", "kill", deps);
+}
+
+export {
+  resolveNoloHome,
+  resolveRunsDir,
+  resolveRunRecordPath,
+  resolveRunLogPath,
+  defaultGenerateRunId,
+  writeRunRecord,
+  createRunActivityTracker,
+  readRunRecord,
+  listRunRecords,
+  findRunRecordByPid,
+  findRunRecord,
+  stripBackgroundFlag,
+  absolutizeSkillArgs,
+  rewriteMsgFileArg,
+  spawnLocalBackgroundRun,
+  finalizeRunRecord,
+  isPidGone,
+  checkStaleRun,
+  runAgentPsCommand,
+  runAgentStatusCommand,
+  runAgentLogsCommand,
+  runAgentStopCommand,
+  runAgentKillCommand
+};