@usepowerplant/cli 0.4.11 → 0.4.12

package/README.md

@@ -226,11 +226,12 @@ npm install -g --prefix ~/.powerplant-staging @usepowerplant/cli@next
 ~/.powerplant-staging/bin/powerplant init --env staging
 ```
 
-`init --env staging` also points each selected agent's shared `powerplant`
-MCP connection at staging. Separate npm prefixes do not isolate that entry.
-After testing, run `powerplant connect` from your production install to
-restore the agents' production connection; the staging sync service keeps
-running. Include `--env staging` on every staging command.
+`init --env staging` registers its own MCP entry, `powerplant-staging`, in each
+selected agent, beside the production `powerplant` entry. Agents see its tools
+as `mcp__powerplant-staging__*`. A CLI older than this change registered
+staging as `powerplant`: if that entry still points at staging, run a bare
+`powerplant connect` from your production install once to restore it. Include
+`--env staging` on every staging command.
 
 The `@next` pin matters: a bare install resolves `latest`, the production
 channel, so the new staging copy would start on the promoted release and

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7d73a97a-938c-5f0f-8b6b-c4076b82abad")}catch(e){}}();
 const __cliNodeMajor = Number(process.versions.node.split('.')[0]);
 if (__cliNodeMajor < 20) {
   console.error(`powerplant needs Node 20 or newer — this is Node ${process.versions.node}.`);
@@ -56698,12 +56700,13 @@ function boundRedactedText(raw, maxBytes) {
   return boundText(redactSecrets(raw), maxBytes);
 }
 function boundText(redacted, maxBytes) {
-  const bytes = utf8Encoder.encode(redacted);
+  const text = redacted.includes("\0") ? redacted.replaceAll("\0", "\uFFFD") : redacted;
+  const bytes = utf8Encoder.encode(text);
   if (bytes.length <= maxBytes) {
-    return { text: redacted, truncated: false, originalBytes: bytes.length };
+    return { text, truncated: false, originalBytes: bytes.length };
   }
-  const text = utf8Decoder.decode(bytes.subarray(0, maxBytes)).replace(/�+$/u, "");
-  return { text, truncated: true, originalBytes: bytes.length };
+  const cut = utf8Decoder.decode(bytes.subarray(0, maxBytes)).replace(/�+$/u, "");
+  return { text: cut, truncated: true, originalBytes: bytes.length };
 }
 
 // ../core/src/codeHost.ts
@@ -56755,18 +56758,35 @@ function pullRequestRefsInText(text) {
   }
   return refs;
 }
+var PULL_REQUEST_ALREADY_EXISTS = /a pull request for branch \S+ into branch \S+ already exists:/;
+function pullRequestAlreadyExistsInText(text) {
+  return PULL_REQUEST_ALREADY_EXISTS.test(text);
+}
 function pullRequestRefFromUrl(url2) {
   return pullRequestRefsInText(url2)[0] ?? null;
 }
 var MAY_TOUCH_HOST = /\b(?:git|gh)\b/;
 function readCodeHostCommands(command, currentBranch) {
+  return readCommands(command, currentBranch, 0);
+}
+var SUBSTITUTION_DEPTH_MAX = 4;
+function readCommands(command, currentBranch, depth) {
   const result = { pushes: [], pullRequestCreates: [] };
   if (!MAY_TOUCH_HOST.test(command)) return result;
   const chain = shellCommands(command);
   let branch = currentBranch;
   chain.forEach((simple, i) => {
     const program = programOf(simple.words);
-    if (program === null) return;
+    if (program === null) {
+      if (depth >= SUBSTITUTION_DEPTH_MAX) return;
+      const alone = simple.words.length === 1 && simple.next === null;
+      for (const substituted of simple.assignedSubstitutions) {
+        for (const create of readCommands(substituted, branch, depth + 1).pullRequestCreates) {
+          result.pullRequestCreates.push({ ...create, ownExitStatus: create.ownExitStatus && alone });
+        }
+      }
+      return;
+    }
     if (program.name === "git") {
       const git = gitSubcommand(program.args);
       if (git === null) return;
@@ -56799,6 +56819,7 @@ function pushOutcomeInText(text, branch) {
   return /Everything up-to-date/.test(text) ? true : null;
 }
 var ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var ASSIGNMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*=$/;
 function programOf(words) {
   let i = 0;
   while (i < words.length && (ENV_ASSIGNMENT.test(words[i]) || words[i] === "env")) i += 1;
@@ -56895,6 +56916,7 @@ function exitStatusIsOwn(chain, index) {
 function shellCommands(text) {
   const commands = [];
   let words = [];
+  let assignedSubstitutions = [];
   let word = "";
   let inWord = false;
   let quote = null;
@@ -56906,8 +56928,9 @@ function shellCommands(text) {
   };
   const endCommand = (next) => {
     endWord();
-    if (words.length > 0) commands.push({ words: withoutRedirections(words), next });
+    if (words.length > 0) commands.push({ words: withoutRedirections(words), assignedSubstitutions, next });
     words = [];
+    assignedSubstitutions = [];
   };
   for (let i = 0; i < text.length; i++) {
     const ch = text[i];
@@ -56927,6 +56950,11 @@ function shellCommands(text) {
       inWord = true;
     } else if (ch === "$" && text[i + 1] === "(" || ch === "`") {
       const end = substitutionEnd(text, i);
+      const after = text[end + 1];
+      const endsWord = after === void 0 || /[\s;&|)]/.test(after);
+      if (ch === "$" && text[end] === ")" && ASSIGNMENT_NAME.test(word) && endsWord) {
+        assignedSubstitutions.push(text.slice(i + 2, end));
+      }
       word += text.slice(i, end + 1);
       inWord = true;
       i = end;
@@ -57037,6 +57065,9 @@ var PrEvidenceCollector = class {
   evidence = [];
   seen = /* @__PURE__ */ new Set();
   watched = /* @__PURE__ */ new Map();
+  /** By process id: what a watched call left unsettled when its result said
+   * the process still runs. */
+  running = /* @__PURE__ */ new Map();
   dropped = 0;
   /** The harness recorded the pull request for this session. Repeats (a
    * record per turn while a PR stays bound) keep the first time. */
@@ -57045,15 +57076,50 @@ var PrEvidenceCollector = class {
   }
   /** A shell command the session ran: watched until its result arrives when
    * it pushes a branch or creates a pull request, ignored otherwise. */
-  command(callId, command, currentBranch) {
-    this.watch(callId, readCodeHostCommands(command, currentBranch));
+  command(callId, command, currentBranch, startedAt = null) {
+    this.watch(callId, readCodeHostCommands(command, currentBranch), startedAt);
   }
   /** A tool call that would push or create a pull request, in the code host
    * adapter's terms (a harness's own pull request tool, for example). */
-  watch(callId, commands) {
+  watch(callId, commands, startedAt = null) {
     if (commands.pushes.length === 0 && commands.pullRequestCreates.length === 0) return;
-    this.watched.set(callId, commands);
-    if (this.watched.size > WATCHED_CALLS_MAX) this.watched.delete(this.watched.keys().next().value);
+    keepBounded(this.watched, callId, { ...commands, startedAt });
+  }
+  /** A call that reads more output of a running process (Codex's
+   * write_stdin poll; Claude Code's TaskOutput, or a read of a background
+   * task's output file): its result is read as the rest of the watched call
+   * that started the process. */
+  follow(callId, process2) {
+    const unsettled = this.running.get(process2);
+    if (unsettled === void 0) return;
+    this.running.delete(process2);
+    this.watch(callId, unsettled, unsettled.startedAt);
+  }
+  /** Whether any process is followed, so a parser reads an unwatched
+   * call's output only while it could matter. */
+  following() {
+    return this.running.size > 0;
+  }
+  /** Another call now runs a process under this id: a later poll of the id
+   * is no longer the rest of the watched call that left it running. */
+  forget(process2) {
+    this.running.delete(process2);
+  }
+  /** Watches several watched calls as one, in the order given: the parts of
+   * a call whose output cannot be told apart, read once as a whole. The
+   * parts are one call's, so they started together and the first part's
+   * time is the whole's. */
+  merge(callIds, into) {
+    const parts = callIds.flatMap((callId) => this.watched.get(callId) ?? []);
+    for (const callId of callIds) this.watched.delete(callId);
+    this.watch(
+      into,
+      {
+        pushes: parts.flatMap((part) => part.pushes),
+        pullRequestCreates: parts.flatMap((part) => part.pullRequestCreates)
+      },
+      parts[0]?.startedAt ?? null
+    );
   }
   watching(callId) {
     return this.watched.has(callId);
@@ -57070,7 +57136,16 @@ var PrEvidenceCollector = class {
    * result names the pull request: gh prints the created PR's URL last, so
    * a call with one creation takes the last URL and a call with several
    * only when the text names exactly as many; a failed call whose status
-   * is the creation's own counts nothing.
+   * is the creation's own counts nothing, and neither does a call whose
+   * text carries gh's refusal because the pull request exists (the URL it
+   * prints is that pull request's, and a result read from a file states no
+   * status). A text cut to the URL alone (`| tail -1`, a `grep` of the
+   * output file) hides the refusal, and the URL then counts.
+   *
+   * When the result says one process still runs, whatever it settled
+   * neither way waits for that process's later output (`follow`). A push
+   * git rejected, or a command whose own status failed, is settled: a
+   * later output never revives it.
    */
   result(callId, outcome) {
     const commands = this.watched.get(callId);
@@ -57079,35 +57154,45 @@ var PrEvidenceCollector = class {
     const destinations = pushDestinationsInText(outcome.text);
     const oneRemote = new Set(commands.pushes.map((push) => push.remote)).size === 1;
     const shared = oneRemote && new Set(destinations).size === 1 ? destinations[0] : null;
+    const unsettled = { pushes: [], pullRequestCreates: [], startedAt: commands.startedAt };
     for (const [i, push] of commands.pushes.entries()) {
       if (push.branch === null) continue;
-      const pushed = pushOutcomeInText(outcome.text, push.branch) ?? (push.ownExitStatus && outcome.succeeded === true);
-      if (!pushed) continue;
+      const pushed = pushOutcomeInText(outcome.text, push.branch) ?? (push.ownExitStatus ? outcome.succeeded : null);
+      if (pushed === null) unsettled.pushes.push(push);
+      if (pushed !== true) continue;
       const repository = destinations.length === commands.pushes.length ? destinations[i] : shared;
       this.addPush({ kind: "branch-pushed", at: outcome.at, prId: null, repository, branch: push.branch, line: outcome.line });
     }
     const creates = commands.pullRequestCreates;
-    if (creates.length === 0) return;
     const refs = pullRequestRefsInText(outcome.text);
     const paired = creates.length === 1 ? [refs.at(-1)] : refs.length === creates.length ? refs : [];
+    const refused = pullRequestAlreadyExistsInText(outcome.text);
     creates.forEach((create, i) => {
       const ref = paired[i];
-      if (ref === void 0 || outcome.succeeded === false && create.ownExitStatus) return;
+      if (refused || outcome.succeeded === false && create.ownExitStatus) return;
+      if (ref === void 0) {
+        unsettled.pullRequestCreates.push(create);
+        return;
+      }
       this.add({
         kind: "pull-request-created",
         at: outcome.at,
         prId: pullRequestId(ref),
         repository: null,
         branch: create.head,
-        line: outcome.line
+        line: outcome.line,
+        commandStartedAt: commands.startedAt
       });
     });
+    if (outcome.running === null || unsettled.pushes.length === 0 && unsettled.pullRequestCreates.length === 0) return;
+    keepBounded(this.running, outcome.running, unsettled);
   }
   /** The evidence collected, in transcript order, with pushes past the cap
-   * dropped oldest first. Calls still watched are dropped: their results
-   * never arrived. */
+   * dropped oldest first. Calls still watched and processes still followed
+   * are dropped: their results never arrived. */
   finish() {
     this.watched.clear();
+    this.running.clear();
     const pushes = this.evidence.filter((item) => item.kind === "branch-pushed");
     if (pushes.length <= PUSH_EVIDENCE_MAX) return this.evidence;
     const cut = new Set(pushes.slice(0, pushes.length - PUSH_EVIDENCE_MAX));
@@ -57119,10 +57204,13 @@ var PrEvidenceCollector = class {
   droppedPushes() {
     return this.dropped;
   }
-  /** A link or a creation is one fact per pull request: repeats keep the
-   * first. */
+  /** A link is one fact per pull request, and so is a creation per command:
+   * repeats keep the first. Two commands that each named the pull request
+   * are two facts (a refused retry read before the first command's own
+   * output), because the match keeps only the one whose command can have
+   * opened it. */
   add(item) {
-    const key = `${item.kind}|${item.prId ?? ""}|${item.branch ?? ""}`;
+    const key = `${item.kind}|${item.prId ?? ""}|${item.branch ?? ""}|${item.commandStartedAt ?? ""}`;
     if (this.seen.has(key)) return;
     this.seen.add(key);
     this.evidence.push(item);
@@ -57136,6 +57224,11 @@ var PrEvidenceCollector = class {
     this.evidence.push(item);
   }
 };
+function keepBounded(map2, key, value) {
+  map2.delete(key);
+  map2.set(key, value);
+  if (map2.size > WATCHED_CALLS_MAX) map2.delete(map2.keys().next().value);
+}
 
 // ../core/src/digest.ts
 var TOOL_CALL_INPUT_MAX_BYTES = 65536;
@@ -57155,6 +57248,7 @@ function createDigestTurnParser(options = {}) {
   let pendingEnvelopes = [];
   let currentEnvelope = null;
   const evidence = new PrEvidenceCollector();
+  const backgroundTasks = { started: /* @__PURE__ */ new Map(), reads: /* @__PURE__ */ new Map() };
   let line = -1;
   const landPending = (turn) => {
     for (const envelope of pendingEnvelopes) {
@@ -57184,7 +57278,7 @@ function createDigestTurnParser(options = {}) {
       if (record2.isMeta === true) return;
       const at = recordTime(record2);
       if (record2.type === "user") {
-        toolResults(record2, evidence, line);
+        toolResults(record2, evidence, backgroundTasks, line);
         const text = userText(record2);
         if (text) {
           const origin = claudeCodeMessageOrigin(originFacts(record2), text);
@@ -57233,8 +57327,9 @@ function createDigestTurnParser(options = {}) {
           }
           pendingTools.push(call);
           if (part.name === "Bash" && typeof part.id === "string" && typeof part.input?.command === "string") {
-            evidence.command(part.id, part.input.command, recordBranch(record2));
+            evidence.command(part.id, part.input.command, recordBranch(record2), at);
           }
+          if (typeof part.id === "string") followBackgroundTask(part.id, part.name, part.input, evidence, backgroundTasks);
         }
         if (part.type === "text" && typeof part.text === "string" && part.text.trim() !== "") {
           const origin = claudeCodeMessageOrigin(facts, part.text);
@@ -57311,16 +57406,38 @@ function isRecord(value) {
 function recordBranch(record2) {
   return typeof record2.gitBranch === "string" && record2.gitBranch !== "" ? record2.gitBranch : null;
 }
-function toolResults(record2, evidence, line) {
+function followBackgroundTask(callId, tool, input2, evidence, tasks) {
+  if (tasks.started.size === 0 || evidence.watching(callId)) return;
+  const named = tool === "TaskOutput" ? input2?.task_id : tool === "Read" ? input2?.file_path : tool === "Bash" ? input2?.command : void 0;
+  if (typeof named !== "string" || tool === "Bash" && RUNS_GH.test(named)) return;
+  const read = new Set(
+    [...tasks.started].filter(([task]) => tool === "TaskOutput" ? named === task : named.includes(`/${task}.output`)).map(([, followed2]) => followed2)
+  );
+  if (read.size !== 1) return;
+  const [followed] = read;
+  evidence.follow(callId, followed);
+  if (evidence.watching(callId)) keepBounded(tasks.reads, callId, followed);
+}
+var RUNS_GH = /(?:^|[\s;&|(])gh\s/;
+function toolResults(record2, evidence, tasks, line) {
   const content = isRecord(record2.message) ? record2.message.content : void 0;
   if (!Array.isArray(content)) return;
   const result = isRecord(record2.toolUseResult) ? record2.toolUseResult : {};
+  const file2 = isRecord(result.file) ? result.file : {};
+  const task = isRecord(result.task) ? result.task : {};
   for (const block of content) {
     if (!isRecord(block) || block.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
     if (!evidence.watching(block.tool_use_id)) continue;
+    const reads = tasks.reads.get(block.tool_use_id);
+    tasks.reads.delete(block.tool_use_id);
+    const started = typeof result.backgroundTaskId === "string" ? result.backgroundTaskId : null;
+    if (started !== null) keepBounded(tasks.started, started, reads ?? started);
+    const failed2 = block.is_error === true || result.interrupted === true;
+    const taskExited = typeof task.exitCode === "number" && task.task_id === reads;
+    const status = reads !== void 0 ? { succeeded: taskExited ? task.exitCode === 0 : null, running: taskExited ? null : reads } : { succeeded: failed2 ? false : started !== null ? null : true, running: started };
     evidence.result(block.tool_use_id, {
-      succeeded: block.is_error !== true && result.interrupted !== true && result.backgroundTaskId === void 0,
-      text: [result.stdout, result.stderr].filter((part) => typeof part === "string").concat(contentText(block.content)).join("\n"),
+      ...status,
+      text: [result.stdout, result.stderr, file2.content, task.output].filter((part) => typeof part === "string").concat(contentText(block.content)).join("\n"),
       at: recordTime(record2),
       line
     });
@@ -57988,6 +58105,8 @@ function createCodexTurnParser(options = {}) {
   let pendingTools = [];
   let pendingAt = null;
   const evidence = new PrEvidenceCollector();
+  const scripts = /* @__PURE__ */ new Map();
+  const runningScripts = /* @__PURE__ */ new Map();
   let line = -1;
   const envelopes = [];
   let pendingEnvelopes = [];
@@ -58047,9 +58166,24 @@ function createCodexTurnParser(options = {}) {
       const responseItem = item;
       const callId = typeof responseItem.call_id === "string" ? responseItem.call_id : null;
       if (callId !== null && isToolOutput(responseItem)) {
-        if (evidence.watching(callId)) {
+        const script = scripts.get(callId);
+        scripts.delete(callId);
+        if (script !== void 0) {
+          const [header = "", ...blocks] = outputBlocks(responseItem.output);
+          const cell = SCRIPT_STILL_RUNNING.exec(header)?.[1];
+          if (cell === void 0) scriptResult(evidence, script, header, blocks, at, line);
+          else keepBounded(runningScripts, cell, script);
+        } else if (evidence.watching(callId)) {
           const text2 = contentText(responseItem.output);
-          evidence.result(callId, { succeeded: codexExitStatus(text2), text: text2, at, line });
+          evidence.result(callId, { succeeded: codexExitStatus(text2), text: text2, running: codexRunningProcess(text2), at, line });
+        } else if (runningScripts.size > 0 || evidence.following()) {
+          const [header = "", ...blocks] = outputBlocks(responseItem.output);
+          const cell = SCRIPT_STILL_RUNNING.exec(header)?.[1];
+          if (cell !== void 0) runningScripts.delete(cell);
+          for (const text2 of [header, ...blocks]) {
+            const process2 = codexRunningProcess(text2);
+            if (process2 !== null) evidence.forget(process2);
+          }
         }
         return;
       }
@@ -58062,7 +58196,10 @@ function createCodexTurnParser(options = {}) {
         }
         pendingTools.push(call);
         pendingAt ??= at;
-        if (callId !== null) watchCodexCall(evidence, callId, responseItem);
+        if (callId !== null) {
+          const script = watchCodexCall(evidence, callId, responseItem, at, runningScripts);
+          if (script !== null) keepBounded(scripts, callId, script);
+        }
         return;
       }
       if (responseItem.type !== "message") return;
@@ -58105,27 +58242,76 @@ function createCodexTurnParser(options = {}) {
     }
   };
 }
-function watchCodexCall(evidence, callId, item) {
+var stepKey = (callId, step) => `${callId}#${step}`;
+function watchCodexCall(evidence, callId, item, at, runningScripts) {
   if (item.type === "custom_tool_call" && item.name === "exec" && typeof item.input === "string") {
-    evidence.command(callId, execCommandStrings(item.input).join("\n"), null);
-    return;
+    const steps = execScriptSteps(item.input);
+    const commands = [];
+    let seen = { pushes: 0, pullRequestCreates: 0 };
+    steps.forEach((step, i) => {
+      if (step.polls !== null) evidence.follow(stepKey(callId, i), step.polls);
+      if (step.command === null) return;
+      commands.push(step.command);
+      const read = readCodeHostCommands(commands.join("\n"), null);
+      evidence.watch(
+        stepKey(callId, i),
+        {
+          pushes: read.pushes.slice(seen.pushes),
+          pullRequestCreates: read.pullRequestCreates.slice(seen.pullRequestCreates)
+        },
+        at
+      );
+      seen = { pushes: read.pushes.length, pullRequestCreates: read.pullRequestCreates.length };
+    });
+    const watched = steps.some((_, i) => evidence.watching(stepKey(callId, i)));
+    return watched ? { callId, polls: steps.map((step) => step.polls), printsEachStep: printsEachStep(item.input, steps) } : null;
   }
   if (item.type === "local_shell_call") {
     const command = argvCommand(asRecord2(item.action)?.command);
-    if (command !== null) evidence.command(callId, command, null);
-    return;
+    if (command !== null) evidence.command(callId, command, null, at);
+    return null;
   }
-  if (item.type !== "function_call" || typeof item.arguments !== "string") return;
+  if (item.type !== "function_call" || typeof item.arguments !== "string") return null;
   const args = safeJsonRecord(item.arguments);
   if (item.name === "exec_command" && typeof args?.cmd === "string") {
-    evidence.command(callId, args.cmd, null);
+    evidence.command(callId, args.cmd, null, at);
   } else if (item.name === "shell") {
     const command = argvCommand(args?.command);
-    if (command !== null) evidence.command(callId, command, null);
+    if (command !== null) evidence.command(callId, command, null, at);
+  } else if (item.name === "write_stdin" && typeof args?.session_id === "number") {
+    evidence.follow(callId, String(args.session_id));
+  } else if (item.name === "wait" && (typeof args?.cell_id === "string" || typeof args?.cell_id === "number")) {
+    const script = runningScripts.get(String(args.cell_id)) ?? null;
+    runningScripts.delete(String(args.cell_id));
+    return script;
   } else if (item.name === "_create_pull_request") {
     const head = typeof args?.head === "string" ? args.head : null;
-    evidence.watch(callId, { pushes: [], pullRequestCreates: [{ head, ownExitStatus: true }] });
+    evidence.watch(callId, { pushes: [], pullRequestCreates: [{ head, ownExitStatus: true }] }, at);
   }
+  return null;
+}
+function scriptResult(evidence, script, header, blocks, at, line) {
+  const paired = script.printsEachStep && blocks.length === script.polls.length;
+  const keys = script.polls.map((_, i) => stepKey(script.callId, i));
+  if (!paired) {
+    evidence.merge(keys.filter((_, i) => script.polls[i] === null), script.callId);
+    evidence.result(script.callId, { succeeded: null, text: [header, ...blocks].join("\n"), running: null, at, line });
+  }
+  script.polls.forEach((polls, i) => {
+    if (!evidence.watching(keys[i])) return;
+    const text = paired ? blocks[i] : "";
+    const succeeded = paired ? codexExitStatus(text) : null;
+    const running = (paired ? codexRunningProcess(text) : null) ?? (succeeded === null ? polls : null);
+    evidence.result(keys[i], { succeeded, text, running, at, line });
+  });
+}
+function outputBlocks(output2) {
+  if (typeof output2 === "string") return [output2];
+  if (!Array.isArray(output2)) return [];
+  return output2.map((block) => {
+    const text = asRecord2(block)?.text;
+    return typeof text === "string" ? text : "";
+  });
 }
 function argvCommand(argv) {
   if (typeof argv === "string") return argv;
@@ -58134,22 +58320,56 @@ function argvCommand(argv) {
   if (argv.length === 3 && /(?:^|\/)(?:ba|z|da|k)?sh$/.test(shell) && /^-[a-z]*c[a-z]*$/.test(flag)) return script;
   return argv.map((word) => /^[A-Za-z0-9._/:=@+-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`).join(" ");
 }
-var EXEC_COMMAND_CALL = /exec_command\(\{\s*"?cmd"?\s*:\s*("(?:[^"\\]|\\.)*")/g;
-function execCommandStrings(script) {
-  const commands = [];
-  for (const match of script.matchAll(EXEC_COMMAND_CALL)) {
-    try {
-      const parsed = JSON.parse(match[1]);
-      if (typeof parsed === "string") commands.push(parsed);
-    } catch {
-      continue;
-    }
+var SCRIPT_TOOL_CALL = /tools\.(\w+)\(/g;
+var COMMAND_ARGUMENT = /\{\s*"?cmd"?\s*:\s*("(?:[^"\\]|\\.)*")/y;
+var SESSION_ARGUMENT = /\{\s*"?session_id"?\s*:\s*(\d+)/y;
+function execScriptSteps(script) {
+  const steps = [];
+  const call = new RegExp(SCRIPT_TOOL_CALL);
+  for (let match = call.exec(script); match !== null; match = call.exec(script)) {
+    const argument = match[1] === "exec_command" ? COMMAND_ARGUMENT : match[1] === "write_stdin" ? SESSION_ARGUMENT : null;
+    if (argument !== null) argument.lastIndex = call.lastIndex;
+    const value = argument?.exec(script) ?? null;
+    if (value !== null) call.lastIndex += value[0].length;
+    steps.push({
+      command: value !== null && match[1] === "exec_command" ? jsonString(value[1]) : null,
+      polls: value !== null && match[1] === "write_stdin" ? value[1] : null
+    });
+  }
+  return steps;
+}
+var STRING_LITERAL = /"(?:[^"\\]|\\.)*"/g;
+var TEXT_CALL = /\btext\(/g;
+var TEXT_OF_TOOL_CALL = /\btext\(\s*await\s+tools\.\w+\(/g;
+var DEFERRED_CODE = /\bfunction\b|=>|\.then\(/;
+function printsEachStep(script, steps) {
+  if (steps.length === 1) return true;
+  const code = script.replace(STRING_LITERAL, '""');
+  if (DEFERRED_CODE.test(code)) return false;
+  const printed = [...code.matchAll(TEXT_OF_TOOL_CALL)].length;
+  return printed === steps.length && [...code.matchAll(TEXT_CALL)].length === steps.length;
+}
+function jsonString(literal2) {
+  try {
+    const parsed = JSON.parse(literal2);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return null;
   }
-  return commands;
 }
 function isToolOutput(item) {
   return item.type === "custom_tool_call_output" || item.type === "function_call_output" || item.type === "local_shell_call_output";
 }
+var SCRIPT_STILL_RUNNING = /^Script running with cell ID (\d+)/;
+var RUNNING_CHUNK = /^\s*\{[^\n]*?"session_id"\s*:\s*(\d+)/;
+var RUNNING_PROCESS_LINE = /^Process running with session ID (\d+)$/m;
+function codexRunningProcess(output2) {
+  const chunk = RUNNING_CHUNK.exec(output2);
+  if (chunk !== null) return chunk[1];
+  const outputLine = output2.search(/^Output:/m);
+  const header = outputLine === -1 ? output2 : output2.slice(0, outputLine);
+  return RUNNING_PROCESS_LINE.exec(header)?.[1] ?? null;
+}
 var EXIT_STATUS = /"exit_code"\s*:\s*(\d+)|Process exited with code (\d+)/g;
 function codexExitStatus(output2) {
   const codes = [...output2.matchAll(EXIT_STATUS)].map((match) => Number(match[1] ?? match[2]));
@@ -85730,7 +85950,7 @@ import { createHmac } from "node:crypto";
 // ../../apps/collector/src/http.ts
 var import_undici = __toESM(require_undici(), 1);
 var CLI_VERSION_HEADER = "x-powerplant-cli-version";
-var cliVersion = true ? "0.4.11" : "0.0.0-checkout";
+var cliVersion = true ? "0.4.12" : "0.0.0-checkout";
 function cliVersionHeaders() {
   return { [CLI_VERSION_HEADER]: cliVersion, "user-agent": `powerplant-cli/${cliVersion}` };
 }
@@ -86575,9 +86795,9 @@ var MergedSpoolWriter = class {
   tmpPath;
   fd;
   bytes = 0;
-  append(pageText) {
+  append(pageText2) {
     if (this.fd === void 0) throw new Error("merged transcript already closed");
-    const text = pageText.endsWith("\n") ? pageText : `${pageText}
+    const text = pageText2.endsWith("\n") ? pageText2 : `${pageText2}
 `;
     this.bytes += writeSync(this.fd, text);
   }
@@ -91861,7 +92081,7 @@ function belowVersionFloor(client, versionText) {
 }
 
 // src/connect.ts
-var MCP_SERVER_NAME = "powerplant";
+var mcpServerNameFor = (appEnv) => appEnv === "production" ? "powerplant" : `powerplant-${appEnv}`;
 var AGENT_DISPLAY_NAMES = {
   claude: "Claude Code",
   codex: "Codex",
@@ -92298,7 +92518,7 @@ function realCheckboxPrompt(question, choices, seams = {}) {
 function claudeAddArgs(deps) {
   const official = deps.officialClients?.["claude-code"];
   const credentialArgs = official ? ["--client-id", official.clientId, "--callback-port", String(official.callbackPort)] : [];
-  return ["mcp", "add", "--transport", "http", "--scope", "user", ...credentialArgs, MCP_SERVER_NAME, deps.mcpUrl];
+  return ["mcp", "add", "--transport", "http", "--scope", "user", ...credentialArgs, deps.serverName, deps.mcpUrl];
 }
 function parseClaudeProbe(result) {
   const output2 = result.stdout + result.stderr;
@@ -92319,7 +92539,7 @@ function claudeEnv(client) {
 function connectClaude(client, name, deps) {
   const { bin } = client;
   const env = claudeEnv(client);
-  const probe = parseClaudeProbe(deps.run(bin, ["mcp", "get", MCP_SERVER_NAME], env));
+  const probe = parseClaudeProbe(deps.run(bin, ["mcp", "get", deps.serverName], env));
   if (probe.broken) {
     return failed(`probing for the Powerplant MCP failed, ${probe.detail}`);
   }
@@ -92327,7 +92547,7 @@ function connectClaude(client, name, deps) {
   if (missing || registeredUrl !== void 0 && registeredUrl !== deps.mcpUrl) {
     if (!missing) {
       deps.log(`${name}: registered against ${registeredUrl}, re-registering for ${deps.mcpUrl}.`);
-      deps.run(bin, ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME], env);
+      deps.run(bin, ["mcp", "remove", "--scope", "user", deps.serverName], env);
     }
     const add = deps.run(bin, claudeAddArgs(deps), env);
     if (add.status !== 0) {
@@ -92339,7 +92559,7 @@ function connectClaude(client, name, deps) {
     return { state: "connected", unchanged: true };
   } else if (deps.officialClients?.["claude-code"]) {
     deps.log(`${name}: re-registering with the pre-registered client before sign-in.`);
-    deps.run(bin, ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME], env);
+    deps.run(bin, ["mcp", "remove", "--scope", "user", deps.serverName], env);
     const add = deps.run(bin, claudeAddArgs(deps), env);
     if (add.status !== 0) {
       return failed(`registering the Powerplant MCP failed, ${describeFailure(add)}`);
@@ -92347,7 +92567,7 @@ function connectClaude(client, name, deps) {
   } else {
     deps.log(`${name}: Powerplant MCP already registered.`);
   }
-  return login(bin, name, ["mcp", "login", MCP_SERVER_NAME], deps, env);
+  return login(bin, name, ["mcp", "login", deps.serverName], deps, env);
 }
 function codexOauthHeaderPattern(serverName) {
   return new RegExp(
@@ -92514,7 +92734,7 @@ function parseCodexServers(stdout) {
   }
 }
 var CODEX_AUTHENTICATED_STATUSES = /* @__PURE__ */ new Set(["o_auth", "bearer_token"]);
-function parseCodexProbe(result) {
+function parseCodexProbe(result, serverName) {
   if (result.status !== 0) {
     return {
       broken: true,
@@ -92532,7 +92752,7 @@ function parseCodexProbe(result) {
       authenticated: false
     };
   }
-  const existing = servers.find((server) => server.name === MCP_SERVER_NAME);
+  const existing = servers.find((server) => server.name === serverName);
   if (!existing) return { broken: false, missing: true, authenticated: false };
   return {
     broken: false,
@@ -92544,7 +92764,7 @@ function parseCodexProbe(result) {
 function codexAddArgs(deps, options) {
   const official = deps.officialClients?.codex;
   const credentialArgs = options.withOfficialClientId && official ? ["--oauth-client-id", official.clientId] : [];
-  return ["mcp", "add", MCP_SERVER_NAME, ...credentialArgs, "--url", deps.mcpUrl];
+  return ["mcp", "add", deps.serverName, ...credentialArgs, "--url", deps.mcpUrl];
 }
 function codexAddLogsIn(bin, deps) {
   const help = deps.run(bin, ["mcp", "add", "--help"]);
@@ -92559,9 +92779,9 @@ function codexServerEntryPattern(serverName) {
 function healOrphanCodexOauthTable(name, deps) {
   const existing = deps.readTextFile(deps.codexConfigPath);
   if (existing === null) return;
-  if (!codexOauthHeaderPattern(MCP_SERVER_NAME).test(existing)) return;
-  if (codexServerEntryPattern(MCP_SERVER_NAME).test(existing)) return;
-  const { content, changed } = unpatchCodexConfigToml(existing, MCP_SERVER_NAME);
+  if (!codexOauthHeaderPattern(deps.serverName).test(existing)) return;
+  if (codexServerEntryPattern(deps.serverName).test(existing)) return;
+  const { content, changed } = unpatchCodexConfigToml(existing, deps.serverName);
   if (!changed) return;
   deps.writeTextFile(deps.codexConfigPath, content);
   deps.log(
@@ -92570,7 +92790,7 @@ function healOrphanCodexOauthTable(name, deps) {
 }
 function connectCodex(bin, name, deps) {
   healOrphanCodexOauthTable(name, deps);
-  const probe = parseCodexProbe(deps.run(bin, ["mcp", "list", "--json"]));
+  const probe = parseCodexProbe(deps.run(bin, ["mcp", "list", "--json"]), deps.serverName);
   if (probe.broken) {
     return failed(probe.detail ?? "probing for the Powerplant MCP failed");
   }
@@ -92597,7 +92817,7 @@ function connectCodex(bin, name, deps) {
   }
   ensureCodexOfficialClient(name, deps);
   if (alreadyConnected) return { state: "connected", unchanged: true };
-  return login(bin, name, ["mcp", "login", MCP_SERVER_NAME], deps);
+  return login(bin, name, ["mcp", "login", deps.serverName], deps);
 }
 function applyCodexConfigPatch(name, deps, patch, successLine) {
   if (patch.conflict !== void 0) {
@@ -92629,7 +92849,7 @@ function ensureCodexOfficialClient(name, deps) {
     deps,
     patchCodexConfigToml(
       deps.readTextFile(deps.codexConfigPath),
-      MCP_SERVER_NAME,
+      deps.serverName,
       official.clientId,
       official.callbackPort
     ),
@@ -92640,7 +92860,7 @@ function connectCursor(mcpJsonPath, name, deps) {
   const official = deps.officialClients?.cursor;
   const patch = patchCursorMcpJson(
     deps.readTextFile(mcpJsonPath),
-    MCP_SERVER_NAME,
+    deps.serverName,
     deps.mcpUrl,
     official?.clientId ?? null
   );
@@ -92651,12 +92871,12 @@ function connectCursor(mcpJsonPath, name, deps) {
   }
   if (patch.changed) deps.writeTextFile(mcpJsonPath, patch.content);
   const configured = patch.changed ? "configured" : "already configured";
-  if (deps.openUrl(cursorInstallDeeplink(MCP_SERVER_NAME, patch.entry))) {
+  if (deps.openUrl(cursorInstallDeeplink(deps.serverName, patch.entry))) {
     deps.log(`\u2192 ${name}  ${configured}, approve inside Cursor when it asks.`);
     return { state: "configured", unchanged: !patch.changed };
   }
   deps.log(
-    `\u2192 ${name}  ${configured}, could not open Cursor; in Cursor's MCP settings, enable the powerplant server and sign in.`
+    `\u2192 ${name}  ${configured}, could not open Cursor; in Cursor's MCP settings, enable the ${deps.serverName} server and sign in.`
   );
   return { state: "pending", unchanged: false };
 }
@@ -92717,7 +92937,7 @@ function disconnectClaude(client, deps) {
   const { bin } = client;
   const name = describeClaudeTarget(client);
   const env = claudeEnv(client);
-  const get = deps.run(bin, ["mcp", "get", MCP_SERVER_NAME], env);
+  const get = deps.run(bin, ["mcp", "get", deps.serverName], env);
   const output2 = get.stdout + get.stderr;
   if (/No MCP server named/i.test(output2)) {
     deps.log(`${name}: not connected.`);
@@ -92727,7 +92947,7 @@ function disconnectClaude(client, deps) {
     deps.log(`\u2717 ${name}: probing for the Powerplant MCP failed, ${describeFailure(get)}`);
     return "failed";
   }
-  const remove = deps.run(bin, ["mcp", "remove", "--scope", "user", MCP_SERVER_NAME], env);
+  const remove = deps.run(bin, ["mcp", "remove", "--scope", "user", deps.serverName], env);
   if (remove.status !== 0) {
     deps.log(`\u2717 ${name}: removing the Powerplant MCP failed, ${describeFailure(remove)}`);
     return "failed";
@@ -92747,15 +92967,15 @@ function disconnectCodex(bin, deps) {
     deps.log(`\u2717 ${name}: could not read its MCP server list, is this codex version very old?`);
     return "failed";
   }
-  const registered = servers.some((server) => server.name === MCP_SERVER_NAME);
-  const patch = unpatchCodexConfigToml(deps.readTextFile(deps.codexConfigPath), MCP_SERVER_NAME);
+  const registered = servers.some((server) => server.name === deps.serverName);
+  const patch = unpatchCodexConfigToml(deps.readTextFile(deps.codexConfigPath), deps.serverName);
   if (patch.changed) deps.writeTextFile(deps.codexConfigPath, patch.content);
   if (!registered) {
     deps.log(`${name}: not connected.`);
     return "notConnected";
   }
-  deps.run(bin, ["mcp", "logout", MCP_SERVER_NAME]);
-  const remove = deps.run(bin, ["mcp", "remove", MCP_SERVER_NAME]);
+  deps.run(bin, ["mcp", "logout", deps.serverName]);
+  const remove = deps.run(bin, ["mcp", "remove", deps.serverName]);
   if (remove.status !== 0) {
     deps.log(`\u2717 ${name}: removing the Powerplant MCP failed, ${describeFailure(remove)}`);
     return "failed";
@@ -92765,9 +92985,9 @@ function disconnectCodex(bin, deps) {
 }
 function disconnectCursor(mcpJsonPath, deps) {
   const name = `Cursor (${mcpJsonPath.replace(os20.homedir(), "~")})`;
-  const patch = unpatchCursorMcpJson(deps.readTextFile(mcpJsonPath), MCP_SERVER_NAME);
+  const patch = unpatchCursorMcpJson(deps.readTextFile(mcpJsonPath), deps.serverName);
   if (patch.error !== void 0) {
-    deps.log(`\u2717 ${name}: mcp.json is ${patch.error}, fix it by hand, then re-run powerplant disconnect.`);
+    deps.log(`\u2717 ${name}: mcp.json is ${patch.error}, fix it by hand, then re-run ${deps.disconnectCommand}.`);
     return "failed";
   }
   if (!patch.changed) {
@@ -92781,15 +93001,15 @@ function disconnectCursor(mcpJsonPath, deps) {
 function anyClientStillConnected(clients, deps) {
   return clients.some((client) => {
     if (client.client === "claude") {
-      const get = deps.run(client.bin, ["mcp", "get", MCP_SERVER_NAME], claudeEnv(client));
+      const get = deps.run(client.bin, ["mcp", "get", deps.serverName], claudeEnv(client));
       return get.status === 0 && !/No MCP server named/i.test(get.stdout + get.stderr);
     }
     if (client.client === "codex") {
       const list = deps.run(client.bin, ["mcp", "list", "--json"]);
       if (list.status !== 0) return false;
-      return parseCodexServers(list.stdout)?.some((server) => server.name === MCP_SERVER_NAME) ?? false;
+      return parseCodexServers(list.stdout)?.some((server) => server.name === deps.serverName) ?? false;
     }
-    const patch = unpatchCursorMcpJson(deps.readTextFile(client.bin), MCP_SERVER_NAME);
+    const patch = unpatchCursorMcpJson(deps.readTextFile(client.bin), deps.serverName);
     return patch.error === void 0 && patch.changed;
   });
 }
@@ -92974,10 +93194,10 @@ function probeClient(client, deps) {
   return report(
     kind,
     kind === "claude" ? parseClaudeProbe(
-      deps.run(bin, ["mcp", "get", MCP_SERVER_NAME], {
+      deps.run(bin, ["mcp", "get", deps.serverName], {
         CLAUDE_CONFIG_DIR: client.configDir
       })
-    ) : parseCodexProbe(deps.run(bin, ["mcp", "list", "--json"])),
+    ) : parseCodexProbe(deps.run(bin, ["mcp", "list", "--json"]), deps.serverName),
     deps.mcpUrl
   );
 }
@@ -93000,7 +93220,7 @@ function probeCursor(mcpJsonPath, deps) {
       detail: error63 instanceof Error ? error63.message : String(error63)
     };
   }
-  const registration = readCursorRegistration(raw, MCP_SERVER_NAME);
+  const registration = readCursorRegistration(raw, deps.serverName);
   if (registration.error !== void 0) {
     return { client: "cursor", state: "check-failed", detail: `mcp.json is ${registration.error}` };
   }
@@ -93158,7 +93378,7 @@ import { accessSync, constants as constants2, readFileSync as readFileSync12 } f
 import path25 from "node:path";
 
 // src/version.ts
-var CLI_VERSION = true ? "0.4.11" : "0.0.0-checkout";
+var CLI_VERSION = true ? "0.4.12" : "0.0.0-checkout";
 var CLI_RELEASE_BUILD = true ? true : false;
 var CLI_PACKAGE_NAME = "@usepowerplant/cli";
 
@@ -95569,6 +95789,7 @@ ${USAGE}`);
     log: log3
   });
   const connectCommand = withEnv("powerplant connect");
+  const disconnectCommand = withEnv("powerplant disconnect");
   const clientFilter = parseClientFilter(values.client);
   const pickerOn = pickerAllowed({
     yes: values.yes,
@@ -95618,6 +95839,7 @@ ${USAGE}`);
     }
     const outcome = runConnect(clients, {
       mcpUrl: `${config2.apiUrl}/mcp`,
+      serverName: mcpServerNameFor(config2.appEnv),
       connectCommand,
       officialClients: await fetchOfficialClients(config2.apiUrl, log3),
       log: log3,
@@ -95705,6 +95927,8 @@ ${USAGE}`);
       }
       const outcome = runDisconnect(clients, {
         log: console.log,
+        serverName: mcpServerNameFor(config2.appEnv),
+        disconnectCommand,
         run: realRun,
         readTextFile: realReadTextFileStrict,
         writeTextFile: realWriteTextFile,
@@ -95837,6 +96061,7 @@ The access you granted these agents stays on your Powerplant account until you r
         oldestSupportedVersion,
         connections: probeConnections(clients, {
           mcpUrl: `${config2.apiUrl}/mcp`,
+          serverName: mcpServerNameFor(config2.appEnv),
           run: runWithPath(probePath, budget),
           readTextFile: realReadTextFileStrict,
           grantedClientIds
@@ -95984,9 +96209,13 @@ The access you granted these agents stays on your Powerplant account until you r
           "Credentials kept, `powerplant init` re-installs without re-enrolling. (--forget deletes them.)"
         );
       }
-      if (anyClientStillConnected(detectClients(), { run: realRun, readTextFile: realReadTextFile })) {
+      if (anyClientStillConnected(detectClients(), {
+        run: realRun,
+        readTextFile: realReadTextFile,
+        serverName: mcpServerNameFor(config2.appEnv)
+      })) {
         console.log(
-          "Your coding agents are still connected to the Powerplant MCP server, remove those connections with: powerplant disconnect"
+          `Your coding agents are still connected to the Powerplant MCP server, remove those connections with: ${disconnectCommand}`
         );
       }
       return;
@@ -96168,3 +96397,5 @@ undici/lib/web/fetch/body.js:
 undici/lib/web/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
+
+//# debugId=7d73a97a-938c-5f0f-8b6b-c4076b82abad

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usepowerplant/cli",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "publishConfig": {
     "access": "public"
   },
@@ -15,7 +15,8 @@
     "powerplant": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map"
   ],
   "engines": {
     "node": ">=20"