@ricsam/r5dctl 0.0.101 → 0.0.104

package/dist/mjs/cli.mjs

@@ -72,14 +72,19 @@ const K8S_HELP_TEXT = [
 ].join("\n");
 const SESSION_RUN_HELP_TEXT = [
   "Usage:",
-  '  r5dctl -p <project> session start --worker <label> --worktree <branch> --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
-  '  r5dctl -p <project> session start --worker <label> --new-worktree <branch> --source worktree:<branch> --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
+  '  r5dctl -p <project> session start --worker <label> --worktree <branch> --model <tier> [-f|--follow|--watch] [--tools] [--parent-session <session-id>] "<prompt>"',
+  '  r5dctl -p <project> session start --worker <label> --new-worktree <branch> --source worktree:<branch> [--working-tree carry|clean] --model <tier> [-f|--follow|--watch] [--tools] [--parent-session <session-id>] "<prompt>"',
   "  r5dctl session status <session-id>",
   '  r5dctl session prompt --worker <label> --mode <mode> --model <tier> <session-id> "<prompt>"',
   "  r5dctl session stop <session-id>",
+  "  r5dctl session process-log <run-id> [--tail <n>] [--grep <pattern>]",
   "",
   "Create, inspect, resume, and stop ordinary agent sessions.",
+  "A new worktree starts with the source checkout's uncommitted changes (--working-tree carry, the default);",
+  "--working-tree clean checks out the source branch's current commit only. Start and status print the mode, never a commit hash.",
   "Use -f/--follow/--watch to attach after a start; Ctrl-C detaches without stopping the session.",
+  "process-log prints a shell run's stored stdout/stderr from the server: the whole log, its last n lines,",
+  "or the lines matching a JavaScript regular expression. The log is not a file on the worker.",
   ""
 ].join("\n");
 const SHARED_HELP_ENTRIES = [
@@ -109,6 +114,21 @@ const SHARED_HELP_ENTRIES = [
   { section: "projects", usage: "delete project <namespace/name|id>", 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: "branches",
+    usage: "-p <project> create branch <branch> --source worktree:<branch> [--working-tree <carry|clean>] [--worker <label>]",
+    description: "Create a linked worktree branch from an existing branch's checkout and print the operation id to poll."
+  },
+  {
+    section: "branches",
+    usage: "-p <project> describe branch-operation <operation-id>",
+    description: "Show whether a branch creation is provisioning, ready, or failed."
+  },
+  {
+    section: "branches",
+    usage: "-p <project> delete branch <branch> [--confirm]",
+    description: "Delete a branch and its sessions through the platform; without --confirm, only preview what would be deleted."
+  },
   {
     section: "envs",
     usage: "-p <project> get envs [--show-values]",
@@ -179,8 +199,8 @@ const SHARED_HELP_ENTRIES = [
   },
   {
     section: "sessions",
-    usage: '-p <project> session start --worker <label> (--worktree <branch>|--new-worktree <branch> --source worktree:<branch>) --model <tier> [-f|--follow|--watch] [--tools] "<prompt>"',
-    description: "Start an ordinary agent session on an explicit existing or new worktree."
+    usage: '-p <project> session start --worker <label> (--worktree <branch>|--new-worktree <branch> --source worktree:<branch> [--working-tree carry|clean]) --model <tier> [-f|--follow|--watch] [--tools] [--parent-session <session-id>] "<prompt>"',
+    description: "Start an ordinary agent session on an explicit existing or new worktree. A new worktree carries the source checkout's uncommitted changes unless --working-tree clean is passed. --parent-session links it like start_subagent: the parent is notified when the run finishes."
   },
   {
     section: "sessions",
@@ -197,6 +217,11 @@ const SHARED_HELP_ENTRIES = [
     usage: "session stop <session-id>",
     description: "Stop an active session generation."
   },
+  {
+    section: "sessions",
+    usage: "session process-log <run-id> [--tail <n>] [--grep <pattern>]",
+    description: "Print a shell run's stored stdout/stderr from the server: the whole log, its last lines, or lines matching a regular expression."
+  },
   {
     section: "sessions",
     usage: '-s <session-id> answer-questions --worker <label> --mode <mode> --model <tier> -a1 "<answer>" ...',
@@ -450,8 +475,8 @@ function parseCommandOperands(args, valueFlags, booleanFlags = /* @__PURE__ */ n
 function requireWorker(values) {
   return requireValue(values.get("--worker")?.trim(), "--worker <label> is required");
 }
-function parseWorktreeSource(rawValue) {
-  const raw = requireValue(rawValue?.trim(), "--source worktree:<branch> is required with --new-worktree");
+function parseWorktreeSource(rawValue, requiredMessage = "--source worktree:<branch> is required with --new-worktree") {
+  const raw = requireValue(rawValue?.trim(), requiredMessage);
   const separator = raw.indexOf(":");
   const type = raw.slice(0, separator);
   const branchName = raw.slice(separator + 1).trim();
@@ -460,6 +485,12 @@ function parseWorktreeSource(rawValue) {
   }
   return { type, branchName };
 }
+function parseWorkingTreeMode(rawValue) {
+  if (rawValue === void 0) return "carry";
+  const mode = rawValue.trim();
+  if (mode !== "carry" && mode !== "clean") throw new Error("Invalid --working-tree. Expected carry or clean");
+  return mode;
+}
 function requireModel(value) {
   const model = requireValue(value?.trim(), "--model <tier> is required");
   if (!MODEL_TIERS.has(model)) throw new Error("Invalid --model. Expected one of: low, medium, high, max");
@@ -472,6 +503,103 @@ function requireSessionMode(value) {
   }
   return mode;
 }
+function parseBranchCreateArgs(args) {
+  const parsed = parseCommandOperands(args, /* @__PURE__ */ new Set(["--source", "--working-tree", "--worker"]), /* @__PURE__ */ new Map(), "create branch", 1);
+  if (parsed.positionals.length > 0) throw new Error(`Unexpected create branch argument: ${parsed.positionals[0]}`);
+  const worker = parsed.values.get("--worker")?.trim();
+  if (parsed.values.has("--worker") && !worker) throw new Error("Missing value for --worker");
+  return {
+    source: parseWorktreeSource(parsed.values.get("--source"), "--source worktree:<branch> is required for `create branch`"),
+    workingTree: parseWorkingTreeMode(parsed.values.get("--working-tree")),
+    ...worker ? { worker } : {}
+  };
+}
+function parseBranchDeleteArgs(args) {
+  let confirmed = false;
+  for (const arg of args) {
+    if (arg === "--confirm") {
+      confirmed = true;
+      continue;
+    }
+    throw new Error(arg.startsWith("-") ? `Unknown delete branch flag: ${arg}` : `Unexpected delete branch argument: ${arg}`);
+  }
+  return { confirmed };
+}
+const PRIMARY_BRANCH_NAME = "main";
+function isUnsupportedServerRoute(error) {
+  return error instanceof R5dctlApiError && error.status === 404 && extractApiErrorMessage(error) === "Not Found";
+}
+async function requireServerRouteSupport(command, request) {
+  try {
+    return await request();
+  } catch (error) {
+    if (isUnsupportedServerRoute(error)) {
+      throw new Error(`This r5d server does not support \`${command}\` yet. Update the server, or manage the branch from the web sidebar.`);
+    }
+    throw error;
+  }
+}
+async function createBranchThroughPlatform(client, projectRef, input) {
+  return await requireServerRouteSupport(
+    "create branch",
+    () => client.projects.branches.create(projectRef, {
+      requestId: randomUUID(),
+      branchName: input.branchName,
+      source: input.source,
+      workingTree: input.workingTree,
+      ...input.worker ? { worker: input.worker } : {}
+    })
+  );
+}
+async function deleteBranchThroughPlatform(client, projectRef, branchName, options) {
+  if (branchName === PRIMARY_BRANCH_NAME) throw new Error(`The primary branch ${branchName} cannot be deleted`);
+  const branch = await client.projects.branches.describe(projectRef, branchName);
+  if (!options.confirmed) return { kind: "preview", branch };
+  const result = await requireServerRouteSupport("delete branch", () => client.projects.branches.delete(projectRef, branchName));
+  return { kind: "deleted", result };
+}
+function renderBranchDeletionPreview(branch) {
+  const count = branch.sessions.length;
+  const lines = [
+    `Project: ${branch.project.path}`,
+    `Branch: ${branch.branchName}`,
+    `Sessions: ${count}`,
+    ...branch.sessions.map((session) => `  ${session.id}  ${session.name ?? "(unnamed)"}`),
+    `Deleting this branch removes its checkout from every connected worker and deletes the ${count} session(s) above.`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function branchDeletionConfirmationMessage(branch) {
+  return `Nothing was deleted. Re-run with --confirm to delete branch ${branch.branchName} and its ${branch.sessions.length} session(s).`;
+}
+function renderBranchDeletion(result) {
+  const lines = [
+    `Deleted branch ${result.branchName} and ${result.deletedSessionIds.length} session(s).`,
+    ...result.deletedSessionIds.map((sessionId) => `  ${sessionId}`)
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function renderBranchOperation(operation, projectRef) {
+  const lines = [
+    `Operation: ${operation.id}`,
+    `Branch: ${operation.branchName}`,
+    `Source: worktree:${operation.source.branchName}`,
+    `Working tree: ${operation.workingTree}`,
+    `Worker: ${operation.worker ?? "(pending)"}`,
+    `Status: ${operation.status}`
+  ];
+  if (operation.error) lines.push(`Error: ${operation.error}`);
+  if (operation.cleanupPending) lines.push("Cleanup: pending");
+  if (operation.status === "provisioning") {
+    lines.push(`Check: r5dctl -p ${projectRef} describe branch-operation ${operation.id}`);
+  } else if (operation.status === "ready") {
+    lines.push(`Branch state: ${formatBranchStateHint(operation.branchName)}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
 function rejectSessionRunGlobalScopes(options, allowProject) {
   if (!allowProject && options.project) throw new Error("--project/-p is only supported for `session start`");
   if (options.branch) throw new Error("--branch/-b is not supported for `session`; select the worktree explicitly");
@@ -485,7 +613,7 @@ function parseSessionRunCommand(options, args) {
     const project = requireValue(options.project, "--project/-p is required for `session start`");
     const parsed = parseCommandOperands(
       commandArgs,
-      /* @__PURE__ */ new Set(["--worker", "--worktree", "--new-worktree", "--source", "--model"]),
+      /* @__PURE__ */ new Set(["--worker", "--worktree", "--new-worktree", "--source", "--working-tree", "--model", "--parent-session"]),
       /* @__PURE__ */ new Map([
         ["-f", "--follow"],
         ["--follow", "--follow"],
@@ -504,6 +632,9 @@ function parseSessionRunCommand(options, args) {
     }
     const sourceValue = parsed.values.get("--source");
     if (worktree && sourceValue) throw new Error("--source is only supported with --new-worktree");
+    const workingTreeValue = parsed.values.get("--working-tree");
+    if (worktree && workingTreeValue !== void 0) throw new Error("--working-tree is only supported with --new-worktree");
+    const parentSessionId = parsed.values.get("--parent-session")?.trim();
     return {
       kind: "start",
       project,
@@ -512,7 +643,8 @@ function parseSessionRunCommand(options, args) {
       prompt,
       follow: parsed.booleans.has("--follow"),
       includeTools: parsed.booleans.has("--tools"),
-      ...worktree ? { worktree } : { newWorktree, source: parseWorktreeSource(sourceValue) }
+      ...parentSessionId ? { parentSessionId } : {},
+      ...worktree ? { worktree } : { newWorktree, source: parseWorktreeSource(sourceValue), workingTree: parseWorkingTreeMode(workingTreeValue) }
     };
   }
   rejectSessionRunGlobalScopes(options, false);
@@ -538,6 +670,16 @@ function parseSessionRunCommand(options, args) {
   }
   throw new Error(`Unknown session command: ${subcommand}`);
 }
+function parseSessionProcessLogArgs(args) {
+  const parsed = parseCommandOperands(args, /* @__PURE__ */ new Set(["--tail", "--grep"]), /* @__PURE__ */ new Map(), "session process-log");
+  const runId = requireValue(parsed.positionals[0], "Process run id is required for `session process-log`");
+  if (parsed.positionals.length > 1) throw new Error(`Unexpected session process-log argument: ${parsed.positionals[1]}`);
+  const tailValue = parsed.values.get("--tail");
+  const tail = tailValue === void 0 ? void 0 : Number(tailValue);
+  if (tail !== void 0 && (!Number.isInteger(tail) || tail < 1)) throw new Error("--tail must be a positive integer");
+  const grep = parsed.values.get("--grep");
+  return { runId, ...tail !== void 0 ? { tail } : {}, ...grep !== void 0 ? { grep } : {} };
+}
 function assertAuthLoginArgs(args) {
   const valueFlags = /* @__PURE__ */ new Set(["--device-name", "--worker-label"]);
   const booleanFlags = /* @__PURE__ */ new Set(["--no-open", "--no-qr"]);
@@ -1364,10 +1506,34 @@ function renderWorkspaceStatus(status) {
     `Workspace HEAD: ${status.head ?? "(not initialized)"}`,
     `Latest sync: ${status.latestSync ? `${status.latestSync.outcome} on ${status.latestSync.workerLabel}` : "(none)"}`,
     `Remediation: ${status.incident ? `${status.incident.kind} ${status.incident.status} (${status.incident.id}) on ${status.incident.originWorkerLabel}` : "none"}`,
-    ...status.workers.map(
-      (worker) => `Worker ${worker.workerLabel}: ${worker.configured ? "configured" : "configuring"}; head ${worker.localHead ?? "(none)"}; pending checkouts ${worker.pendingCheckouts.length}`
-    )
+    ...status.workers.flatMap((worker) => [
+      `Worker ${worker.workerLabel}: ${worker.configured ? "configured" : "configuring"}; head ${worker.localHead ?? "(none)"}; pending checkouts ${worker.pendingCheckouts.length}`,
+      ...renderMissingCheckouts(worker.workerLabel, worker.missingCheckouts ?? [])
+    ])
   ];
+  if (status.latestSync?.missingCheckouts?.length && !status.workers.some((worker) => worker.missingCheckouts?.length)) {
+    lines.push(...renderMissingCheckouts(status.latestSync.workerLabel, status.latestSync.missingCheckouts));
+  }
+  return `${lines.join("\n")}
+`;
+}
+const CHECKOUT_RECOVERY_HINT = "delete the branch with `r5dctl -p <project> delete branch <branch> --confirm`, or reconnect the worker to recreate the checkout";
+function renderMissingCheckouts(workerLabel, missingCheckouts) {
+  if (missingCheckouts.length === 0) return [];
+  return [
+    `Missing checkouts on ${workerLabel}: ${missingCheckouts.map((checkout) => `${checkout.projectId}/${checkout.branchName} (${checkout.reason})`).join(", ")}`,
+    `  Workspace sync skips these branches; ${CHECKOUT_RECOVERY_HINT}.`
+  ];
+}
+function renderBranchList(branches) {
+  if (branches.length === 0) return "No branches found.\n";
+  const lines = branches.map((branch) => {
+    const checkout = branch.checkoutState ? `  checkout=${branch.checkoutState}${branch.checkoutStateWorkerLabel ? ` on ${branch.checkoutStateWorkerLabel}` : ""}` : "";
+    return `${branch.branchName}  sessions=${branch.sessionCount}${checkout}`;
+  });
+  if (branches.some((branch) => branch.checkoutState)) {
+    lines.push(`Workspace sync skips a branch whose checkout is missing or not a worktree; ${CHECKOUT_RECOVERY_HINT}.`);
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -1595,6 +1761,32 @@ function renderProcessList(processes, nowMs = Date.now()) {
 function renderProcessHistory(processes, nowMs = Date.now()) {
   return processes.length === 0 ? "No process history.\n" : renderProcessList(processes, nowMs);
 }
+function renderProcessLog(log) {
+  const sections = [];
+  for (const [name, stream] of [
+    ["stdout", log.stdout],
+    ["stderr", log.stderr]
+  ]) {
+    if (stream.text.length === 0) continue;
+    sections.push(`==> ${name} <==
+${stream.text.endsWith("\n") ? stream.text : `${stream.text}
+`}`);
+  }
+  const selection = [
+    ...log.grep !== void 0 ? [`lines matching /${log.grep}/`] : [],
+    ...log.tailLines !== void 0 ? [`last ${log.tailLines} lines`] : []
+  ];
+  const cut = [log.stdout.truncated ? "stdout" : void 0, log.stderr.truncated ? "stderr" : void 0].filter(Boolean);
+  const summary = [
+    `Run ${log.runId} (${log.status}${log.exitCode !== void 0 ? `, exit ${log.exitCode}` : ""}): `,
+    `stdout ${log.stdout.totalBytes} bytes, stderr ${log.stderr.totalBytes} bytes`,
+    selection.length > 0 ? `; showing ${selection.join(", ")}` : "",
+    cut.length > 0 ? `; ${cut.join(" and ")} cut to ${log.maxBytesPerStream} bytes, narrow with --tail or --grep` : "",
+    sections.length === 0 ? "; no output to show" : ""
+  ].join("");
+  return { text: sections.join(""), summary: `${summary}
+` };
+}
 function renderProcessInspection(process2) {
   return [
     `Run: ${process2.runId}`,
@@ -1748,13 +1940,22 @@ function formatStatusValue(value) {
   }
   return value === void 0 || value === null ? void 0 : String(value);
 }
+function pushWorktreeOriginLines(lines, session) {
+  const source = responseString(session, "sourceBranch");
+  const mode = responseString(session, "workingTree");
+  if (!source || !mode) return;
+  lines.push(`Source: ${source}`);
+  const detail = mode === "carry" ? `carried ${source}'s uncommitted changes at launch` : mode === "clean" ? `clean checkout of ${source}'s commit at launch` : void 0;
+  lines.push(`Working tree: ${mode}${detail ? ` (${detail})` : ""}`);
+}
 function renderSessionRunStart(session) {
   const lines = [
     `Session: ${responseString(session, "sessionId") ?? "(unknown)"}`,
     `Status: ${formatStatusValue(session.status) ?? "queued"}`,
-    `Worktree: ${responseString(session, "branchName") ?? "(provisioning)"}`,
-    `Worker: ${responseString(session, "worker") ?? "(unassigned)"}`
+    `Worktree: ${responseString(session, "branchName") ?? "(provisioning)"}`
   ];
+  pushWorktreeOriginLines(lines, session);
+  lines.push(`Worker: ${responseString(session, "worker") ?? "(unassigned)"}`);
   const sessionUrl = responseString(session, "sessionUrl");
   if (sessionUrl) lines.push(`URL: ${sessionUrl}`);
   const sessionId = responseString(session, "sessionId");
@@ -1762,29 +1963,50 @@ function renderSessionRunStart(session) {
   return `${lines.join("\n")}
 `;
 }
+function formatBranchStateHint(branch) {
+  const target = branch ?? "<branch>";
+  const commands = [
+    `git merge-base <your-branch> ${target}`,
+    `git log --oneline <your-branch>..${target}`,
+    "git status in the branch folder"
+  ];
+  return `inspect the worktree with git (${commands.join("; ")})`;
+}
+function formatQueuedAt(value) {
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? value : new Date(time).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function formatProvisioningQueueLine(session) {
+  const position = session.provisioningQueuePosition;
+  const queuedAt = responseString(session, "provisioningQueuedAt");
+  if (typeof position !== "number" || !Number.isInteger(position) || position < 0 || !queuedAt) return void 0;
+  const since = formatQueuedAt(queuedAt);
+  if (position === 0) return `Provisioning: worker started the branch operation at ${since}`;
+  return `Provisioning: queued behind ${position} worker operation${position === 1 ? "" : "s"} since ${since}`;
+}
 function renderSessionRunStatus(session) {
   const status = formatStatusValue(session.status) ?? "unknown";
   const lines = [`Session: ${responseString(session, "sessionId") ?? "(unknown)"}`, `Status: ${status}`];
   const runStatus = formatStatusValue(session.runStatus);
   if (runStatus) lines.push(`Run: ${runStatus}`);
+  const provisioningQueue = formatProvisioningQueueLine(session);
+  if (provisioningQueue) lines.push(provisioningQueue);
   const promptDisposition = responseString(session, "promptDisposition");
   if (promptDisposition) lines.push(`Prompt: ${promptDisposition}`);
   const branch = responseString(session, "branchName");
   if (branch) lines.push(`Worktree: ${branch}`);
+  pushWorktreeOriginLines(lines, session);
   for (const [label, key] of [
-    ["Workspace head", "workspaceHead"],
-    ["Baseline", "baselineCommit"],
-    ["Head", "headCommit"],
     ["Worker", "worker"],
+    ["Parent session", "parentSessionId"],
     ["Session", "sessionUrl"]
   ]) {
     const value = responseString(session, key);
     if (value) lines.push(`${label}: ${value}`);
   }
+  lines.push(`Branch state: ${formatBranchStateHint(branch)}`);
   const error = responseString(session, "error");
   if (error) lines.push(`Error: ${error}`);
-  const headCommitError = responseString(session, "headCommitError");
-  if (headCommitError) lines.push(`Head error: ${headCommitError}`);
   const diffSummary = responseString(session, "diffSummary");
   if (diffSummary) lines.push("", diffSummary);
   const summary = responseString(session, "summary");
@@ -1802,13 +2024,14 @@ async function dispatchSessionRunCommand(client, command) {
       prompt: command.prompt,
       worker: command.worker,
       model: command.model,
-      requestId: randomUUID()
+      requestId: randomUUID(),
+      ...command.parentSessionId ? { parentSessionId: command.parentSessionId } : {}
     };
     let input;
     if (command.worktree !== void 0) {
       input = { ...commonInput, worktree: command.worktree };
     } else if (command.newWorktree !== void 0 && command.source !== void 0) {
-      input = { ...commonInput, newWorktree: command.newWorktree, source: command.source };
+      input = { ...commonInput, newWorktree: command.newWorktree, source: command.source, workingTree: command.workingTree };
     } else {
       throw new Error("Session start requires an existing or new worktree");
     }
@@ -2448,6 +2671,17 @@ async function executeR5dctlCommand(client, json, args) {
 `);
     return;
   }
+  if (first === "session" && second === "process-log") {
+    const selection = parseSessionProcessLogArgs(args.slice(2));
+    const log = await client.processes.log(selection.runId, {
+      ...selection.tail !== void 0 ? { tail: selection.tail } : {},
+      ...selection.grep !== void 0 ? { grep: selection.grep } : {}
+    });
+    const rendered = renderProcessLog(log);
+    write(log, rendered.text);
+    if (!json) process.stderr.write(rendered.summary);
+    return;
+  }
   if (first === "sessions" && second === "recent") {
     const sessions = await client.sessions.recent(parseRecentSessionArgs(args.slice(2)));
     write(sessions, renderRecentSessionList(sessions));
@@ -2477,11 +2711,7 @@ async function executeR5dctlCommand(client, json, args) {
   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")}
-`
-    );
+    write(branches, renderBranchList(branches));
     return;
   }
   if (first === "projects" && second === "branches" && third === "describe" || first === "describe" && second === "branch") {
@@ -2496,6 +2726,40 @@ Sessions: ${result.sessions.length}
 `);
     return;
   }
+  if (first === "projects" && second === "branches" && third === "create" || first === "create" && second === "branch") {
+    const offset = first === "create" ? 2 : 3;
+    const projectRef = requireValue(args[offset], "Missing project reference");
+    const branchName = requireValue(args[offset + 1], "Missing branch name");
+    const operation = await createBranchThroughPlatform(client, projectRef, {
+      branchName,
+      ...parseBranchCreateArgs(args.slice(offset + 2))
+    });
+    write(operation, renderBranchOperation(operation, projectRef));
+    return;
+  }
+  if (first === "projects" && second === "branches" && third === "operation" || first === "describe" && second === "branch-operation") {
+    const offset = first === "describe" ? 2 : 3;
+    const projectRef = requireValue(args[offset], "Missing project reference");
+    const operationId = requireValue(args[offset + 1], "Missing operation id");
+    const operation = await requireServerRouteSupport(
+      "describe branch-operation",
+      () => client.projects.branches.describeOperation(projectRef, operationId)
+    );
+    write(operation, renderBranchOperation(operation, projectRef));
+    return;
+  }
+  if (first === "projects" && second === "branches" && third === "delete" || first === "delete" && second === "branch") {
+    const offset = first === "delete" ? 2 : 3;
+    const projectRef = requireValue(args[offset], "Missing project reference");
+    const branchName = requireValue(args[offset + 1], "Missing branch name");
+    const deletion = await deleteBranchThroughPlatform(client, projectRef, branchName, parseBranchDeleteArgs(args.slice(offset + 2)));
+    if (deletion.kind === "preview") {
+      write({ ...deletion.branch, confirmed: false }, renderBranchDeletionPreview(deletion.branch));
+      throw new Error(branchDeletionConfirmationMessage(deletion.branch));
+    }
+    write(deletion.result, renderBranchDeletion(deletion.result));
+    return;
+  }
   if (first === "get" && second === "envs") {
     const projectRef = requireValue(args[2], "Missing project reference");
     const options = parseGetEnvsArgs(args.slice(3));
@@ -2912,6 +3176,19 @@ function resolveCommandExecution(options, rest) {
         pluginArgs: ["describe", "branch", options.project, branch]
       };
     }
+    if (target === "branch-operation") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `describe branch-operation`");
+      }
+      const operationId = requireValue(commandArgs[1], "Operation id is required for `describe branch-operation`");
+      if (commandArgs.length > 2) {
+        throw new Error(`Unexpected describe branch-operation argument: ${commandArgs[2]}`);
+      }
+      return {
+        kind: "plugin",
+        pluginArgs: ["describe", "branch-operation", options.project, operationId]
+      };
+    }
     if (target === "session") {
       const sessionId = commandArgs[1] ?? options.session;
       if (!sessionId) {
@@ -2944,6 +3221,23 @@ function resolveCommandExecution(options, rest) {
         pluginArgs: ["create", "session", projectRef, branch, ...flagArgs]
       };
     }
+    if (target === "branch") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `create branch`");
+      }
+      const rawArgs = commandArgs.slice(1);
+      const positionalBranch = rawArgs[0] && !rawArgs[0].startsWith("-") ? rawArgs[0] : void 0;
+      const branch = positionalBranch ?? options.branch;
+      if (!branch) {
+        throw new Error("Branch name is required for `create branch`");
+      }
+      const flagArgs = positionalBranch ? rawArgs.slice(1) : rawArgs;
+      parseBranchCreateArgs(flagArgs);
+      return {
+        kind: "plugin",
+        pluginArgs: ["create", "branch", options.project, branch, ...flagArgs]
+      };
+    }
     throw new Error("Unknown create command");
   }
   if (command === "update") {
@@ -2994,6 +3288,23 @@ function resolveCommandExecution(options, rest) {
         pluginArgs: ["delete", "session", sessionId]
       };
     }
+    if (target === "branch") {
+      if (!options.project) {
+        throw new Error("--project/-p is required for `delete branch`");
+      }
+      const rawArgs = commandArgs.slice(1);
+      const positionalBranch = rawArgs[0] && !rawArgs[0].startsWith("-") ? rawArgs[0] : void 0;
+      const branch = positionalBranch ?? options.branch;
+      if (!branch) {
+        throw new Error("Branch name is required for `delete branch`");
+      }
+      const flagArgs = positionalBranch ? rawArgs.slice(1) : rawArgs;
+      parseBranchDeleteArgs(flagArgs);
+      return {
+        kind: "plugin",
+        pluginArgs: ["delete", "branch", options.project, branch, ...flagArgs]
+      };
+    }
     throw new Error("Unknown delete command");
   }
   if (command === "conversation") {
@@ -3055,6 +3366,20 @@ function resolveCommandExecution(options, rest) {
     };
   }
   if (command === "session") {
+    if (commandArgs[0] === "process-log") {
+      rejectSessionRunGlobalScopes(options, false);
+      const selection = parseSessionProcessLogArgs(commandArgs.slice(1));
+      return {
+        kind: "plugin",
+        pluginArgs: [
+          "session",
+          "process-log",
+          selection.runId,
+          ...selection.tail !== void 0 ? [`--tail=${selection.tail}`] : [],
+          ...selection.grep !== void 0 ? [`--grep=${selection.grep}`] : []
+        ]
+      };
+    }
     return { kind: "session-run", command: parseSessionRunCommand(options, commandArgs) };
   }
   if (command === "answer-questions") {
@@ -3206,7 +3531,10 @@ async function main(argv = process.argv.slice(2)) {
 }
 export {
   advanceTransientDevicePollBackoff,
+  branchDeletionConfirmationMessage,
   collectK8sUsage,
+  createBranchThroughPlatform,
+  deleteBranchThroughPlatform,
   dispatchSessionRunCommand,
   followR5dctlSession,
   formatK8sCpu,
@@ -3218,10 +3546,13 @@ export {
   getR5dctlVersion,
   getTransientDevicePollDelay,
   handleAuthLogin,
+  isUnsupportedServerRoute,
   main,
   parseAnswerEnvRequestCommandArgs,
   parseAnswerFlags,
   parseAnswerQuestionsCommandArgs,
+  parseBranchCreateArgs,
+  parseBranchDeleteArgs,
   parseConversationForkArgs,
   parseConversationInspectWorkArgs,
   parseConversationOverviewArgs,
@@ -3234,10 +3565,15 @@ export {
   parsePromptArgs,
   parsePsHistoryArgs,
   parsePsListArgs,
+  parseSessionProcessLogArgs,
   parseSessionRunCommand,
   parseSetEnvArgs,
   parseShellArgs,
   readDotenvFile,
+  renderBranchDeletion,
+  renderBranchDeletionPreview,
+  renderBranchList,
+  renderBranchOperation,
   renderConversationForkResponse,
   renderConversationHeadResponse,
   renderConversationNodeResponse,
@@ -3250,6 +3586,7 @@ export {
   renderProcessHistory,
   renderProcessInspection,
   renderProcessList,
+  renderProcessLog,
   renderSessionRunStart,
   renderSessionRunStatus,
   renderWorkspaceStatus,

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5dctl",
-  "version": "0.0.101",
+  "version": "0.0.104",
   "type": "module"
 }