@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-KXZR7UAE.js

@@ -0,0 +1,302 @@
+import {
+  lane_handoff,
+  lane_process_table
+} from "./chunk-5QICRFVL.js";
+import {
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN
+} from "./chunk-L7GYJHDX.js";
+import {
+  lane_environment
+} from "./chunk-CVRDJCOE.js";
+import {
+  git_worktree
+} from "./chunk-2AH73ZTW.js";
+import {
+  lane_child_invocation
+} from "./chunk-VFW6XZH7.js";
+import {
+  repo_discovery
+} from "./chunk-MDKDJF2K.js";
+import {
+  ENV_FILE_NAME
+} from "./chunk-IGD6QJPH.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/lane/lane-registry.ts
+import { chmodSync, existsSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// scripts/lane/lane-listening-ports.ts
+import { readFile } from "node:fs/promises";
+import { execa } from "execa";
+var PORT_FIELD = /^n.*:(?<port>\d+)$/gmu;
+var NO_MATCH = 1;
+var HEX_RADIX = 16;
+var LISTEN_STATE = "0A";
+var TCP_TABLE = "/proc/net/tcp";
+var TCP6_TABLE = "/proc/net/tcp6";
+var TABLE_FIELDS = 4;
+var ADDRESS_FIELDS = 2;
+async function read_text(file) {
+  return await readFile(file, "utf8");
+}
+function linux_port(line) {
+  const [, local, , state] = line.trim().split(/\s+/u, TABLE_FIELDS);
+  if (state !== LISTEN_STATE || local === void 0) return [];
+  const port = Number.parseInt(local.split(":", ADDRESS_FIELDS)[1] ?? "", HEX_RADIX);
+  return Number.isSafeInteger(port) ? [port] : [];
+}
+async function ipv6_text(read) {
+  try {
+    return await read(TCP6_TABLE);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function linux_ports(read) {
+  const tables = await Promise.all([read(TCP_TABLE), ipv6_text(read)]);
+  return new Set(tables.flatMap((table) => table.split("\n").flatMap((line) => linux_port(line))));
+}
+async function darwin_ports() {
+  const result = await execa("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-Fn"], {
+    reject: false,
+    timeout: PROBE_TIMEOUT_MS
+  });
+  if (result.exitCode !== 0 && result.exitCode !== NO_MATCH) return void 0;
+  if (result.stderr.trim() !== "") return void 0;
+  return new Set(
+    [...result.stdout.matchAll(PORT_FIELD)].map((match) => Number(match.groups?.["port"]))
+  );
+}
+async function read_for(platform, read) {
+  if (platform === "linux") return await linux_ports(read);
+  return platform === "darwin" ? await darwin_ports() : void 0;
+}
+async function read_ports(platform = process.platform, read = read_text) {
+  try {
+    return await read_for(platform, read);
+  } catch {
+    return void 0;
+  }
+}
+var lane_listening_ports = { read_ports };
+
+// scripts/lane/lane-snapshot-trace.ts
+function is_matched(probes, issue) {
+  return probes.matching(lane_child_invocation.process_pattern(issue)).length > 0;
+}
+async function traces_of(issues, rows) {
+  if (rows === void 0) return () => PROCESS_UNKNOWN;
+  const probes = lane_process_table.probes_of(rows);
+  const unmatched = issues.filter((issue) => !is_matched(probes, issue));
+  const is_shipping = unmatched.length === 0 ? () => false : await lane_handoff.ship_reader(lane_process_table.start_reader(rows));
+  const idle = new Set(unmatched.filter((issue) => !is_shipping(issue)));
+  return (issue) => idle.has(issue) ? PROCESS_NONE : PROCESS_ALIVE;
+}
+function never_merge_waiting() {
+  return false;
+}
+async function merge_waits_of(issues, rows) {
+  if (rows === void 0) return never_merge_waiting;
+  const probes = lane_process_table.probes_of(rows);
+  const shipping = issues.filter(
+    (issue) => probes.matching(lane_child_invocation.ship_pattern(issue)).length > 0
+  );
+  if (shipping.length === 0) return never_merge_waiting;
+  return await lane_handoff.merge_wait_reader(lane_process_table.start_reader(rows));
+}
+async function count_merge_waiting(issues, table = lane_process_table.read_table) {
+  const is_waiting = await merge_waits_of(issues, await table());
+  return issues.filter((issue) => is_waiting(issue)).length;
+}
+var lane_snapshot_trace = { count_merge_waiting, merge_waits_of, traces_of };
+
+// scripts/lane/lane-seat-ownership.ts
+var UNREADABLE = "Cannot read lane process ownership or listening ports (process or socket probe failed).";
+async function snapshot(issues = []) {
+  const [ports, rows] = await Promise.all([
+    lane_listening_ports.read_ports(),
+    lane_process_table.read_table()
+  ]);
+  if (ports === void 0 || rows === void 0) return void 0;
+  const trace = await lane_snapshot_trace.traces_of(issues, rows);
+  return { running: new Set(issues.filter((issue) => trace(issue) === PROCESS_ALIVE)), ports };
+}
+function ports_held(lane, ports) {
+  return [lane.development_port, lane.preview_port].some(
+    (port) => port !== void 0 && ports.has(port)
+  );
+}
+function ownership(lane, reading) {
+  if (lane.is_stranded) return { ...lane, seat_held: false };
+  if (reading === void 0) return { ...lane, seat_held: true, seat_problem: UNREADABLE };
+  const is_running = reading.running.has(lane.issue);
+  return {
+    ...lane,
+    seat_owned: is_running,
+    seat_held: is_running || ports_held(lane, reading.ports)
+  };
+}
+function measure(lanes, reading) {
+  return lanes.map((lane) => ownership(lane, reading));
+}
+var lane_seat_ownership = { measure, ports_held, snapshot, UNREADABLE };
+
+// scripts/lane/lane-registry.ts
+var OWNER_ONLY_MODE = 384;
+var WORKTREE_PREFIX = "worktree ";
+var BRANCH_PREFIX = "branch refs/heads/";
+var BLOCK_SEPARATOR = "\n\n";
+function line_value(lines, prefix) {
+  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
+}
+function seat_from_content(content) {
+  const seat = lane_environment.read_lane_seat(content);
+  if (seat === void 0) return void 0;
+  const port_pair = lane_environment.read_lane_ports(content);
+  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
+}
+var EMPTY_SEAT = {
+  seat: void 0,
+  development_port: void 0,
+  preview_port: void 0
+};
+function held_seat(content) {
+  if (content === void 0) return EMPTY_SEAT;
+  return seat_from_content(content) ?? EMPTY_SEAT;
+}
+function read_environment(directory) {
+  return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME));
+}
+function write_environment(directory, content) {
+  const file = path.join(directory, ENV_FILE_NAME);
+  writeFileSync(file, content, { mode: OWNER_ONLY_MODE });
+  chmodSync(file, OWNER_ONLY_MODE);
+}
+function dispatched_at(directory) {
+  return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs;
+}
+function branch_issue(branch) {
+  if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
+  const issue = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? issue : void 0;
+}
+function is_gone(directory) {
+  return !existsSync(directory);
+}
+function build_lane(issue, branch, directory, is_stranded) {
+  const content = is_stranded ? void 0 : read_environment(directory);
+  const held = held_seat(content);
+  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
+  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
+  return {
+    issue,
+    branch,
+    directory,
+    seat: held.seat,
+    development_port: held.development_port,
+    preview_port: held.preview_port,
+    output,
+    profile,
+    dispatched_ms: is_stranded ? void 0 : dispatched_at(directory),
+    is_stranded
+  };
+}
+function is_lane_directory(root, issue, directory) {
+  return directory === lane_paths.lane_directory(root, issue);
+}
+function parse_block(block, root) {
+  const lines = block.split("\n");
+  const directory = line_value(lines, WORKTREE_PREFIX);
+  const branch = line_value(lines, BRANCH_PREFIX);
+  const issue = branch_issue(branch);
+  if (directory === void 0 || branch === void 0 || issue === void 0 || !is_lane_directory(root, issue, directory)) {
+    return void 0;
+  }
+  return build_lane(issue, branch, directory, is_gone(directory));
+}
+function is_lane(lane) {
+  return lane !== void 0;
+}
+async function worktree_blocks() {
+  const listing = await git_worktree.worktree_list();
+  return listing.split(BLOCK_SEPARATOR);
+}
+async function main_repository_root() {
+  return repo_discovery.main_worktree(await git_command.repository_root());
+}
+async function lane_root_directory() {
+  return lane_paths.lane_root(await main_repository_root());
+}
+async function lane_location(issue) {
+  return { issue, directory: lane_paths.lane_directory(await lane_root_directory(), issue) };
+}
+async function list_lanes(main_root) {
+  const root = lane_paths.lane_root(main_root ?? await main_repository_root());
+  const blocks = await worktree_blocks();
+  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
+  const reading = await lane_seat_ownership.snapshot(lanes.map((lane) => lane.issue));
+  const measured = lane_seat_ownership.measure(lanes, reading);
+  return measured.toSorted((left, right) => Number(left.issue) - Number(right.issue));
+}
+async function registered_directories() {
+  const blocks = await worktree_blocks();
+  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
+}
+async function has_lanes_in_flight() {
+  const lanes = await list_lanes();
+  return lanes.some((lane) => !lane.is_stranded);
+}
+function used_seats(lanes) {
+  return [
+    ...new Set(lanes.filter((lane) => lane.seat_held !== false).flatMap((lane) => lane.seat ?? []))
+  ];
+}
+function unreadable_lanes(lanes) {
+  return lanes.filter(
+    (lane) => !lane.is_stranded && (lane.seat === void 0 || lane.seat_problem !== void 0)
+  );
+}
+function find_lane(lanes, issue) {
+  return lanes.find((lane) => lane.issue === issue);
+}
+async function find_open_lane(issue) {
+  return find_lane(await list_lanes(), issue);
+}
+var lane_registry = {
+  find_lane,
+  find_open_lane,
+  has_lanes_in_flight,
+  lane_location,
+  lane_root_directory,
+  list_lanes,
+  main_repository_root,
+  parse_block,
+  read_environment,
+  registered_directories,
+  unreadable_lanes,
+  used_seats,
+  write_environment,
+  OWNER_ONLY_MODE
+};
+
+export {
+  lane_snapshot_trace,
+  lane_seat_ownership,
+  lane_registry
+};

package/dist/commands/chunk-L7GYJHDX.js

@@ -0,0 +1,223 @@
+import {
+  agent_event
+} from "./chunk-LULJUD6P.js";
+import {
+  issue_state
+} from "./chunk-HXM26K3O.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/run-liveness.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+var ALIVE_VERDICT = "alive";
+var PAUSED_VERDICT = "paused";
+var SETTLED_VERDICT = "settled";
+var STOPPED_VERDICT = "stopped";
+var UNDETERMINED_VERDICT = "undetermined";
+var PROCESS_ALIVE = "alive";
+var PROCESS_NONE = "none";
+var PROCESS_UNKNOWN = "unknown";
+var DEFAULT_SILENT_MINUTES = 30;
+var DEFAULT_GAP_SECONDS = 5;
+var OPEN_STATE = "OPEN";
+var STATE_FIELDS = "state,labels";
+var REASONS = {
+  [ALIVE_VERDICT]: "The unit is still working: its output moved, or a process of the child is alive.",
+  [PAUSED_VERDICT]: "The lane state record says the lane is paused: its child is suspended, not working, and nothing moves until someone resumes it.",
+  [SETTLED_VERDICT]: "The child is closed, parked with `needs-decision` or `run:stalled`, or marked `already-done`, so there is nothing here to recover.",
+  [STOPPED_VERDICT]: "The output has been frozen past the silent window and no process of the child is alive in that checkout.",
+  [UNDETERMINED_VERDICT]: "A trace could not be read, so this says nothing about the unit. A trace that could not be read answers `undetermined`, never `stopped`."
+};
+var ALIVE_ADVICE = "Keep waiting on `pnpm josh lane:await`; do not touch the child.";
+var PAUSED_ADVICE = "Do not wait on it and do not recover it: tell the person the lane is paused; `pnpm josh lane:resume <N>` resumes it once they ask.";
+var SETTLED_ADVICE = "Read the child with `pnpm josh issue:state <N>` and take the branch its state says.";
+var STOPPED_CLEAN_ADVICE = "The unit ended \u2014 classify how before booking it. Run `pnpm josh run:merge <N> --output <path>` (add `--epic <E> --repo <owner/repo>` for a named epic): it reads the child's exit record without waiting for the unit to return, re-dispatches a child that could not reach the API (counting the outage; a run of them trips the environment guard, which holds launches), and parks an abandoned child with `run:stalled` against the consecutive-failure guard. The checkout is clean, so there is nothing to stash.";
+var STOPPED_DIRTY_ADVICE = "Classify how the unit ended with `pnpm josh run:merge <N> --output <path> --stash` (add `--epic <E> --repo <owner/repo>` for a named epic): `--stash` first stashes the half-finished work and records its `stash:pop` line on the Issue, then it re-dispatches an API-outage child (counting the outage; a run of them trips the environment guard, which holds launches) and parks an abandoned child with `run:stalled` against the consecutive-failure guard, without waiting for the unit to return.";
+var UNDETERMINED_ADVICE = "Read the trace that failed and ask again. Where the process trace was given as `unknown`, leave `--process` out so the command reads it. Two of these in a row is a fault in the check itself rather than a slow unit: stop polling and report it.";
+function is_output_moving(traces) {
+  return traces.is_output_frozen === false;
+}
+function is_agent_state_finished(state) {
+  return state?.result === "completed" || state?.result === "failed";
+}
+function is_agent_finished(traces) {
+  return is_agent_state_finished(traces.agent_state);
+}
+function recorded_verdict(state) {
+  if (state === "paused") return PAUSED_VERDICT;
+  return state === "ended" ? SETTLED_VERDICT : void 0;
+}
+function definitive_verdict(traces) {
+  if (traces.is_child_settled === true) return SETTLED_VERDICT;
+  const recorded = recorded_verdict(traces.lane_state);
+  if (recorded !== void 0) return recorded;
+  if (is_agent_finished(traces)) return STOPPED_VERDICT;
+  if (is_output_moving(traces)) return ALIVE_VERDICT;
+  return void 0;
+}
+function is_check_running(traces) {
+  return traces.process_trace === PROCESS_ALIVE;
+}
+function has_unreadable_trace(traces) {
+  return traces.is_child_settled === void 0 || traces.is_output_frozen === void 0 || traces.process_trace === PROCESS_UNKNOWN;
+}
+function to_verdict(traces) {
+  const definitive = definitive_verdict(traces);
+  if (definitive !== void 0) return definitive;
+  if (has_unreadable_trace(traces)) return UNDETERMINED_VERDICT;
+  return is_check_running(traces) ? ALIVE_VERDICT : STOPPED_VERDICT;
+}
+var ADVICE = {
+  [ALIVE_VERDICT]: ALIVE_ADVICE,
+  [PAUSED_VERDICT]: PAUSED_ADVICE,
+  [SETTLED_VERDICT]: SETTLED_ADVICE,
+  [UNDETERMINED_VERDICT]: UNDETERMINED_ADVICE
+};
+function to_advice(verdict, has_work_to_stash) {
+  if (verdict !== STOPPED_VERDICT) return ADVICE[verdict];
+  return has_work_to_stash ? STOPPED_DIRTY_ADVICE : STOPPED_CLEAN_ADVICE;
+}
+function decide(traces) {
+  const verdict = to_verdict(traces);
+  const has_work_to_stash = verdict === STOPPED_VERDICT && traces.is_tree_dirty;
+  return {
+    advice: to_advice(verdict, has_work_to_stash),
+    has_work_to_stash,
+    reason: traces.agent_state?.reason ?? REASONS[verdict],
+    verdict
+  };
+}
+function to_resolved_root(root) {
+  try {
+    return realpathSync(root);
+  } catch {
+    return root;
+  }
+}
+var ALLOWED_ROOTS = [
+  ...new Set(
+    [homedir(), tmpdir(), PLATFORM_TEMP_ROOT].flatMap((root) => [root, to_resolved_root(root)])
+  )
+];
+function is_within(candidate, root) {
+  const relative = path.relative(root, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function to_safe_path(output_path) {
+  const normalized = path.normalize(output_path);
+  if (!path.isAbsolute(normalized)) return void 0;
+  return ALLOWED_ROOTS.some((root) => is_within(normalized, root)) ? normalized : void 0;
+}
+function sample_output(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  const stats = statSync(safe_path, { throwIfNoEntry: false });
+  if (!stats?.isFile()) return void 0;
+  return { mtime_ms: stats.mtimeMs, size: stats.size };
+}
+function read_agent_state(output_path) {
+  const safe_path = to_safe_path(output_path);
+  if (safe_path === void 0) return void 0;
+  try {
+    const state = agent_event.read(readFileSync(safe_path, "utf8"));
+    return state.provider === void 0 ? void 0 : state;
+  } catch {
+    return void 0;
+  }
+}
+function describe_agent_state(output_path) {
+  const state = read_agent_state(output_path);
+  return state === void 0 ? void 0 : `agent: ${state.provider ?? "unknown"} ${agent_event.describe(state)}`;
+}
+async function read_output_frozen(request) {
+  const first = sample_output(request.output_path);
+  if (first === void 0) return void 0;
+  if (request.now_ms - first.mtime_ms < request.silent_window_ms) return false;
+  await sleep(request.gap_ms);
+  const second = sample_output(request.output_path);
+  if (second === void 0) return void 0;
+  return second.mtime_ms === first.mtime_ms && second.size === first.size;
+}
+function carries_settled_label(labels) {
+  return has_parked_label(labels);
+}
+async function read_child_settled(issue, repo) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELDS, repo);
+  if (json === void 0) return void 0;
+  const state = issue_state.parse_issue_state(json);
+  if (state === void 0) return void 0;
+  return state.state !== OPEN_STATE || carries_settled_label(state.labels);
+}
+function freshness_of(request) {
+  return {
+    gap_ms: request.gap_ms ?? DEFAULT_GAP_SECONDS * MS_PER_SECOND,
+    now_ms: Date.now(),
+    output_path: request.output_path,
+    silent_window_ms: request.silent_window_ms ?? DEFAULT_SILENT_MINUTES * MS_PER_MINUTE
+  };
+}
+async function read_traces(request) {
+  const [is_initial_child_settled, is_output_frozen, is_tree_dirty, record] = await Promise.all([
+    read_child_settled(request.issue, request.repo),
+    read_output_frozen(freshness_of(request)),
+    run_hold.is_tree_dirty(),
+    lane_state.read_state(request.issue)
+  ]);
+  const agent_state = read_agent_state(request.output_path);
+  const is_latest_child_settled = is_agent_state_finished(agent_state) ? await read_child_settled(request.issue, request.repo) : void 0;
+  const is_child_settled = is_latest_child_settled ?? is_initial_child_settled;
+  return {
+    agent_state,
+    is_child_settled,
+    is_output_frozen,
+    is_tree_dirty,
+    lane_state: record?.state,
+    process_trace: request.process_trace
+  };
+}
+async function check(request) {
+  issue_number_shape.require_issue_number(request.issue);
+  return decide(await read_traces(request));
+}
+var run_liveness = {
+  check,
+  decide,
+  describe_agent_state,
+  read_agent_state,
+  read_child_settled,
+  read_output_frozen,
+  sample_output,
+  to_safe_path
+};
+
+export {
+  UNDETERMINED_VERDICT,
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
+  DEFAULT_SILENT_MINUTES,
+  run_liveness
+};

package/dist/commands/chunk-LAQZJX5C.js

@@ -0,0 +1,49 @@
+import {
+  core_budget
+} from "./chunk-TWI7UTVE.js";
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  PACKAGE_JSON,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  INSTALL_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-install.ts
+import { existsSync } from "node:fs";
+var INSTALL_ARGUMENTS = ["install", "--frozen-lockfile"];
+var NO_MANIFEST_OUTPUT = `No ${PACKAGE_JSON} in the lane, so the dependency install was skipped.`;
+function has_manifest(directory) {
+  return existsSync(package_manifest.manifest_path(directory));
+}
+async function install_dependencies(directory) {
+  if (!has_manifest(directory)) return { is_installed: true, output: NO_MANIFEST_OUTPUT };
+  const admitted = await run_startup.waiting("install resource wait");
+  const result = await core_budget.with_command_reservation(
+    core_budget.CORE_WEIGHTS.install,
+    async () => {
+      await admitted();
+      return await run_startup.phase(
+        "dependency install",
+        async () => await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
+          cwd: directory,
+          timeout_ms: INSTALL_TIMEOUT_MS
+        }),
+        { edge_of: (value) => buffered_process.is_process_failed(value) ? "failed" : "done" }
+      );
+    },
+    { memory_mb: core_budget.MEMORY_MB.install, command: "lane install" }
+  );
+  return { is_installed: !buffered_process.is_process_failed(result), output: result.output };
+}
+var lane_install = { install_dependencies };
+
+export {
+  lane_install
+};