@kynver-app/runtime 0.1.2 → 0.1.4

package/dist/index.js

@@ -236,12 +236,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path13 = input.diskPath?.trim() || "/";
+  const path14 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path13);
+  const stats = statfsSync(path14);
   const freeBytes = Number(stats.bavail) * Number(stats.bsize);
   const totalBytes = Number(stats.blocks) * Number(stats.bsize);
   const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
@@ -261,7 +261,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path13,
+    path: path14,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -372,7 +372,8 @@ function parseClaudeStream(file) {
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
-    const ts = event.timestamp || event.ts;
+    const tsMs = event.timestamp_ms;
+    const ts = event.timestamp || event.ts || (tsMs ? new Date(tsMs).toISOString() : void 0);
     if (ts) {
       result.firstEventAt ||= ts;
       result.lastEventAt = ts;
@@ -631,8 +632,8 @@ function observeRunnerResourceGate(input) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3 } from "node:fs";
+import path7 from "node:path";
 
 // src/prompt.ts
 function buildPrompt(input) {
@@ -692,11 +693,44 @@ var claudeProvider = {
 };
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, openSync as openSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync6, openSync as openSync2, readdirSync as readdirSync2 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
+import path6 from "node:path";
 var DEFAULT_CURSOR_MODEL = "composer-2.5";
+function latestVersionDir(versionsRoot) {
+  if (!existsSync6(versionsRoot)) return null;
+  const versions = readdirSync2(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}\.\d/.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
+  return versions[0] ? path6.join(versionsRoot, versions[0]) : null;
+}
+function resolveBundledCursor(versionDir) {
+  const nodeExe = path6.join(versionDir, "node.exe");
+  const indexJs = path6.join(versionDir, "index.js");
+  if (!existsSync6(nodeExe) || !existsSync6(indexJs)) return null;
+  return { executable: nodeExe, prefixArgs: [indexJs], shell: false, detached: true };
+}
+function resolveWindowsCursorSpawn(agentBin) {
+  const agentRoot = path6.dirname(agentBin);
+  const direct = resolveBundledCursor(agentRoot);
+  if (direct) return direct;
+  const versionDir = latestVersionDir(path6.join(agentRoot, "versions"));
+  return versionDir ? resolveBundledCursor(versionDir) : null;
+}
+function resolveCursorSpawn(agentBin) {
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(agentBin)) {
+    const bundled = resolveWindowsCursorSpawn(agentBin);
+    if (bundled) return bundled;
+    return { executable: agentBin, prefixArgs: [], shell: true, detached: false };
+  }
+  return { executable: agentBin, prefixArgs: [], shell: false, detached: true };
+}
 function resolveAgentBin() {
-  return process.env.KYNVER_CURSOR_AGENT_BIN?.trim() || process.env.CURSOR_AGENT_BIN?.trim() || "agent";
+  const configured = process.env.KYNVER_CURSOR_AGENT_BIN?.trim() || process.env.CURSOR_AGENT_BIN?.trim();
+  if (configured) return configured;
+  if (process.platform === "win32") {
+    const localAgent = path6.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
+    if (existsSync6(localAgent)) return localAgent;
+  }
+  return "agent";
 }
 var cursorProvider = {
   name: "cursor",
@@ -705,9 +739,11 @@ var cursorProvider = {
     const stdoutFd = openSync2(opts.stdoutPath, "a");
     const stderrFd = openSync2(opts.stderrPath, "a");
     const agentBin = resolveAgentBin();
+    const spawnTarget = resolveCursorSpawn(agentBin);
     const child = spawn2(
-      agentBin,
+      spawnTarget.executable,
       [
+        ...spawnTarget.prefixArgs,
         "-p",
         "--force",
         "--trust",
@@ -722,9 +758,13 @@ var cursorProvider = {
       ],
       {
         cwd: opts.worktreePath,
-        detached: true,
+        detached: spawnTarget.detached,
+        shell: spawnTarget.shell,
         stdio: ["ignore", stdoutFd, stderrFd],
-        env: process.env
+        env: {
+          ...process.env,
+          ...spawnTarget.prefixArgs.length > 0 ? { CURSOR_INVOKED_AS: path6.basename(agentBin) } : {}
+        }
       }
     );
     closeSync2(stdoutFd);
@@ -762,16 +802,16 @@ function spawnWorkerProcess(run, opts) {
   if (run.workers?.[name]) throw new Error(`worker already exists in run ${run.id}: ${name}`);
   if (!opts.task) throw new Error(`missing task text for worker ${name}`);
   const { worktreesDir } = getPaths();
-  const workerDir = path6.join(runDirectory(run.id), "workers", name);
+  const workerDir = path7.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path6.join(worktreesDir, run.id, name);
+  const worktreePath = path7.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync6(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync7(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
   git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
-  const stdoutPath = path6.join(workerDir, "stdout.jsonl");
-  const stderrPath = path6.join(workerDir, "stderr.log");
-  const heartbeatPath = path6.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path7.join(workerDir, "stdout.jsonl");
+  const stderrPath = path7.join(workerDir, "stderr.log");
+  const heartbeatPath = path7.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
@@ -820,7 +860,7 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path6.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path7.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   return worker;
@@ -1025,7 +1065,7 @@ function redactHarness(text, secret) {
 }
 
 // src/validate.ts
-import path7 from "node:path";
+import path8 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 var WORKER_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
 function validateRunId(runId) {
@@ -1039,15 +1079,15 @@ function validateWorkerName(name) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path7.resolve(repo);
+  const resolved = path8.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
 function validateOwnedPaths(repoRoot, ownedPaths) {
   return ownedPaths.map((owned) => {
-    const resolved = path7.resolve(repoRoot, owned);
-    const rel = path7.relative(repoRoot, resolved);
-    if (rel.startsWith("..") || path7.isAbsolute(rel)) {
+    const resolved = path8.resolve(repoRoot, owned);
+    const rel = path8.relative(repoRoot, resolved);
+    if (rel.startsWith("..") || path8.isAbsolute(rel)) {
       throw new Error(`owned path escapes repo: ${owned}`);
     }
     return resolved;
@@ -1059,14 +1099,14 @@ function validateTailLines(lines) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
+import path9 from "node:path";
 function createRun(args) {
   const repo = validateRepo(required(String(args.repo || ""), "--repo"));
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync7(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync8(dir)) failExists(`run already exists: ${id}`);
   mkdirSync4(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -1080,12 +1120,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path8.join(dir, "run.json"), run);
+  writeJson(path9.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
   const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path8.join(runDirectory(id), "run.json"), null)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path9.join(runDirectory(id), "run.json"), null)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -1100,7 +1140,7 @@ function failExists(message) {
 }
 
 // src/sweep.ts
-import path9 from "node:path";
+import path10 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -1112,7 +1152,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path9.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         null
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -1155,7 +1195,7 @@ async function sweepRun(args) {
 }
 
 // src/worker-ops.ts
-import path10 from "node:path";
+import path11 from "node:path";
 async function tryCompleteWorker(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const status = computeWorkerStatus(worker);
@@ -1248,7 +1288,7 @@ async function completeWorker(args) {
 function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const status = computeWorkerStatus(worker);
-  writeJson(path10.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path11.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function runStatus(args) {
@@ -1256,7 +1296,7 @@ function runStatus(args) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       null
     );
     if (!worker) {
@@ -1288,7 +1328,7 @@ function runStatus(args) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path10.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path11.join(runDirectory(run.id), "last-board.json"), board);
   console.log(JSON.stringify(board, null, 2));
 }
 function tailWorker(args) {
@@ -1322,11 +1362,11 @@ function stopWorker(args) {
 
 // src/cli.ts
 import { mkdirSync as mkdirSync5 } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/pipeline-tick.ts
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/workspace-runtime-config.ts
 async function fetchWorkspaceRuntimePreferences(agentOsId, args) {
@@ -1355,7 +1395,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path12.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       null
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -1473,6 +1513,101 @@ async function runDaemon(args) {
   console.error(JSON.stringify({ event: "daemon_stop", runId, agentOsId }));
 }
 
+// src/plan-progress.ts
+function parseEvidenceArg(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0) throw new Error(`invalid --evidence ${raw} (expected type:value)`);
+  return { type: raw.slice(0, idx), value: raw.slice(idx + 1) };
+}
+async function emitPlanProgress(args) {
+  const planId = required(args, "plan");
+  const agentOsId = (args.agentOsId ? String(args.agentOsId) : loadUserConfig().agentOsId) || "";
+  if (!agentOsId) {
+    console.error("requires --agent-os-id or agentOsId in ~/.kynver/config.json");
+    process.exit(1);
+  }
+  const roleLane = required(args, "role");
+  const status = required(args, "status");
+  const evidence = [];
+  const rawEvidence = args.evidence;
+  if (Array.isArray(rawEvidence)) {
+    for (const item of rawEvidence) evidence.push(parseEvidenceArg(String(item)));
+  } else if (typeof rawEvidence === "string") {
+    evidence.push(parseEvidenceArg(rawEvidence));
+  }
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const secret = resolveCallbackSecret(args.secret ? String(args.secret) : void 0);
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/plans/${encodeURIComponent(planId)}/progress-events`;
+  const body = {
+    rowKey: args.row ? String(args.row) : void 0,
+    rowId: args.rowId ? String(args.rowId) : void 0,
+    taskId: args.task ? String(args.task) : void 0,
+    reviewTaskId: args.reviewTask ? String(args.reviewTask) : void 0,
+    roleLane,
+    status,
+    note: args.note ? String(args.note) : void 0,
+    remainingWork: args.remaining ? String(args.remaining) : void 0,
+    evidence: evidence.length ? evidence : void 0,
+    proposed: args.proposed === true || args.proposed === "true",
+    executorRef: args.executorRef ? String(args.executorRef) : void 0
+  };
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-OpenClaw-Cron-Secret": secret,
+      "X-Kynver-Runtime-Secret": secret
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  if (!res.ok) {
+    console.error(JSON.stringify({ httpStatus: res.status, response: parsed }, null, 2));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(parsed, null, 2));
+}
+async function verifyPlan(args) {
+  const planId = required(args, "plan");
+  const slug = loadUserConfig().agentOsSlug;
+  if (!slug) {
+    console.error("requires agentOsSlug in ~/.kynver/config.json for verify (session route)");
+    process.exit(1);
+  }
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
+  const apiKey = process.env.KYNVER_API_KEY;
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const url = `${base}/api/agent-os/${encodeURIComponent(slug)}/plans/${encodeURIComponent(planId)}/verify`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      worktreePath: args.worktree ? String(args.worktree) : void 0,
+      taskId: args.task ? String(args.task) : void 0,
+      humanOverride: args.humanOverride === true || args.humanOverride === "true"
+    })
+  });
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  if (!res.ok) {
+    console.error(JSON.stringify({ httpStatus: res.status, response: parsed }, null, 2));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(parsed, null, 2));
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -1499,7 +1634,9 @@ function usage(code = 0) {
       "  kynver worker status --run RUN_ID --name worker",
       "  kynver worker tail --run RUN_ID --name worker [--lines 40] [--raw]",
       "  kynver worker stop --run RUN_ID --name worker",
-      "  kynver worker complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--task-id TASK_ID] [--base-url URL] [--secret SECRET]"
+      "  kynver worker complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--task-id TASK_ID] [--base-url URL] [--secret SECRET]",
+      "  kynver plan progress --plan PLAN_ID --row ROW_KEY --role ROLE --status STATUS [--task TASK_ID] [--note NOTE] [--evidence type:value] [--agent-os-id AOS_ID]",
+      "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override]"
     ].join("\n")
   );
   process.exit(code);
@@ -1509,7 +1646,7 @@ async function main(argv = process.argv.slice(2)) {
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker") {
+  if (scope === "run" || scope === "worker" || scope === "plan") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -1522,6 +1659,8 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "login") return void await runLogin(args);
   if (scope === "setup") return void await runSetup(args);
   if (scope === "daemon") return void await runDaemon(args);
+  if (scope === "plan" && action === "progress") return void await emitPlanProgress(args);
+  if (scope === "plan" && action === "verify") return void await verifyPlan(args);
   if (scope === "run" && action === "create") return createRun(args);
   if (scope === "run" && action === "list") return listRuns();
   if (scope === "run" && action === "status") return runStatus(args);
@@ -1534,7 +1673,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "worker" && action === "complete") return void await completeWorker(args);
   unknownCommand(scope, action);
 }
-var isCliEntry = process.argv[1] && path12.resolve(process.argv[1]) === path12.resolve(fileURLToPath(import.meta.url));
+var isCliEntry = process.argv[1] && path13.resolve(process.argv[1]) === path13.resolve(fileURLToPath(import.meta.url));
 if (isCliEntry) {
   void main().catch((error) => {
     console.error(error);