wildcrane-runner 0.0.0-stage → 0.3.0

package/dist/akb/package.json

@@ -0,0 +1 @@
+{"name":"wildcrane","version":"0.11.2","type":"module","private":true}

package/dist/launcher.mjs

@@ -0,0 +1,360 @@
+// wildcrane-runner 0.3.0 — built by runner/scripts/build.mjs. Do not edit.
+import { createRequire as __ai4kanbanRequire } from 'node:module'
+const require = __ai4kanbanRequire(import.meta.url)
+
+// src/launcher-main.ts
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/home.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function runnerHome() {
+  return process.env.WILDCRANE_HOME || path.join(os.homedir(), ".wildcrane");
+}
+function useRunnerHome() {
+  process.env.AI4KANBAN_HOME = runnerHome();
+}
+function machineId() {
+  const file = path.join(runnerHome(), "machine.json");
+  try {
+    const held = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (held.id && /^[0-9a-f-]{36}$/i.test(held.id)) return held.id;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  fs.mkdirSync(runnerHome(), { recursive: true, mode: 448 });
+  fs.writeFileSync(file, `${JSON.stringify({ id })}
+`);
+  return id;
+}
+
+// src/launcher.ts
+import { spawn } from "node:child_process";
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// ../cli/src/lib/cloud/config.ts
+var SUPABASE_URL = "https://yajrbpprmdvtkvjjfpbk.supabase.co";
+var SUPABASE_ANON_KEY = "sb_publishable_ioUQ23BTtoj8NKqndp0Jrw_omVR3m4n";
+var API_URL = "https://api.ai4kanban.dev";
+var URL_SCHEME = "ai4kanban";
+var SIGN_IN_REDIRECT = `${URL_SCHEME}://cloud/signed-in`;
+var trimSlash = (url) => url.replace(/\/+$/, "");
+function cloudEndpoints() {
+  return {
+    supabaseUrl: trimSlash(process.env.AI4KANBAN_SUPABASE_URL || SUPABASE_URL),
+    anonKey: process.env.AI4KANBAN_SUPABASE_ANON_KEY || SUPABASE_ANON_KEY,
+    api: trimSlash(process.env.AI4KANBAN_CLOUD_URL || API_URL)
+  };
+}
+
+// src/i18n.ts
+var ZH = {
+  signIn: (url) => `\u8BF7\u5728\u6D4F\u89C8\u5668\u4E2D\u767B\u5F55 WildCrane\uFF1A
+${url}`,
+  signedIn: () => "\u5DF2\u767B\u5F55",
+  signInFailed: (why) => `\u767B\u5F55\u672A\u5B8C\u6210\uFF1A${why}`,
+  connected: (machine) => `\u5DF2\u8FDE\u63A5\uFF08${machine}\uFF09\uFF0C\u7B49\u5F85\u4EFB\u52A1`,
+  running: (count) => `\u6B63\u5728\u8FD0\u884C ${count} \u4E2A\u4EFB\u52A1`,
+  reconnecting: () => "\u5DF2\u65AD\u5F00\uFF0C\u6B63\u5728\u91CD\u8FDE\u2026",
+  elsewhere: (machine) => `\u4F60\u7684 Runner \u5DF2\u5728\u300C${machine}\u300D\u4E0A\u8FDE\u63A5\u3002\u8BF7\u5148\u5728\u90A3\u53F0\u7535\u8111\u4E0A\u9000\u51FA\uFF0C\u518D\u5728\u8FD9\u91CC\u542F\u52A8\u3002`,
+  outdated: () => "\u6B64\u7248\u672C\u5DF2\u8FC7\u65E7\uFF0C\u8BF7\u91CD\u542F\u4EE5\u66F4\u65B0\u3002",
+  refused: (why) => `WildCrane \u62D2\u7EDD\u4E86\u8FDE\u63A5\uFF1A${why}`,
+  updated: (version) => `\u5DF2\u66F4\u65B0\u5230 ${version}`,
+  rolledBack: (version) => `\u65B0\u7248\u672C\u672A\u80FD\u542F\u52A8\uFF0C\u5DF2\u9000\u56DE ${version}`,
+  nodeTooOld: (range) => `\u65B0\u7248\u672C\u9700\u8981 Node ${range}\uFF0C\u8BF7\u5347\u7EA7 Node\u3002\u672C\u6B21\u7EE7\u7EED\u4F7F\u7528\u5F53\u524D\u7248\u672C\u3002`,
+  stopped: () => "\u5DF2\u505C\u6B62",
+  reviewTitle: () => "\u5F85\u4F60\u5BA1\u6838",
+  reviewBody: (task, checkpoint) => `\u300C${task}\u300D\u7684${checkpoint}\u5DF2\u5C31\u7EEA`,
+  doneTitle: () => "\u4EFB\u52A1\u5DF2\u5B8C\u6210",
+  failedTitle: () => "\u4EFB\u52A1\u5931\u8D25",
+  commentTitle: (task) => `\u300C${task}\u300D\u6709\u65B0\u8BC4\u8BBA`,
+  commentBody: (who, text) => `${who}\uFF1A${text}`
+};
+var EN = {
+  signIn: (url) => `Sign in to WildCrane in your browser:
+${url}`,
+  signedIn: () => "Signed in",
+  signInFailed: (why) => `Sign-in did not finish: ${why}`,
+  connected: (machine) => `Connected (${machine}) \u2014 waiting for tasks`,
+  running: (count) => `Running ${count} ${count === 1 ? "task" : "tasks"}`,
+  reconnecting: () => "Disconnected \u2014 reconnecting\u2026",
+  elsewhere: (machine) => `Your Runner is already connected on "${machine}". Quit it there first, then start it here.`,
+  outdated: () => "This version is out of date. Restart to update.",
+  refused: (why) => `WildCrane refused the connection: ${why}`,
+  updated: (version) => `Updated to ${version}`,
+  rolledBack: (version) => `The new version did not start \u2014 back on ${version}`,
+  nodeTooOld: (range) => `The new version needs Node ${range}. Update Node; running the current version for now.`,
+  stopped: () => "Stopped",
+  reviewTitle: () => "Needs your review",
+  reviewBody: (task, checkpoint) => `${checkpoint} for "${task}" is ready`,
+  doneTitle: () => "Task finished",
+  failedTitle: () => "Task failed",
+  commentTitle: (task) => `New comment on ${task}`,
+  commentBody: (who, text) => `${who}: ${text}`
+};
+function isChinese(env = process.env) {
+  const lang = env.LC_ALL || env.LC_MESSAGES || env.LANG || Intl.DateTimeFormat().resolvedOptions().locale;
+  return /^zh/i.test(lang ?? "");
+}
+var linesFor = (chinese) => chinese ? ZH : EN;
+var t = linesFor(isChinese());
+var last = "";
+function status(line) {
+  if (line === last) return;
+  last = line;
+  process.stdout.write(`${line}
+`);
+}
+
+// src/protocol.ts
+var VERSION = true ? "0.3.0" : "0.0.0";
+var EXIT_REFUSED = 10;
+var EXIT_OUTDATED = 11;
+
+// src/update.ts
+import crypto2 from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+import zlib from "node:zlib";
+var PACKAGE = "wildcrane-runner";
+var TIMEOUT_MS = 6e4;
+var versionsDir = () => path2.join(runnerHome(), "runner");
+var versionDir = (version) => path2.join(versionsDir(), version);
+var entryOf = (dir) => path2.join(dir, "dist", "runner.mjs");
+var registry = () => (process.env.npm_config_registry || "https://registry.npmjs.org").replace(/\/+$/, "");
+async function install(version, nodeVersion = process.versions.node) {
+  const dir = versionDir(version);
+  if (fs2.existsSync(entryOf(dir))) return { ok: true, dir };
+  let meta;
+  let tarball;
+  try {
+    const answer = await fetch(`${registry()}/${PACKAGE}/${encodeURIComponent(version)}`, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!answer.ok) return { ok: false, why: "unreachable", detail: `registry answered ${answer.status}` };
+    meta = await answer.json();
+    const range = meta.engines?.node;
+    if (range && !satisfies(nodeVersion, range)) return { ok: false, why: "node", detail: range };
+    if (!meta.dist?.tarball) return { ok: false, why: "unreachable", detail: "no tarball" };
+    const download = await fetch(meta.dist.tarball, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (!download.ok) return { ok: false, why: "unreachable", detail: `download answered ${download.status}` };
+    tarball = Buffer.from(await download.arrayBuffer());
+  } catch (e) {
+    return { ok: false, why: "unreachable", detail: e instanceof Error ? e.message : String(e) };
+  }
+  const expected = /^sha512-(.+)$/.exec(meta.dist.integrity ?? "")?.[1];
+  const actual = crypto2.createHash("sha512").update(tarball).digest("base64");
+  if (!expected || expected !== actual) return { ok: false, why: "integrity", detail: "sha512 mismatch" };
+  const staging = `${dir}.${process.pid}.tmp`;
+  try {
+    fs2.rmSync(staging, { recursive: true, force: true });
+    extract(zlib.gunzipSync(tarball), staging);
+    if (!fs2.existsSync(entryOf(staging))) throw new Error("the package carries no dist/runner.mjs");
+    fs2.rmSync(dir, { recursive: true, force: true });
+    fs2.renameSync(staging, dir);
+  } catch (e) {
+    fs2.rmSync(staging, { recursive: true, force: true });
+    return { ok: false, why: "integrity", detail: e instanceof Error ? e.message : String(e) };
+  }
+  return { ok: true, dir };
+}
+function extract(tar, into) {
+  let offset = 0;
+  let longName = null;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((b) => b === 0)) break;
+    const field = (start, length) => header.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
+    const size = parseInt(field(124, 12).trim() || "0", 8);
+    const type = field(156, 1) || "0";
+    const body = tar.subarray(offset + 512, offset + 512 + size);
+    offset += 512 + Math.ceil(size / 512) * 512;
+    if (type === "x") {
+      longName = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(body.toString("utf8"))?.[1] ?? null;
+      continue;
+    }
+    if (type === "L") {
+      longName = body.toString("utf8").replace(/\0.*$/s, "");
+      continue;
+    }
+    const prefix = field(345, 155);
+    const name = longName ?? (prefix ? `${prefix}/${field(0, 100)}` : field(0, 100));
+    longName = null;
+    if (type !== "0" && type !== "5") continue;
+    const relative = name.replace(/^[^/]+\//, "");
+    if (!relative) continue;
+    const target = path2.resolve(into, relative);
+    if (!target.startsWith(path2.resolve(into) + path2.sep)) throw new Error(`refusing ${name}`);
+    if (type === "5") fs2.mkdirSync(target, { recursive: true });
+    else {
+      fs2.mkdirSync(path2.dirname(target), { recursive: true });
+      fs2.writeFileSync(target, body);
+    }
+  }
+}
+var parse = (v) => {
+  const m = /^v?(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?/.exec(v.trim());
+  return m ? [Number(m[1]), Number(m[2]) || 0, Number(m[3]) || 0] : null;
+};
+function compare(a, b) {
+  const [x, y] = [parse(a) ?? [0, 0, 0], parse(b) ?? [0, 0, 0]];
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] - y[i];
+  return 0;
+}
+function satisfies(version, range) {
+  return range.split("||").some((alternative) => {
+    const parts = alternative.trim().split(/\s+/).filter(Boolean);
+    return parts.length > 0 && parts.every((part) => meets(version, part));
+  });
+}
+function meets(version, comparator) {
+  const m = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(comparator);
+  const bound = m && parse(m[2]);
+  if (!m || !bound) return false;
+  const v = parse(version);
+  const c = compare(version, m[2]);
+  switch (m[1]) {
+    case ">=":
+      return c >= 0;
+    case ">":
+      return c > 0;
+    case "<=":
+      return c <= 0;
+    case "<":
+      return c < 0;
+    case "^":
+      return c >= 0 && v[0] === bound[0];
+    case "~":
+      return c >= 0 && v[0] === bound[0] && v[1] === bound[1];
+    default: {
+      const given = m[2].split(".").filter((p) => /^\d+$/.test(p)).length;
+      return [0, 1, 2].slice(0, given).every((i) => v[i] === bound[i]);
+    }
+  }
+}
+
+// src/launcher.ts
+var ASK_MS = 5e3;
+var CONNECT_MS = 2 * 6e4;
+var KEEP = 2;
+var stateFile = () => path3.join(versionsDir(), "state.json");
+function readState() {
+  try {
+    const held = JSON.parse(fs3.readFileSync(stateFile(), "utf8"));
+    return { good: held.good ?? [], bad: held.bad ?? [] };
+  } catch {
+    return { good: [], bad: [] };
+  }
+}
+function writeState(state) {
+  fs3.mkdirSync(versionsDir(), { recursive: true });
+  fs3.writeFileSync(stateFile(), `${JSON.stringify(state, null, 2)}
+`);
+}
+function markGood(version) {
+  const state = readState();
+  state.good = [version, ...state.good.filter((v) => v !== version)].slice(0, KEEP);
+  writeState(state);
+  for (const name of fs3.readdirSync(versionsDir())) {
+    if (name === "state.json" || state.good.includes(name) || name.endsWith(".tmp")) continue;
+    fs3.rmSync(path3.join(versionsDir(), name), { recursive: true, force: true });
+  }
+}
+function markBad(version) {
+  const state = readState();
+  state.bad = [.../* @__PURE__ */ new Set([...state.bad, version])];
+  state.good = state.good.filter((v) => v !== version);
+  writeState(state);
+}
+async function askTarget(machine) {
+  try {
+    const answer = await fetch(`${cloudEndpoints().api}/v1/runner/version?machine=${machine}`, {
+      signal: AbortSignal.timeout(ASK_MS)
+    });
+    if (!answer.ok) return null;
+    const { version } = await answer.json();
+    return typeof version === "string" && version ? version : null;
+  } catch {
+    return null;
+  }
+}
+async function candidates(own) {
+  const state = readState();
+  const proven = state.good.find((v) => fs3.existsSync(entryOf(versionDir(v))));
+  const current = proven && compare(proven, own.version) > 0 ? { version: proven, entry: entryOf(versionDir(proven)) } : own;
+  const target = await askTarget(machineId());
+  if (!target || target === current.version || state.bad.includes(target)) return [current];
+  if (process.env.WILDCRANE_DESKTOP && compare(target, own.version) < 0) return [current];
+  if (target === own.version) return [own, current];
+  const got = await install(target);
+  if (got.ok) {
+    const known = state.good.includes(target);
+    return [{ version: target, entry: entryOf(got.dir), fresh: !known }, current];
+  }
+  if (got.why === "node") status(t.nodeTooOld(got.detail));
+  return [current];
+}
+function runOnce(candidate) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [candidate.entry], {
+      stdio: ["inherit", "inherit", "inherit", "ipc"],
+      env: { ...process.env, WILDCRANE_RUNNER_VERSION: candidate.version }
+    });
+    let connected = false;
+    let timer = null;
+    let timedOut = false;
+    let stopping = false;
+    const forward = (signal) => () => {
+      stopping = true;
+      child.kill(signal);
+    };
+    const onInt = forward("SIGINT");
+    const onTerm = forward("SIGTERM");
+    process.on("SIGINT", onInt);
+    process.on("SIGTERM", onTerm);
+    child.on("message", (message) => {
+      if (message.type === "started" && candidate.fresh && !connected) {
+        timer = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, Number(process.env.WILDCRANE_CONNECT_MS) || CONNECT_MS);
+      }
+      if (message.type === "connected" && !connected) {
+        connected = true;
+        if (timer) clearTimeout(timer);
+        if (candidate.fresh) {
+          markGood(candidate.version);
+          status(t.updated(candidate.version));
+        }
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (timer) clearTimeout(timer);
+      process.off("SIGINT", onInt);
+      process.off("SIGTERM", onTerm);
+      if (connected || !candidate.fresh || stopping) return resolve({ exit: code ?? (signal ? 1 : 0) });
+      if (timedOut) return resolve({ failed: "timeout" });
+      if (code === 0 || code === EXIT_REFUSED || code === EXIT_OUTDATED) return resolve({ exit: code });
+      resolve({ failed: "crashed" });
+    });
+  });
+}
+async function launch(own) {
+  const list = await candidates(own);
+  for (let i = 0; i < list.length; i++) {
+    const candidate = list[i];
+    const outcome = await runOnce(candidate);
+    if ("exit" in outcome) return outcome.exit;
+    if (outcome.failed === "crashed") markBad(candidate.version);
+    const next = list[i + 1];
+    if (next) status(t.rolledBack(next.version));
+  }
+  return 1;
+}
+
+// src/launcher-main.ts
+useRunnerHome();
+var entry = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "runner.mjs");
+launch({ version: VERSION, entry }).then((code) => process.exit(code));