@ricsam/r5dctl 0.0.1 → 0.0.2

package/dist/cjs/cli.cjs

@@ -0,0 +1,1246 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_exports = {};
+__export(cli_exports, {
+  getCliHelpText: () => getCliHelpText,
+  main: () => main,
+  parseAnswerFlags: () => parseAnswerFlags,
+  parseEnvFlags: () => parseEnvFlags,
+  parseGlobalArgs: () => parseGlobalArgs,
+  parsePromptArgs: () => parsePromptArgs,
+  resolveCommandExecution: () => resolveCommandExecution,
+  runBinctlCli: () => runBinctlCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_child_process = require("node:child_process");
+var import_promises = require("node:timers/promises");
+var import_r5d_api = require("@ricsam/r5d-api");
+const CHAT_MODES = /* @__PURE__ */ new Set(["ask", "plan", "build", "agent", "explore", "review", "test", "research"]);
+const MODEL_TIERS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
+const CLI_GLOBAL_OPTION_HELP = [
+  "--base-url <url>",
+  "--json",
+  "--config <path>",
+  "--token <token>",
+  "--api-key <key>",
+  "-p, --project <slug|id>",
+  "-b, --branch <branch>",
+  "-s, --session <sessionId>",
+  "-h, --help"
+];
+const CLI_ONLY_HELP_ENTRIES = [
+  {
+    section: "auth",
+    usage: "auth login [--no-open]",
+    description: "Start the browser login flow."
+  }
+];
+const CLI_ONLY_COMMAND_HELP = [
+  {
+    path: ["auth", "login"],
+    usage: "auth login [--no-open]"
+  }
+];
+const SHARED_HELP_ENTRIES = [
+  { section: "auth", usage: "auth status", description: "Show the current authenticated user and credential source." },
+  { section: "auth", usage: "auth logout", description: "Revoke the current credential and clear saved auth." },
+  { section: "auth", usage: "auth api-key create --name <name> [--save]", description: "Create an API key for automation or local scripts." },
+  { section: "auth", usage: "auth api-key list", description: "List API keys for the current account." },
+  { section: "auth", usage: "auth api-key revoke <key-id>", description: "Revoke an API key." },
+  { section: "projects", usage: "get projects", description: "List projects you can access." },
+  { section: "projects", usage: "create project [--name <name>] [--org <org-id>]", description: "Create a new project." },
+  { section: "projects", usage: "describe project <project-ref>", description: "Show details for a project." },
+  { section: "projects", usage: "update project <project-ref> [--name <name>] [--mode <greenfield|prod>]", description: "Update project settings." },
+  { section: "projects", usage: "delete project <project-ref>", description: "Delete a project." },
+  { section: "branches", usage: "-p <project> get branches", description: "List branches for a project." },
+  { section: "branches", usage: "-p <project> describe branch <branch>", description: "Show branch URLs and sessions." },
+  { section: "sessions", usage: "-p <project> get sessions [--branch <branch>]", description: "List sessions for a project, optionally filtered by branch." },
+  { section: "sessions", usage: "-p <project> create session -b <branch> [--name <name>]", description: "Create a session for a project branch." },
+  { section: "sessions", usage: "describe session <session-id>", description: "Show session details." },
+  { section: "sessions", usage: "-s <session-id> update session --name <name>", description: "Rename a session or clear its name." },
+  { section: "sessions", usage: "-s <session-id> delete session", description: "Delete a session." },
+  { section: "sessions", usage: "-s <session-id> conversation [--full] [--compact] [--tail <nodes>]", description: "Read a conversation transcript, pending questions, and required envs." },
+  { section: "sessions", usage: '-s <session-id> prompt --mode <mode> --model <tier> "<message>"', description: "Send a prompt to a session." },
+  { section: "sessions", usage: '-s <session-id> answer-questions -a1 "<answer>" -a2 "<answer>" ...', description: "Answer pending questions in order." },
+  { section: "sessions", usage: "-s <session-id> apply-required-envs -e backend/KEY=value -e frontend/KEY=value", description: "Apply required backend or frontend env values." }
+];
+const HELP_SECTION_ORDER = ["auth", "projects", "branches", "sessions"];
+const HELP_SECTION_TITLES = {
+  auth: "Auth",
+  projects: "Projects",
+  branches: "Branches",
+  sessions: "Sessions"
+};
+function getCliHelpText() {
+  const entries = [...CLI_ONLY_HELP_ENTRIES, ...SHARED_HELP_ENTRIES];
+  const usageWidth = Math.max(...entries.map((entry) => `r5dctl ${entry.usage}`.length), 0);
+  const lines = [
+    "Usage: r5dctl [global-options] <command>",
+    "Run `r5dctl <command> --help` for details on a specific command.",
+    "",
+    "Global options:",
+    ...CLI_GLOBAL_OPTION_HELP.map((option) => `  ${option}`)
+  ];
+  for (const section of HELP_SECTION_ORDER) {
+    const sectionEntries = entries.filter((entry) => entry.section === section);
+    if (sectionEntries.length === 0) {
+      continue;
+    }
+    lines.push("");
+    lines.push(`${HELP_SECTION_TITLES[section]}:`);
+    lines.push(
+      ...sectionEntries.map((entry) => {
+        const usage = `r5dctl ${entry.usage}`;
+        return `  ${usage.padEnd(usageWidth + 2, " ")}${entry.description}`;
+      })
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function printHelp() {
+  process.stdout.write(getCliHelpText());
+}
+function isHelpFlag(arg) {
+  return arg === "--help" || arg === "-h";
+}
+function findCliOnlyCommandHelp(pathSegments) {
+  return CLI_ONLY_COMMAND_HELP.find(
+    (entry) => entry.path.length <= pathSegments.length && entry.path.every((segment, index) => segment === pathSegments[index])
+  );
+}
+function renderCliOnlyCommandHelp(entry) {
+  return `Usage:
+  r5dctl ${entry.usage}
+`;
+}
+function renderSharedCommandHelp(pathSegments) {
+  const entry = SHARED_HELP_ENTRIES.find((candidate) => {
+    const usageSegments = candidate.usage.split(" ").filter((segment) => !segment.startsWith("-") && !segment.startsWith("<") && !segment.startsWith("["));
+    return usageSegments.length <= pathSegments.length && usageSegments.every((segment, index) => segment === pathSegments[index]);
+  });
+  if (!entry) {
+    return void 0;
+  }
+  return `Usage:
+  r5dctl ${entry.usage}
+
+${entry.description}
+`;
+}
+function defaultConfigPath() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".config", "r5d", "r5dctl", "config.json");
+}
+function requireValue(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+}
+function parseLongOptionWithEquals(arg, optionName) {
+  const prefix = `${optionName}=`;
+  if (!arg.startsWith(prefix)) {
+    return void 0;
+  }
+  return arg.slice(prefix.length);
+}
+function parseOptionalFlagValue(args, flag, shortFlag) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) {
+      continue;
+    }
+    if (arg === flag || shortFlag && arg === shortFlag) {
+      return args[i + 1];
+    }
+    const equalsValue = parseLongOptionWithEquals(arg, flag);
+    if (equalsValue !== void 0) {
+      return equalsValue;
+    }
+  }
+  return void 0;
+}
+function hasBooleanFlag(args, flag) {
+  return args.includes(flag);
+}
+function parseGlobalArgs(argv) {
+  const options = {
+    json: false,
+    configPath: defaultConfigPath(),
+    help: false
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--") {
+      rest.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      if (rest.length === 0) {
+        options.help = true;
+      } else {
+        rest.push(arg);
+      }
+      continue;
+    }
+    if (arg === "--base-url") {
+      options.baseUrl = requireValue(argv[i + 1], "Missing value for --base-url");
+      i += 1;
+      continue;
+    }
+    const baseUrl = parseLongOptionWithEquals(arg, "--base-url");
+    if (baseUrl !== void 0) {
+      options.baseUrl = baseUrl;
+      continue;
+    }
+    if (arg === "--config") {
+      options.configPath = requireValue(argv[i + 1], "Missing value for --config");
+      i += 1;
+      continue;
+    }
+    const configPath = parseLongOptionWithEquals(arg, "--config");
+    if (configPath !== void 0) {
+      options.configPath = configPath;
+      continue;
+    }
+    if (arg === "--token") {
+      options.token = requireValue(argv[i + 1], "Missing value for --token");
+      i += 1;
+      continue;
+    }
+    const token = parseLongOptionWithEquals(arg, "--token");
+    if (token !== void 0) {
+      options.token = token;
+      continue;
+    }
+    if (arg === "--api-key") {
+      options.apiKey = requireValue(argv[i + 1], "Missing value for --api-key");
+      i += 1;
+      continue;
+    }
+    const apiKey = parseLongOptionWithEquals(arg, "--api-key");
+    if (apiKey !== void 0) {
+      options.apiKey = apiKey;
+      continue;
+    }
+    if (arg === "--project" || arg === "-p") {
+      options.project = requireValue(argv[i + 1], "Missing value for --project");
+      i += 1;
+      continue;
+    }
+    if (arg === "--branch" || arg === "-b") {
+      options.branch = requireValue(argv[i + 1], "Missing value for --branch");
+      i += 1;
+      continue;
+    }
+    if (arg === "--session" || arg === "-s") {
+      options.session = requireValue(argv[i + 1], "Missing value for --session");
+      i += 1;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { options, rest };
+}
+function parseConfig(configPath) {
+  if (!import_node_fs.default.existsSync(configPath)) {
+    return {};
+  }
+  const raw = import_node_fs.default.readFileSync(configPath, "utf-8");
+  if (raw.trim().length === 0) {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config file format at ${configPath}`);
+  }
+  const value = parsed;
+  return {
+    baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : void 0,
+    token: typeof value.token === "string" ? value.token : void 0,
+    apiKey: typeof value.apiKey === "string" ? value.apiKey : void 0
+  };
+}
+function compactConfig(config) {
+  const output = {};
+  if (config.baseUrl) {
+    output.baseUrl = config.baseUrl;
+  }
+  if (config.token) {
+    output.token = config.token;
+  }
+  if (config.apiKey) {
+    output.apiKey = config.apiKey;
+  }
+  return output;
+}
+function writeConfig(configPath, config) {
+  const dir = import_node_path.default.dirname(configPath);
+  import_node_fs.default.mkdirSync(dir, { recursive: true, mode: 448 });
+  const compacted = compactConfig(config);
+  import_node_fs.default.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+`, {
+    mode: 384
+  });
+  import_node_fs.default.chmodSync(configPath, 384);
+}
+function resolveClientOptions(options, config) {
+  return {
+    baseUrl: options.baseUrl ?? process.env.R5D_BASE_URL ?? process.env.BINCTL_BASE_URL ?? config.baseUrl,
+    token: options.token ?? process.env.R5D_TOKEN ?? process.env.BINCTL_TOKEN ?? config.token,
+    apiKey: options.apiKey ?? process.env.R5D_API_KEY ?? process.env.BINCTL_API_KEY ?? config.apiKey
+  };
+}
+function parseAnswerFlags(args) {
+  const answers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) {
+      continue;
+    }
+    const inlineMatch = arg.match(/^-a(\d+)=(.*)$/);
+    if (inlineMatch) {
+      const position2 = Number(inlineMatch[1]);
+      const value2 = inlineMatch[2] ?? "";
+      answers.set(position2, value2);
+      continue;
+    }
+    const match = arg.match(/^-a(\d+)$/);
+    if (!match) {
+      if (arg.startsWith("-")) {
+        throw new Error(`Unknown answer flag: ${arg}`);
+      }
+      throw new Error(`Unexpected value '${arg}'. Use positional flags like -a1, -a2, ...`);
+    }
+    const position = Number(match[1]);
+    const value = args[i + 1];
+    if (value === void 0) {
+      throw new Error(`Missing value for ${arg}`);
+    }
+    answers.set(position, value);
+    i += 1;
+  }
+  if (answers.size === 0) {
+    throw new Error("Provide answers using positional flags like -a1, -a2, ...");
+  }
+  const ordered = Array.from(answers.entries()).sort(([left], [right]) => left - right);
+  for (let index = 0; index < ordered.length; index += 1) {
+    const expectedPosition = index + 1;
+    if (ordered[index]?.[0] !== expectedPosition) {
+      throw new Error("Answers must start at -a1 and be contiguous (-a1, -a2, ...)");
+    }
+  }
+  return ordered.map(([, value]) => value);
+}
+function validateEnvAssignment(value) {
+  const equalsIndex = value.indexOf("=");
+  if (equalsIndex <= 0) {
+    throw new Error(`Invalid env assignment '${value}'. Expected backend/KEY=value or frontend/KEY=value`);
+  }
+  const assignment = value.slice(0, equalsIndex);
+  const slashIndex = assignment.indexOf("/");
+  if (slashIndex <= 0) {
+    throw new Error(`Invalid env assignment '${value}'. Expected backend/KEY=value or frontend/KEY=value`);
+  }
+  const target = assignment.slice(0, slashIndex);
+  const key = assignment.slice(slashIndex + 1);
+  if (target !== "backend" && target !== "frontend" || key.length === 0) {
+    throw new Error(`Invalid env assignment '${value}'. Expected backend/KEY=value or frontend/KEY=value`);
+  }
+}
+function parseEnvFlags(args) {
+  const envs = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "-e" || arg === "--env") {
+      const value = args[i + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      validateEnvAssignment(value);
+      envs.push(value);
+      i += 1;
+      continue;
+    }
+    const inline = parseLongOptionWithEquals(arg, "--env");
+    if (inline !== void 0) {
+      validateEnvAssignment(inline);
+      envs.push(inline);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown env flag: ${arg}`);
+    }
+    throw new Error(`Unexpected value '${arg}'. Use -e backend/KEY=value.`);
+  }
+  if (envs.length === 0) {
+    throw new Error("At least one -e/--env value is required.");
+  }
+  return envs;
+}
+function parsePromptArgs(args) {
+  let modeRaw;
+  let modelRaw;
+  const messageParts = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--") {
+      messageParts.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--mode") {
+      modeRaw = requireValue(args[i + 1], "Missing value for --mode");
+      i += 1;
+      continue;
+    }
+    const inlineMode = parseLongOptionWithEquals(arg, "--mode");
+    if (inlineMode !== void 0) {
+      modeRaw = inlineMode;
+      continue;
+    }
+    if (arg === "--model") {
+      modelRaw = requireValue(args[i + 1], "Missing value for --model");
+      i += 1;
+      continue;
+    }
+    const inlineModel = parseLongOptionWithEquals(arg, "--model");
+    if (inlineModel !== void 0) {
+      modelRaw = inlineModel;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown prompt flag: ${arg}`);
+    }
+    messageParts.push(arg);
+  }
+  if (!modeRaw) {
+    throw new Error("--mode is required for `prompt`");
+  }
+  if (!CHAT_MODES.has(modeRaw)) {
+    throw new Error(`Invalid --mode '${modeRaw}'. Expected one of: ask, plan, build, agent, explore, review, test, research`);
+  }
+  if (!modelRaw) {
+    throw new Error("--model is required for `prompt`");
+  }
+  if (!MODEL_TIERS.has(modelRaw)) {
+    throw new Error("Invalid --model. Expected one of: low, medium, high, max");
+  }
+  const message = messageParts.join(" ").trim();
+  if (message.length === 0) {
+    throw new Error("Prompt message is required");
+  }
+  return {
+    mode: modeRaw,
+    model: modelRaw,
+    message
+  };
+}
+async function openInBrowser(url) {
+  if (process.platform === "darwin") {
+    (0, import_node_child_process.spawn)("open", [url], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  if (process.platform === "win32") {
+    (0, import_node_child_process.spawn)("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  (0, import_node_child_process.spawn)("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+}
+function writeDataOutput(json, data, humanText) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(humanText);
+}
+function createSavedApiKeyConfig(options, config, apiKey) {
+  return {
+    baseUrl: options.baseUrl ?? config.baseUrl,
+    apiKey,
+    token: void 0
+  };
+}
+async function handleAuthLogin(client, options, commandArgs, config) {
+  const noOpen = hasBooleanFlag(commandArgs, "--no-open");
+  const start = await client.auth.loginStart({
+    baseUrl: options.baseUrl ?? config.baseUrl
+  });
+  if (options.json) {
+    writeDataOutput(true, {
+      status: "pending",
+      requestId: start.requestId,
+      loginUrl: start.loginUrl,
+      expiresAt: start.expiresAt,
+      intervalMs: start.intervalMs
+    }, "");
+  } else {
+    process.stdout.write(`Open this URL to approve login:
+${start.loginUrl}
+`);
+  }
+  if (!noOpen) {
+    try {
+      await openInBrowser(start.loginUrl);
+    } catch {
+    }
+  }
+  const expiresAtMs = new Date(start.expiresAt).getTime();
+  let intervalMs = start.intervalMs;
+  while (Date.now() < expiresAtMs) {
+    await (0, import_promises.setTimeout)(intervalMs);
+    const polled = await client.auth.loginPoll(start.requestId, { pollCode: start.pollCode });
+    if (polled.status === "pending") {
+      intervalMs = polled.intervalMs;
+      continue;
+    }
+    if (polled.status === "approved") {
+      const nextConfig = {
+        ...config,
+        baseUrl: options.baseUrl ?? config.baseUrl,
+        token: polled.token,
+        apiKey: void 0
+      };
+      writeConfig(options.configPath, nextConfig);
+      writeDataOutput(
+        options.json,
+        {
+          status: "approved",
+          credentialId: polled.credentialId,
+          savedConfigPath: options.configPath
+        },
+        "Login successful. Token saved to config.\n"
+      );
+      return;
+    }
+    if (polled.status === "expired") {
+      throw new Error("Login request expired. Run `r5dctl auth login` again.");
+    }
+    if (polled.status === "consumed") {
+      throw new Error("Login request was already consumed.");
+    }
+  }
+  throw new Error("Login request timed out.");
+}
+async function handleAuthApiKeyCreate(client, options, config, commandArgs) {
+  const name = parseOptionalFlagValue(commandArgs, "--name", "-n");
+  if (!name) {
+    throw new Error("Missing --name for API key creation");
+  }
+  const created = await client.auth.apiKeys.create({ name });
+  if (hasBooleanFlag(commandArgs, "--save")) {
+    writeConfig(options.configPath, createSavedApiKeyConfig(options, config, created.apiKey));
+  }
+  if (options.json) {
+    const payload = hasBooleanFlag(commandArgs, "--save") ? { ...created, saved: true, savedConfigPath: options.configPath } : created;
+    writeDataOutput(true, payload, "");
+    return;
+  }
+  const saveMessage = hasBooleanFlag(commandArgs, "--save") ? `Saved API key to ${options.configPath}
+` : "";
+  process.stdout.write(`API key created: ${created.id}
+${created.apiKey}
+${saveMessage}`);
+}
+function clearAuthFromConfig(config, options) {
+  return {
+    baseUrl: options.baseUrl ?? config.baseUrl,
+    token: void 0,
+    apiKey: void 0
+  };
+}
+function renderProjectDescription(project) {
+  return [`Project: ${project.name ?? project.id}`, `Ref: ${project.slug ?? project.id}`, `Mode: ${project.mode}`].join("\n") + "\n";
+}
+function renderProjectList(projects) {
+  if (projects.length === 0) {
+    return "No projects found.\n";
+  }
+  return `${projects.map((project) => `${project.name ?? "(unnamed project)"}
+  Ref: ${project.slug ?? project.id}
+  Mode: ${project.mode}`).join("\n\n")}
+`;
+}
+function renderSessionList(sessions) {
+  if (sessions.length === 0) {
+    return "No sessions found.\n";
+  }
+  return `${sessions.map((session) => `${session.id}  ${session.branchName}  ${session.name ?? "(unnamed)"}`).join("\n")}
+`;
+}
+function renderSessionDescription(session) {
+  return [`Session: ${session.id}`, `Project: ${session.projectName ?? session.projectId}`, `Branch: ${session.branchName}`].join("\n") + "\n";
+}
+function parseProjectCreateArgs(args) {
+  const input = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--name") {
+      input.name = requireValue(args[index + 1], "Missing value for --name");
+      index += 1;
+      continue;
+    }
+    const inlineName = arg ? parseLongOptionWithEquals(arg, "--name") : void 0;
+    if (inlineName !== void 0) {
+      input.name = inlineName;
+      continue;
+    }
+    if (arg === "--org" || arg === "--org-id") {
+      input.orgId = requireValue(args[index + 1], `Missing value for ${arg}`);
+      index += 1;
+      continue;
+    }
+    const inlineOrg = arg ? parseLongOptionWithEquals(arg, "--org") ?? parseLongOptionWithEquals(arg, "--org-id") : void 0;
+    if (inlineOrg !== void 0) {
+      input.orgId = inlineOrg;
+      continue;
+    }
+    throw new Error(`Unknown project create argument: ${arg}`);
+  }
+  return input;
+}
+function parseProjectUpdateArgs(args) {
+  const input = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--name") {
+      input.name = requireValue(args[index + 1], "Missing value for --name");
+      index += 1;
+      continue;
+    }
+    const inlineName = arg ? parseLongOptionWithEquals(arg, "--name") : void 0;
+    if (inlineName !== void 0) {
+      input.name = inlineName;
+      continue;
+    }
+    if (arg === "--mode") {
+      const mode = requireValue(args[index + 1], "Missing value for --mode");
+      if (mode !== "greenfield" && mode !== "prod") throw new Error("Invalid value for --mode: expected greenfield or prod");
+      input.mode = mode;
+      index += 1;
+      continue;
+    }
+    const inlineMode = arg ? parseLongOptionWithEquals(arg, "--mode") : void 0;
+    if (inlineMode !== void 0) {
+      if (inlineMode !== "greenfield" && inlineMode !== "prod") throw new Error("Invalid value for --mode: expected greenfield or prod");
+      input.mode = inlineMode;
+      continue;
+    }
+    throw new Error(`Unknown project update argument: ${arg}`);
+  }
+  if (Object.keys(input).length === 0) {
+    throw new Error("At least one project update flag is required");
+  }
+  return input;
+}
+function parseSessionCreateArgs(args) {
+  const branchName = requireValue(args[0], "Missing branch name");
+  const input = { branchName };
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--name") {
+      input.name = requireValue(args[index + 1], "Missing value for --name");
+      index += 1;
+      continue;
+    }
+    const inlineName = arg ? parseLongOptionWithEquals(arg, "--name") : void 0;
+    if (inlineName !== void 0) {
+      input.name = inlineName;
+      continue;
+    }
+    throw new Error(`Unknown session create argument: ${arg}`);
+  }
+  return input;
+}
+function parseSessionUpdateArgs(args) {
+  let hasName = false;
+  const input = { name: null };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--name") {
+      input.name = requireValue(args[index + 1], "Missing value for --name");
+      hasName = true;
+      index += 1;
+      continue;
+    }
+    const inlineName = arg ? parseLongOptionWithEquals(arg, "--name") : void 0;
+    if (inlineName !== void 0) {
+      input.name = inlineName;
+      hasName = true;
+      continue;
+    }
+    if (arg === "--clear-name") {
+      input.name = null;
+      hasName = true;
+      continue;
+    }
+    throw new Error(`Unknown session update argument: ${arg}`);
+  }
+  if (!hasName) {
+    throw new Error("Use --name <name> or --clear-name");
+  }
+  return input;
+}
+function parseConversationRenderArgs(args) {
+  const options = { full: false, compact: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--full" || arg === "--verbose") {
+      options.full = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      options.compact = true;
+      continue;
+    }
+    if (arg === "--tail") {
+      const value = Number(requireValue(args[index + 1], "Missing value for --tail"));
+      if (!Number.isInteger(value) || value <= 0) throw new Error("--tail must be a positive integer");
+      options.tail = value;
+      index += 1;
+      continue;
+    }
+    const inlineTail = arg ? parseLongOptionWithEquals(arg, "--tail") : void 0;
+    if (inlineTail !== void 0) {
+      const value = Number(inlineTail);
+      if (!Number.isInteger(value) || value <= 0) throw new Error("--tail must be a positive integer");
+      options.tail = value;
+      continue;
+    }
+    throw new Error(`Unknown conversation argument: ${arg}`);
+  }
+  if (options.full && options.compact) {
+    throw new Error("Use either --full or --compact, not both");
+  }
+  return options;
+}
+function renderConversationResponse(read, options = { full: false, compact: false }) {
+  const thread = Array.isArray(read.thread) ? read.thread : [];
+  const visibleThread = options.tail ? thread.slice(-options.tail) : thread;
+  const lines = [`Session: ${read.session.id}`, `Project: ${read.session.projectName ?? read.session.projectId}`, `Branch: ${read.session.branchName}`, ""];
+  lines.push(`Conversation nodes: ${visibleThread.length}${options.tail ? ` of ${thread.length}` : ""}`);
+  if (!options.compact) {
+    lines.push(JSON.stringify(visibleThread, null, options.full ? 2 : 0));
+  }
+  if (read.pendingQuestions.length > 0) {
+    lines.push("", "Pending questions:");
+    read.pendingQuestions.forEach((question, index) => lines.push(`${index + 1}. ${question.question}`));
+  }
+  if (read.requiredEnvs.length > 0) {
+    lines.push("", "Required envs:");
+    read.requiredEnvs.forEach((env) => lines.push(`- ${env.target}/${env.name}${env.optional ? "?" : ""}${env.description ? `: ${env.description}` : ""}`));
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function executeBinctlCommand(client, json, args) {
+  const write = (data, human) => writeDataOutput(json, data, human);
+  const [first, second, third] = args;
+  if (first === "auth" && second === "status") {
+    const status = await client.auth.status();
+    write(status, `Authenticated as ${status.user.email} via ${status.source}.
+`);
+    return;
+  }
+  if (first === "auth" && second === "logout") {
+    const response = await client.auth.logout();
+    write(response, response.revokedCredential ? "Logged out and revoked current credential.\n" : "Logged out.\n");
+    return;
+  }
+  if (first === "auth" && second === "api-key" && third === "list") {
+    const keys = await client.auth.apiKeys.list();
+    write(keys, keys.length === 0 ? "No API keys.\n" : `${keys.map((key) => `${key.id}  ${key.name}`).join("\n")}
+`);
+    return;
+  }
+  if (first === "auth" && second === "api-key" && third === "revoke") {
+    const result = await client.auth.apiKeys.revoke(requireValue(args[3], "Missing API key id"));
+    write(result, "API key revoked.\n");
+    return;
+  }
+  if (first === "projects" && second === "list" || first === "get" && second === "projects") {
+    const projects = await client.projects.list();
+    write(projects, renderProjectList(projects));
+    return;
+  }
+  if (first === "projects" && second === "create" || first === "create" && second === "project") {
+    const project = await client.projects.create(parseProjectCreateArgs(args.slice(2)));
+    write(project, renderProjectDescription(project));
+    return;
+  }
+  if (first === "projects" && second === "describe" || first === "describe" && second === "project") {
+    const project = await client.projects.describe(requireValue(args[2], "Missing project reference"));
+    write(project, renderProjectDescription(project));
+    return;
+  }
+  if (first === "projects" && second === "update" || first === "update" && second === "project") {
+    const projectRef = requireValue(args[2], "Missing project reference");
+    const project = await client.projects.update(projectRef, parseProjectUpdateArgs(args.slice(3)));
+    write(project, renderProjectDescription(project));
+    return;
+  }
+  if (first === "projects" && second === "delete" || first === "delete" && second === "project") {
+    const result = await client.projects.delete(requireValue(args[2], "Missing project reference"));
+    write(result, "Project deleted.\n");
+    return;
+  }
+  if (first === "projects" && second === "branches" && third === "list" || first === "get" && second === "branches") {
+    const projectRef = requireValue(first === "get" ? args[2] : args[3], "Missing project reference");
+    const branches = await client.projects.branches.list(projectRef);
+    write(branches, branches.length === 0 ? "No branches found.\n" : `${branches.map((branch) => `${branch.branchName}  sessions=${branch.sessionCount}`).join("\n")}
+`);
+    return;
+  }
+  if (first === "projects" && second === "branches" && third === "describe" || first === "describe" && second === "branch") {
+    const offset = first === "describe" ? 2 : 3;
+    const result = await client.projects.branches.describe(requireValue(args[offset], "Missing project reference"), requireValue(args[offset + 1], "Missing branch name"));
+    write(result, `Project: ${result.project.name ?? result.project.id}
+Branch: ${result.branchName}
+Sessions: ${result.sessions.length}
+`);
+    return;
+  }
+  if (first === "projects" && second === "sessions" && third === "list" || first === "get" && second === "sessions") {
+    const offset = first === "get" ? 2 : 3;
+    const projectRef = requireValue(args[offset], "Missing project reference");
+    const branch = parseOptionalFlagValue(args.slice(offset + 1), "--branch");
+    const sessions = await client.projects.sessions.list(projectRef, { branch });
+    write(sessions, renderSessionList(sessions));
+    return;
+  }
+  if (first === "projects" && second === "sessions" && third === "create" || first === "create" && second === "session") {
+    const offset = first === "create" ? 2 : 3;
+    const session = await client.projects.sessions.create(requireValue(args[offset], "Missing project reference"), parseSessionCreateArgs(args.slice(offset + 1)));
+    write(session, renderSessionDescription(session));
+    return;
+  }
+  if (first === "sessions" && second === "describe" || first === "describe" && second === "session") {
+    const session = await client.sessions.describe(requireValue(args[2], "Missing session id"));
+    write(session, renderSessionDescription(session));
+    return;
+  }
+  if (first === "sessions" && second === "update" || first === "update" && second === "session") {
+    const session = await client.sessions.update(requireValue(args[2], "Missing session id"), parseSessionUpdateArgs(args.slice(3)));
+    write(session, renderSessionDescription(session));
+    return;
+  }
+  if (first === "sessions" && second === "delete" || first === "delete" && second === "session") {
+    const result = await client.sessions.delete(requireValue(args[2], "Missing session id"));
+    write(result, "Session deleted.\n");
+    return;
+  }
+  if (first === "sessions" && second === "conversation" || first === "conversation") {
+    const offset = first === "conversation" ? 1 : 2;
+    const read = await client.sessions.conversation(requireValue(args[offset], "Missing session id"));
+    write(read, renderConversationResponse(read, parseConversationRenderArgs(args.slice(offset + 1))));
+    return;
+  }
+  if (first === "sessions" && second === "prompt" || first === "prompt") {
+    const offset = first === "prompt" ? 1 : 2;
+    const read = await client.sessions.prompt(requireValue(args[offset], "Missing session id"), {
+      mode: requireValue(args[offset + 1], "Missing mode"),
+      model: requireValue(args[offset + 2], "Missing model"),
+      message: requireValue(args[offset + 3], "Missing prompt message")
+    });
+    write(read, renderConversationResponse(read));
+    return;
+  }
+  if (first === "sessions" && second === "answer-questions" || first === "answer-questions") {
+    const offset = first === "answer-questions" ? 1 : 2;
+    const answers = args.slice(offset + 1);
+    if (answers.length === 0) throw new Error("At least one answer is required");
+    const read = await client.sessions.answerQuestions(requireValue(args[offset], "Missing session id"), { answers });
+    write(read, renderConversationResponse(read));
+    return;
+  }
+  if (first === "sessions" && second === "apply-required-envs" || first === "apply-required-envs") {
+    const offset = first === "apply-required-envs" ? 1 : 2;
+    const envs = args.slice(offset + 1);
+    if (envs.length === 0) throw new Error("At least one env assignment is required");
+    const read = await client.sessions.applyRequiredEnvs(requireValue(args[offset], "Missing session id"), { envs });
+    write(read, renderConversationResponse(read));
+    return;
+  }
+  throw new Error(`Unknown command: ${args.join(" ")}`);
+}
+function resolveCommandExecution(options, rest) {
+  const trailingHelp = isHelpFlag(rest.at(-1));
+  const normalizedRest = trailingHelp ? rest.slice(0, -1) : rest;
+  const command = normalizedRest[0];
+  if (!command) {
+    throw new Error("Missing command");
+  }
+  const commandArgs = normalizedRest.slice(1);
+  if (trailingHelp) {
+    const cliOnlyHelp = findCliOnlyCommandHelp(normalizedRest);
+    if (cliOnlyHelp) {
+      return {
+        kind: "cli-help",
+        text: renderCliOnlyCommandHelp(cliOnlyHelp)
+      };
+    }
+    const sharedHelp = renderSharedCommandHelp(normalizedRest);
+    if (sharedHelp) {
+      return {
+        kind: "cli-help",
+        text: sharedHelp
+      };
+    }
+    return {
+      kind: "plugin",
+      pluginArgs: [...normalizedRest, "--help"]
+    };
+  }
+  if (command === "projects" || command === "sessions") {
+    return {
+      kind: "plugin",
+      pluginArgs: normalizedRest
+    };
+  }
+  if (command === "auth") {
+    const subcommand = commandArgs[0];
+    const subArgs = commandArgs.slice(1);
+    if (subcommand === "login") {
+      return {
+        kind: "auth-login",
+        commandArgs: subArgs
+      };
+    }
+    if (subcommand === "status") {
+      return {
+        kind: "plugin",
+        pluginArgs: ["auth", "status"]
+      };
+    }
+    if (subcommand === "logout") {
+      return {
+        kind: "plugin",
+        pluginArgs: ["auth", "logout"],
+        clearAuthOnSuccess: true
+      };
+    }
+    if (subcommand === "api-key") {
+      const apiKeyCommand = subArgs[0];
+      const apiKeyArgs = subArgs.slice(1);
+      if (apiKeyCommand === "create") {
+        return {
+          kind: "auth-api-key-create",
+          commandArgs: apiKeyArgs
+        };
+      }
+      if (apiKeyCommand === "list") {
+        return {
+          kind: "plugin",
+          pluginArgs: ["auth", "api-key", "list"]
+        };
+      }
+      if (apiKeyCommand === "revoke") {
+        return {
+          kind: "plugin",
+          pluginArgs: ["auth", "api-key", "revoke", requireValue(apiKeyArgs[0], "Missing API key id")]
+        };
+      }
+      throw new Error("Unknown auth api-key command");
+    }
+    throw new Error("Unknown auth command");
+  }
+  if (command === "get") {
+    const target = commandArgs[0];
+    if (target === "projects") {
+      return {
+        kind: "plugin",
+        pluginArgs: ["get", "projects"]
+      };
+    }
+    if (target === "branches") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `get branches`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["get", "branches", options.project]
+      };
+    }
+    if (target === "sessions") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `get sessions`");
+      }
+      const pluginArgs = ["get", "sessions", options.project];
+      if (options.branch) {
+        pluginArgs.push("--branch", options.branch);
+      }
+      return {
+        kind: "plugin",
+        pluginArgs
+      };
+    }
+    throw new Error("Unknown get command");
+  }
+  if (command === "describe") {
+    const target = commandArgs[0];
+    if (target === "project") {
+      const projectRef = commandArgs[1] ?? options.project;
+      if (!projectRef) {
+        throw new Error("Project reference is required for `describe project`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["describe", "project", projectRef]
+      };
+    }
+    if (target === "branch") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `describe branch`");
+      }
+      const branch = commandArgs[1] ?? options.branch;
+      if (!branch) {
+        throw new Error("Branch name is required for `describe branch`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["describe", "branch", options.project, branch]
+      };
+    }
+    if (target === "session") {
+      const sessionId = commandArgs[1] ?? options.session;
+      if (!sessionId) {
+        throw new Error("Session id is required for `describe session`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["describe", "session", sessionId]
+      };
+    }
+    throw new Error("Unknown describe command");
+  }
+  if (command === "create") {
+    const target = commandArgs[0];
+    if (target === "project") {
+      return {
+        kind: "plugin",
+        pluginArgs: ["create", "project", ...commandArgs.slice(1)]
+      };
+    }
+    if (target === "session") {
+      const rawArgs = commandArgs.slice(1);
+      const firstFlagIndex = rawArgs.findIndex((arg) => arg.startsWith("-"));
+      const positionalArgs = firstFlagIndex === -1 ? rawArgs : rawArgs.slice(0, firstFlagIndex);
+      const flagArgs = firstFlagIndex === -1 ? [] : rawArgs.slice(firstFlagIndex);
+      const projectRef = positionalArgs[0] ?? options.project;
+      if (!projectRef) {
+        throw new Error("Project reference is required for `create session`");
+      }
+      const branch = positionalArgs[1] ?? options.branch;
+      if (!branch) {
+        throw new Error("Branch name is required for `create session`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["create", "session", projectRef, branch, ...flagArgs]
+      };
+    }
+    throw new Error("Unknown create command");
+  }
+  if (command === "update") {
+    const target = commandArgs[0];
+    if (target === "project") {
+      const projectRef = commandArgs[1] && !commandArgs[1].startsWith("-") ? commandArgs[1] : options.project;
+      if (!projectRef) {
+        throw new Error("Project reference is required for `update project`");
+      }
+      const remainingArgs = commandArgs[1] && !commandArgs[1].startsWith("-") ? commandArgs.slice(2) : commandArgs.slice(1);
+      return {
+        kind: "plugin",
+        pluginArgs: ["update", "project", projectRef, ...remainingArgs]
+      };
+    }
+    if (target === "session") {
+      const sessionId = commandArgs[1] && !commandArgs[1].startsWith("-") ? commandArgs[1] : options.session;
+      if (!sessionId) {
+        throw new Error("Session id is required for `update session`");
+      }
+      const remainingArgs = commandArgs[1] && !commandArgs[1].startsWith("-") ? commandArgs.slice(2) : commandArgs.slice(1);
+      return {
+        kind: "plugin",
+        pluginArgs: ["update", "session", sessionId, ...remainingArgs]
+      };
+    }
+    throw new Error("Unknown update command");
+  }
+  if (command === "delete") {
+    const target = commandArgs[0];
+    if (target === "project") {
+      const projectRef = commandArgs[1] ?? options.project;
+      if (!projectRef) {
+        throw new Error("Project reference is required for `delete project`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["delete", "project", projectRef]
+      };
+    }
+    if (target === "session") {
+      const sessionId = commandArgs[1] ?? options.session;
+      if (!sessionId) {
+        throw new Error("Session id is required for `delete session`");
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["delete", "session", sessionId]
+      };
+    }
+    throw new Error("Unknown delete command");
+  }
+  if (command === "conversation") {
+    const sessionId = options.session;
+    if (!sessionId) {
+      throw new Error("--session/-s is required for `conversation`");
+    }
+    return {
+      kind: "plugin",
+      pluginArgs: ["conversation", sessionId, ...commandArgs]
+    };
+  }
+  if (command === "prompt") {
+    const sessionId = options.session;
+    if (!sessionId) {
+      throw new Error("--session/-s is required for `prompt`");
+    }
+    const parsed = parsePromptArgs(commandArgs);
+    return {
+      kind: "plugin",
+      pluginArgs: ["prompt", sessionId, parsed.mode, parsed.model, parsed.message]
+    };
+  }
+  if (command === "answer-questions") {
+    const sessionId = options.session;
+    if (!sessionId) {
+      throw new Error("--session/-s is required for `answer-questions`");
+    }
+    return {
+      kind: "plugin",
+      pluginArgs: ["answer-questions", sessionId, ...parseAnswerFlags(commandArgs)]
+    };
+  }
+  if (command === "apply-required-envs") {
+    const sessionId = options.session;
+    if (!sessionId) {
+      throw new Error("--session/-s is required for `apply-required-envs`");
+    }
+    return {
+      kind: "plugin",
+      pluginArgs: ["apply-required-envs", sessionId, ...parseEnvFlags(commandArgs)]
+    };
+  }
+  throw new Error(`Unknown command: ${command}`);
+}
+async function runCommand(argv) {
+  const { options, rest } = parseGlobalArgs(argv);
+  if (options.help || rest.length === 0) {
+    printHelp();
+    return;
+  }
+  const config = parseConfig(options.configPath);
+  const client = new import_r5d_api.BinctlClient(resolveClientOptions(options, config));
+  const execution = resolveCommandExecution(options, rest);
+  if (execution.kind === "auth-login") {
+    await handleAuthLogin(client, options, execution.commandArgs, config);
+    return;
+  }
+  if (execution.kind === "auth-api-key-create") {
+    await handleAuthApiKeyCreate(client, options, config, execution.commandArgs);
+    return;
+  }
+  if (execution.kind === "cli-help") {
+    process.stdout.write(execution.text);
+    return;
+  }
+  await executeBinctlCommand(client, options.json, execution.pluginArgs);
+  if (execution.clearAuthOnSuccess) {
+    writeConfig(options.configPath, clearAuthFromConfig(config, options));
+  }
+}
+function extractApiErrorMessage(error) {
+  if (typeof error.body === "object" && error.body !== null) {
+    const body = error.body;
+    if (typeof body.error === "string" && body.error.trim().length > 0) {
+      return body.error;
+    }
+  }
+  return error.message;
+}
+async function runBinctlCli(argv) {
+  try {
+    await runCommand(argv);
+    return 0;
+  } catch (error) {
+    if (error instanceof import_r5d_api.BinctlApiError) {
+      process.stderr.write(`${extractApiErrorMessage(error)}
+`);
+      return 1;
+    }
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  const exitCode = await runBinctlCli(argv);
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCliHelpText,
+  main,
+  parseAnswerFlags,
+  parseEnvFlags,
+  parseGlobalArgs,
+  parsePromptArgs,
+  resolveCommandExecution,
+  runBinctlCli
+});