@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-MOAPWO34.js

@@ -0,0 +1,292 @@
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  run_carry_session,
+  run_headless_keys
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/agent/agent-headless.ts
+var KEY = "JOSH_AGENT_HEADLESS";
+var VALUE = "1";
+function environment() {
+  return { [KEY]: VALUE };
+}
+function is_headless(source = process.env) {
+  return source[KEY] === VALUE;
+}
+var agent_headless = { KEY, environment, is_headless };
+
+// scripts/run/detached-launch.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, openSync, writeSync as writeSync2 } from "node:fs";
+
+// scripts/agent/agent-launch-environment.ts
+var OPENAI_PROVIDER = "openai";
+function build(profile, environment2 = {}) {
+  if (profile === void 0) return { ...environment2, [agent_session_role.KEY]: void 0 };
+  const marked = {
+    ...agent_headless.environment(),
+    ...environment2,
+    ...agent_session_role.env_for(profile.role)
+  };
+  return profile.provider === OPENAI_PROVIDER ? { TMPDIR: PLATFORM_TEMP_ROOT, ...marked } : marked;
+}
+var agent_launch_environment = { build };
+
+// scripts/agent/codex-launch-identity.ts
+var CONFIG_FLAG = "-c";
+var SHELL_SET = "shell_environment_policy.set.";
+function identity_environment(request) {
+  return {
+    [lane_paths.LANE_ROOT_KEY]: process.env[lane_paths.LANE_ROOT_KEY],
+    ...request.env
+  };
+}
+function identity_arguments(request) {
+  const source = identity_environment(request);
+  if (!lane_child_marker.is_child_of(request.cwd, source)) return [];
+  return [lane_child_marker.KEY, lane_paths.LANE_ROOT_KEY].flatMap(
+    (key) => source[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(source[key])}`]
+  );
+}
+function is_codex_worker(request) {
+  const { argv, profile } = request;
+  return profile?.provider === "openai" && profile.role === agent_profile_schema.WORKER && argv.command === "codex" && argv.ends_with_prompt === true;
+}
+function scheduler_arguments(request) {
+  if (request.profile?.role !== agent_profile_schema.SCHEDULER) return [];
+  const keys = [run_carry_session.KEY, ...run_headless_keys.MARK_KEYS];
+  return keys.flatMap(
+    (key) => request.env?.[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(request.env[key])}`]
+  );
+}
+function is_codex(request) {
+  return request.profile?.provider === "openai" && request.argv.command === "codex";
+}
+function arguments_for(request) {
+  const { argv } = request;
+  if (!is_codex(request) || argv.ends_with_prompt !== true) return argv.args;
+  const identity = is_codex_worker(request) ? identity_arguments(request) : scheduler_arguments(request);
+  return [...argv.args.slice(0, -1), ...identity, ...argv.args.slice(-1)];
+}
+var codex_launch_identity = { arguments_for };
+
+// scripts/run/launch-priority.ts
+import { setPriority } from "node:os";
+var LANE_NICENESS = 10;
+function lower(pid, set_priority = setPriority) {
+  if (pid === void 0) return;
+  try {
+    set_priority(pid, LANE_NICENESS);
+  } catch {
+  }
+}
+var launch_priority = {
+  LANE_NICENESS,
+  lower
+};
+
+// scripts/run/attached-log.ts
+import { writeSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+var EVENT_SCHEMA = z.looseObject({ type: z.string(), timestamp: z.string().optional() });
+function stamped_line(line, timestamp) {
+  const event = EVENT_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data;
+  if (event === void 0) return line;
+  return JSON.stringify({ ...event, timestamp: event.timestamp ?? timestamp });
+}
+function record(child, log, on_error) {
+  if (child.stdout === null) return;
+  const lines = createInterface({ input: child.stdout });
+  lines.on("line", (line) => {
+    if (log === void 0) return;
+    try {
+      writeSync(log, `${stamped_line(line, (/* @__PURE__ */ new Date()).toISOString())}
+`);
+    } catch (error) {
+      on_error(`the session log could not be written: ${String(error)}`);
+    }
+  });
+}
+var attached_log = { record, stamped_line };
+
+// scripts/run/detached-launch.ts
+var NO_PID_NOTE = "the process started without a pid";
+var UNSAFE_NOTE = "the wake command or its arguments are empty, over length, or contain characters that are not safe to execute";
+var { is_safe_prompt, is_safe_value } = agent_safe_text;
+var LAST = -1;
+function is_safe_element(argv, value, index) {
+  const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST;
+  return is_prompt ? is_safe_prompt(value) : is_safe_value(value);
+}
+function is_safe_argv(argv) {
+  return is_safe_value(argv.command) && argv.args.every((value, index) => is_safe_element(argv, value, index));
+}
+function note_of(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function launched(pid) {
+  return { kind: "launched", pid };
+}
+var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
+var LOG_MODE = 384;
+function profile_suffix(profile) {
+  return profile === void 0 ? "" : ` \xB7 ${agent_profile_schema.describe(profile)}`;
+}
+function log_header(argv, profile) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `
+=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
+`;
+}
+function opened_log(log_path, on_error) {
+  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
+  if (!stamp_file.is_own_regular_file(log_path)) {
+    closeSync(descriptor);
+    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
+    return void 0;
+  }
+  return descriptor;
+}
+function stamped(descriptor, argv, profile, on_error) {
+  if (descriptor === void 0) return;
+  try {
+    writeSync2(descriptor, log_header(argv, profile));
+  } catch (error) {
+    on_error(`the session log could not be written: ${note_of(error)}`);
+  }
+}
+function open_log(log_path, on_error) {
+  if (log_path === void 0) return void 0;
+  try {
+    return opened_log(log_path, on_error);
+  } catch (error) {
+    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
+    return void 0;
+  }
+}
+function ensure_log(log_path, on_error) {
+  const descriptor = open_log(log_path, on_error);
+  if (descriptor !== void 0) closeSync(descriptor);
+}
+function spawn_options(cwd, log, environment2 = {}, is_detached = true) {
+  const output = log ?? "ignore";
+  return {
+    cwd,
+    detached: is_detached,
+    stdio: ["ignore", is_detached ? output : "pipe", output],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
+  };
+}
+function notify_spawn(pid, on_spawn, on_error) {
+  if (pid === void 0) return;
+  try {
+    on_spawn(pid);
+  } catch (error) {
+    on_error(`the child state could not be recorded: ${note_of(error)}`);
+  }
+}
+async function attached_spawn(request, log, on_error, on_spawn) {
+  return await new Promise((resolve) => {
+    const environment2 = agent_launch_environment.build(request.profile, request.env);
+    const child = spawn(
+      request.argv.command,
+      [...request.argv.args],
+      spawn_options(request.cwd, log, environment2, false)
+    );
+    child.once("error", (error) => {
+      on_error(note_of(error));
+      resolve({ kind: "failed", note: note_of(error) });
+    });
+    attached_log.record(child, log, on_error);
+    child.once("close", (exit_code) => {
+      resolve({ kind: "completed", pid: child.pid ?? 0, exit_code });
+    });
+    launch_priority.lower(child.pid);
+    notify_spawn(child.pid, on_spawn, on_error);
+  });
+}
+function ignore_spawn(_pid) {
+}
+function spawned(request, log, on_error) {
+  const { command, args } = request.argv;
+  const environment2 = agent_launch_environment.build(request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment2));
+  child.on("error", (error) => {
+    on_error(note_of(error));
+  });
+  child.unref();
+  launch_priority.lower(child.pid);
+  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
+}
+function prepared_request(request) {
+  return {
+    ...request,
+    argv: { ...request.argv, args: codex_launch_identity.arguments_for(request) }
+  };
+}
+function launch(input, on_error) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return spawned(request, log, on_error);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+async function launch_attached(input, on_error, on_spawn = ignore_spawn) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return await attached_spawn(request, log, on_error, on_spawn);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+var detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
+};
+
+export {
+  agent_headless,
+  detached_launch
+};

package/dist/commands/chunk-MOLXF5KO.js

@@ -0,0 +1,51 @@
+import {
+  reproduction_measure
+} from "./chunk-C2WXQPF3.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  report_format_reference
+} from "./chunk-Q6SKKQVJ.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/review/live-evidence.ts
+var EVIDENCE_HEADING = "## \u5B9F\u6A5F\u8A3C\u8DE1";
+var EVIDENCE_FORMAT = `under ${EVIDENCE_HEADING}, a backticked command followed by a fenced block holding the output it actually printed (prose such as "confirmed" is not accepted) \u2014 format: ${report_format_reference.pointer(report_format_reference.COMPLETION_REPORT_HEADING)}`;
+function verdict_for(paths, body = "") {
+  if (test_declared_logic.runtime_files(paths).length === 0) return "exempt";
+  return reproduction_measure.has_command_output(body, EVIDENCE_HEADING) ? "satisfied" : "required";
+}
+async function assert_checked_out(branch_name) {
+  const current = await git_command.branch();
+  if (current === branch_name) return;
+  throw new Error(
+    `The ${EVIDENCE_HEADING} check reads this checkout's diff, which is ${current}, not ${branch_name}; run followup from ${branch_name}'s checkout.`
+  );
+}
+async function check(branch_name) {
+  await assert_checked_out(branch_name);
+  const [names, body] = await Promise.all([
+    git_command.diff_main_names(),
+    git_gh_command.pr_get_body(branch_name)
+  ]);
+  return verdict_for(names.split("\n"), body);
+}
+function refusal_message() {
+  return [
+    `Merge refused: this pull request changes runtime code but its body has no ${EVIDENCE_HEADING} section.`,
+    "Run the acceptance criteria for real, then add the section:",
+    EVIDENCE_FORMAT,
+    "Update the body with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run."
+  ].join("\n");
+}
+var live_evidence = { EVIDENCE_FORMAT, EVIDENCE_HEADING, check, refusal_message, verdict_for };
+
+export {
+  live_evidence
+};

package/dist/commands/chunk-MQNKIKJ6.js

@@ -0,0 +1,288 @@
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  gh_spawn
+} from "./chunk-JZZURWZH.js";
+import {
+  token_shape
+} from "./chunk-AQ3PMSXK.js";
+import {
+  session_language
+} from "./chunk-OKYFQJW3.js";
+
+// scripts/notify/telegram-notify.ts
+import { z } from "zod";
+
+// scripts/notify/confirmation-options.ts
+var JAPANESE_HEADINGS = {
+  recommended: "\u63A8\u5968:",
+  alternatives: "\u4ED6\u306E\u9078\u629E\u80A2:",
+  none: "\u306A\u3057"
+};
+var ENGLISH_HEADINGS = {
+  recommended: "Recommended:",
+  alternatives: "Alternatives:",
+  none: "none"
+};
+function headings() {
+  const { lang } = session_language.resolve_session_lang();
+  return session_language.is_japanese(lang) ? JAPANESE_HEADINGS : ENGLISH_HEADINGS;
+}
+function alternatives_block(options, labels) {
+  if (options.alternatives.length === 0) return `${labels.alternatives} ${labels.none}`;
+  const lines = options.alternatives.map((alternative) => `- ${alternative}`);
+  return [labels.alternatives, ...lines].join("\n");
+}
+function block(options) {
+  const labels = headings();
+  return `${labels.recommended} ${options.recommended}
+${alternatives_block(options, labels)}`;
+}
+var confirmation_options = { block };
+
+// scripts/notify/notify-opt-in.ts
+var OPT_IN_KEY = "JOSH_NOTIFY_OPT_IN";
+var OPTIONAL_TASK_TYPES = /* @__PURE__ */ new Set(["planning", "completion"]);
+var LIST_SEPARATOR = ",";
+function opted_in_types() {
+  return (process.env[OPT_IN_KEY] ?? "").split(LIST_SEPARATOR).map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+}
+function is_skipped(task_type) {
+  if (!OPTIONAL_TASK_TYPES.has(task_type)) return false;
+  return !opted_in_types().includes(task_type);
+}
+function skip_line(task_type) {
+  return `\u{1F515} ${task_type} notifications are not opted in (${OPT_IN_KEY}).`;
+}
+var notify_opt_in = { is_skipped, skip_line };
+
+// scripts/notify/telegram-notify.ts
+var TELEGRAM_API_BASE = "https://api.telegram.org";
+var TELEGRAM_TEXT_LIMIT = 4096;
+var BODY_TRUNCATION_MARK = "\n...";
+var TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/u;
+var telegram_environment_schema = z.object({
+  telegram_bot_token: z.string().min(1, { message: "TELEGRAM_BOT_TOKEN is required" }),
+  telegram_chat_id: z.string().min(1, { message: "TELEGRAM_CHAT_ID is required" })
+});
+var TASK_DEFINITIONS = {
+  planning: { icon: "\u{1F4CB}", label: "Planning" },
+  completion: { icon: "\u2705", label: "Completion" },
+  failure: { icon: "\u274C", label: "Failure" },
+  warning: { icon: "\u26A0\uFE0F", label: "Completed with a warning" },
+  kickoff_retry: { icon: "\u{1F504}", label: "Kickoff retry" },
+  confirmation: { icon: "\u23F8\uFE0F", label: "Confirmation required" },
+  idle: { icon: "\u{1F4A4}", label: "Backlog run idle \u2014 nothing left to dispatch" },
+  stranded: { icon: "\u{1F6A8}", label: "Run stranded \u2014 nobody is driving it" },
+  progress: { icon: "\u{1F4CA}", label: "Progress" },
+  decision: { icon: "\u{1F916}", label: "Decided by the run \u2014 override with a later decision comment" }
+};
+var NOTIFY_SWITCH_KEY = "JOSH_NOTIFY";
+var NOTIFY_OFF_VALUE = "off";
+var NOT_CONFIGURED_PREFIX = "Telegram is not configured";
+var SEND_FAILED_PREFIX = "Telegram notification failed";
+var REDACTED = "<redacted>";
+var UNKNOWN_ERROR_TEXT = "unknown error";
+function parse_environment_string(value) {
+  return value?.trim() ?? "";
+}
+function join_cause(error) {
+  const { cause } = error;
+  if (!(cause instanceof Error) || cause.message.length === 0) return error.message;
+  return `${error.message}: ${cause.message}`;
+}
+function describe_non_error(error) {
+  return typeof error === "string" ? error : UNKNOWN_ERROR_TEXT;
+}
+function describe_error(error) {
+  if (error instanceof Error) return join_cause(error);
+  return describe_non_error(error);
+}
+function describe_symptom(error) {
+  return error instanceof Error ? error.message : describe_non_error(error);
+}
+function redact_credentials(text, config) {
+  return text.split(config.bot_token).join(REDACTED).split(config.chat_id).join(REDACTED);
+}
+function load_config() {
+  const result = telegram_environment_schema.safeParse({
+    telegram_bot_token: parse_environment_string(process.env["TELEGRAM_BOT_TOKEN"]),
+    telegram_chat_id: parse_environment_string(process.env["TELEGRAM_CHAT_ID"])
+  });
+  if (!result.success) {
+    const error_list = result.error.issues.map((issue) => issue.message).join(", ");
+    throw new Error(`${NOT_CONFIGURED_PREFIX}: ${error_list}`);
+  }
+  return { bot_token: result.data.telegram_bot_token, chat_id: result.data.telegram_chat_id };
+}
+function is_notify_disabled() {
+  return parse_environment_string(process.env[NOTIFY_SWITCH_KEY]).toLowerCase() === NOTIFY_OFF_VALUE;
+}
+function skip_line2(task_type) {
+  if (is_notify_disabled()) {
+    return `\u{1F515} Telegram notifications are disabled (${NOTIFY_SWITCH_KEY}=${NOTIFY_OFF_VALUE}).`;
+  }
+  return notify_opt_in.is_skipped(task_type) ? notify_opt_in.skip_line(task_type) : void 0;
+}
+function build_header(task_type, repo_name) {
+  const { icon, label } = TASK_DEFINITIONS[task_type];
+  if (repo_name === void 0 || repo_name.length === 0) return `${icon} ${label}`;
+  return `${icon} ${repo_name}: ${label}`;
+}
+function push_if_present(target, value) {
+  if (value !== void 0 && value.length > 0) target.push(value);
+}
+function build_title_block(input) {
+  const lines = [build_header(input.task_type, input.repo_name)];
+  push_if_present(lines, input.issue_title);
+  return lines.join("\n");
+}
+function append_url(parts, label, value) {
+  if (value !== void 0 && value.length > 0) parts.push(`${label}: ${value}`);
+}
+function build_url_parts(input) {
+  const parts = [];
+  append_url(parts, "Issue", input.issue_url);
+  append_url(parts, "PR", input.pr_url);
+  return parts;
+}
+function build_blocks(input) {
+  const blocks = [build_title_block(input)];
+  push_if_present(blocks, input.body);
+  push_if_present(blocks, input.choices);
+  blocks.push(...build_url_parts(input));
+  return blocks;
+}
+function join_blocks(input) {
+  return build_blocks(input).join("\n\n");
+}
+function head_of(body, kept) {
+  const head = body.slice(0, kept);
+  return TRAILING_HIGH_SURROGATE.test(head) ? head.slice(0, -1) : head;
+}
+function build_text(input) {
+  const text = join_blocks(input);
+  const overflow = text.length - TELEGRAM_TEXT_LIMIT;
+  if (overflow <= 0 || input.body === void 0) return text;
+  const kept = Math.max(0, input.body.length - overflow - BODY_TRUNCATION_MARK.length);
+  return join_blocks({ ...input, body: `${head_of(input.body, kept)}${BODY_TRUNCATION_MARK}` });
+}
+function outbound_text(input) {
+  token_shape.refuse(join_blocks(input), "The Telegram message");
+  return build_text(input);
+}
+async function post_message(config, text) {
+  const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`;
+  const response = await timed_fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: config.chat_id, text })
+  });
+  if (!response.ok) {
+    throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}`);
+  }
+}
+function build_send_failure(error, config) {
+  const reason = redact_credentials(describe_error(error), config);
+  return new Error(`${SEND_FAILED_PREFIX}: ${reason}`, { cause: new Error(reason) });
+}
+async function send(input) {
+  const skipped = skip_line2(input.task_type);
+  if (skipped !== void 0) {
+    console.info(skipped);
+    return;
+  }
+  const config = load_config();
+  const text = outbound_text(input);
+  try {
+    await post_message(config, text);
+  } catch (error) {
+    throw build_send_failure(error, config);
+  }
+  console.info("\u{1F4F1} Telegram notification sent.");
+}
+function report_send_failure(error, recovery) {
+  console.error("");
+  console.error(`\u2757 ${describe_symptom(error)}`);
+  console.error("   Nobody was notified, and the run carried on.");
+  if (recovery !== void 0) console.error(`   Recovery: ${recovery}`);
+  console.error("");
+}
+async function send_or_report(input, recovery) {
+  try {
+    await send(input);
+    return true;
+  } catch (error) {
+    report_send_failure(error, recovery);
+    return false;
+  }
+}
+var REPO_LOOKUP_TIMEOUT_MS = 5e3;
+async function warn(input) {
+  return await send_or_report(
+    {
+      task_type: "warning",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function confirm(input) {
+  return await send_or_report(
+    {
+      task_type: "confirmation",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      choices: confirmation_options.block(input),
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function headline(task_type, input) {
+  return await send_or_report(
+    {
+      task_type,
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function idle(input) {
+  return await headline("idle", input);
+}
+async function stranded(input) {
+  return await headline("stranded", input);
+}
+async function progress(body) {
+  return await headline("progress", { body, recovery: "pnpm josh run:board --chat" });
+}
+async function decided(input) {
+  return await headline("decision", input);
+}
+var telegram_notify = {
+  confirm,
+  decided,
+  idle,
+  progress,
+  send,
+  send_or_report,
+  stranded,
+  warn
+};
+
+export {
+  confirmation_options,
+  telegram_notify
+};