@ordewell/core 0.4.3 → 0.4.5

package/dist/index.mjs

@@ -9890,8 +9890,12 @@ var Block = /* @__PURE__ */ ((Block2) => {
   Block2[Block2["IfInteractive"] = 7] = "IfInteractive";
   Block2[Block2["IfHeadlessSession"] = 8] = "IfHeadlessSession";
   Block2[Block2["IfInteractiveVariant"] = 9] = "IfInteractiveVariant";
+  Block2[Block2["IfProjectTrust"] = 10] = "IfProjectTrust";
   return Block2;
 })(Block || {});
+function isInteractive(ctx) {
+  return ctx.interactive ?? !ctx.headless;
+}
 function resolveArgs(manifest, ctx) {
   const args = [];
   const env = {};
@@ -9960,6 +9964,8 @@ function parseBlockOpen(raw) {
       return 8 /* IfHeadlessSession */;
     case "{{if interactiveVariant}}":
       return 9 /* IfInteractiveVariant */;
+    case "{{if projectTrust}}":
+      return 10 /* IfProjectTrust */;
     default:
       return null;
   }
@@ -9981,19 +9987,24 @@ function shouldIncludeBlock(block, ctx) {
     // `--variant` is a headless-only flag: it exists on `opencode run` but not
     // on the interactive TUI, which exits immediately if handed an unknown flag.
     case 6 /* IfVariant */:
-      return !!ctx.thinkingEffort && !!ctx.headless;
+      return !!ctx.thinkingEffort && !isInteractive(ctx);
     // Session-shape blocks: unlike IfHeadless (a permission-flag gate with a
     // plan-mode carve-out), these pick the CLI invocation shape — e.g.
     // opencode's `run` subcommand vs its interactive TUI — so no mode carve-out.
     case 7 /* IfInteractive */:
-      return !ctx.headless;
+      return isInteractive(ctx);
     case 8 /* IfHeadlessSession */:
-      return !!ctx.headless;
+      return !isInteractive(ctx);
     // Interactive counterpart of IfVariant, for runners whose TUI has no
     // variant flag and must receive the variant via env config instead.
     // Requires a provider-prefixed model: the config pins variant per model.
     case 9 /* IfInteractiveVariant */:
-      return !!ctx.thinkingEffort && !!ctx.model?.includes("/") && !ctx.headless;
+      return !!ctx.thinkingEffort && !!ctx.model?.includes("/") && isInteractive(ctx);
+    // Guards the flag/value pair that pre-trusts the workspace directory. The
+    // condition, not the token, is what keeps a bare `-c` out of the args when
+    // there is no cwd to name.
+    case 10 /* IfProjectTrust */:
+      return isInteractive(ctx) && !!ctx.cwd;
     default:
       return true;
   }
@@ -10014,6 +10025,10 @@ function resolveToken(token, manifest, ctx) {
   if (token === "{{model}}") return ctx.model || "";
   if (token === "{{thinkingEffort}}") return ctx.thinkingEffort || "";
   if (token === "{{mode}}") return ctx.mode || "build";
+  if (token === "{{projectTrust}}") {
+    if (!ctx.cwd) return "";
+    return `projects.${JSON.stringify(ctx.cwd)}.trust_level="trusted"`;
+  }
   if (token === "{{feature:thinking}}") {
     return manifest.features.thinkingFlag || "";
   }
@@ -10100,7 +10115,9 @@ function buildRunnerInvocation(opts) {
     thinkingEffort: opts.thinkingEffort,
     modelVariants: opts.modelVariants,
     mode: opts.mode ?? "build",
-    headless: opts.headless
+    headless: opts.headless,
+    interactive: opts.interactive,
+    cwd: opts.cwd
   });
 }
 
@@ -10221,8 +10238,14 @@ var HeadlessRunner = class extends AbstractRunner {
   hasScriptCmd;
   resolvePath;
   launchDeps;
-  /** Session shape when the caller names none; the VS Code runner overrides it to interactive. */
-  defaultHeadless = true;
+  /**
+   * Session shape: a piped subprocess is not a terminal, so runners get their
+   * non-interactive subcommand. The VS Code runner owns a pseudoterminal and
+   * overrides this to true. Autonomy is a separate axis (see `ResolveContext`)
+   * and stays on either way — no surface has a human answering permission
+   * prompts on the orchestrator's behalf.
+   */
+  defaultInteractive = false;
   constructor(deps = {}) {
     super();
     this.spawnImpl = deps.spawnImpl ?? nodeSpawn2;
@@ -10235,7 +10258,7 @@ var HeadlessRunner = class extends AbstractRunner {
   }
   /** Everything up to, but not including, spawning — so a surface that owns its own child reaches the same decisions. */
   async prepareLaunch(opts) {
-    const headless = opts.headless ?? this.defaultHeadless;
+    const interactive = this.defaultInteractive;
     const invocation = buildRunnerInvocation({
       runner: opts.runner,
       prompt: opts.prompt,
@@ -10243,11 +10266,13 @@ var HeadlessRunner = class extends AbstractRunner {
       thinkingEffort: opts.thinkingEffort,
       modelVariants: opts.modelVariants,
       mode: opts.mode,
-      headless,
+      headless: opts.headless ?? true,
+      interactive,
+      cwd: opts.cwd,
       registry: opts.registry
     });
     const manifest = opts.registry?.get(opts.runner)?.manifest;
-    const pty = (manifest?.runner.requiresTty === true || !headless) && this.hasScriptCmd();
+    const pty = (manifest?.runner.requiresTty === true || interactive) && this.hasScriptCmd();
     const resolvedPath = await this.resolvePath();
     const { command, args } = pty ? wrapWithPty(invocation.command, invocation.args) : { command: invocation.command, args: invocation.args };
     return {
@@ -10300,6 +10325,28 @@ function hasTmux(probe = defaultProbe) {
     return false;
   }
 }
+var defaultHasBin = (bin) => {
+  try {
+    execSync2(`${process.platform === "win32" ? "where" : "which"} ${bin}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platform, env = process.env) {
+  const candidates = platform === "darwin" ? [["pbcopy", "pbcopy"]] : platform === "win32" ? [["clip.exe", "clip.exe"]] : [
+    // Only prefer wl-copy when there is a Wayland display to talk to —
+    // on X11 it is often installed but fails at copy time.
+    ...env.WAYLAND_DISPLAY ? [["wl-copy", "wl-copy"]] : [],
+    ["xclip", "xclip -selection clipboard"],
+    ["xsel", "xsel --clipboard --input"],
+    ["wl-copy", "wl-copy"]
+  ];
+  for (const [bin, command] of candidates) {
+    if (hasBin(bin)) return command;
+  }
+  return null;
+}
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
@@ -10409,6 +10456,7 @@ var TmuxRunner = class extends AbstractRunner {
   resolvePath;
   pollIntervalMs;
   logDir;
+  clipboardCommand;
   /** Retries get a freshly named window so a failed attempt's output stays inspectable. */
   attempts = /* @__PURE__ */ new Map();
   ready = null;
@@ -10420,6 +10468,7 @@ var TmuxRunner = class extends AbstractRunner {
     this.resolvePath = deps.resolvePath ?? augmentedPath;
     this.pollIntervalMs = deps.pollIntervalMs ?? 500;
     this.logDir = deps.logDir ?? tmpdir();
+    this.clipboardCommand = deps.clipboardCommand ?? (() => clipboardCopyCommand());
   }
   /**
    * Reaps a session orphaned by a crashed prior daemon on the same port, then
@@ -10448,25 +10497,44 @@ var TmuxRunner = class extends AbstractRunner {
     await this.configureScrolling();
   }
   /**
-   * Makes an attached runner terminal scrollable with the mouse wheel and
-   * Page Up/Down. A fresh tmux session ships with `mouse off`, a 2000-line
-   * scrollback, and no PageUp binding — none of which lets a user page back
-   * through a finished task's output, which is the whole point of opening its
-   * window. Scoping is harmless: the daemon owns a private socket
-   * (`tmuxSocketName`), so these server-wide options touch nothing but its
-   * own session. Best-effort so an ancient or stripped tmux cannot stop tasks
-   * from spawning — the session still works without the scroll comforts.
+   * Gives an attached runner terminal wheel/PageUp scrolling over a deep
+   * scrollback, and a mouse selection that reaches the system clipboard — none
+   * of which a default tmux session does. Server-wide scoping is harmless: the
+   * daemon owns a private socket (`tmuxSocketName`).
+   *
+   * `mouse on` is what costs the emulator's own drag-select, so tmux must hand
+   * the selection back out itself: via a clipboard binary when there is one,
+   * and via OSC 52 (`set-clipboard`) for what that cannot cover, such as
+   * viewing over SSH. Naming the binary on the binding as well as in
+   * `copy-command` keeps drag-to-copy working on tmux older than 3.2, which has
+   * no `copy-command`.
    */
   async configureScrolling() {
-    try {
-      await this.tmux(["set-option", "-g", "history-limit", "100000"]);
-      await this.tmux(["set-option", "-g", "mouse", "on"]);
-      await this.tmux(["bind-key", "-n", "PageUp", "copy-mode", "-u"]);
-      await this.tmux(["bind-key", "-T", "copy-mode", "PageUp", "send-keys", "-X", "page-up"]);
-      await this.tmux(["bind-key", "-T", "copy-mode", "PageDown", "send-keys", "-X", "page-down"]);
-      await this.tmux(["bind-key", "-T", "copy-mode-vi", "PageUp", "send-keys", "-X", "page-up"]);
-      await this.tmux(["bind-key", "-T", "copy-mode-vi", "PageDown", "send-keys", "-X", "page-down"]);
-    } catch {
+    const clip = this.clipboardCommand();
+    const copySelection = clip ? ["copy-pipe-and-cancel", clip] : ["copy-pipe-and-cancel"];
+    const commands = [
+      // `history-limit` only governs windows created after it is set, so it
+      // must run before any `new-window` — once, here at session creation.
+      ["set-option", "-g", "history-limit", "100000"],
+      ["set-option", "-g", "mouse", "on"],
+      ["set-option", "-g", "set-clipboard", "on"],
+      ...clip ? [["set-option", "-g", "copy-command", clip]] : [],
+      ["bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", ...copySelection],
+      ["bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", ...copySelection],
+      // Root-table PageUp; otherwise the key goes to the inner app and never
+      // reaches tmux's scrollback. Both mode tables, so `mode-keys` can't
+      // decide whether paging works.
+      ["bind-key", "-n", "PageUp", "copy-mode", "-u"],
+      ["bind-key", "-T", "copy-mode", "PageUp", "send-keys", "-X", "page-up"],
+      ["bind-key", "-T", "copy-mode", "PageDown", "send-keys", "-X", "page-down"],
+      ["bind-key", "-T", "copy-mode-vi", "PageUp", "send-keys", "-X", "page-up"],
+      ["bind-key", "-T", "copy-mode-vi", "PageDown", "send-keys", "-X", "page-down"]
+    ];
+    for (const args of commands) {
+      try {
+        await this.tmux(args);
+      } catch {
+      }
     }
   }
   /**
@@ -10491,7 +10559,14 @@ var TmuxRunner = class extends AbstractRunner {
       thinkingEffort: opts.thinkingEffort,
       modelVariants: opts.modelVariants,
       mode: opts.mode,
+      // A tmux window is a real TTY the user can attach to (ADR-0007), so the
+      // runner's own TUI is the point — `interactive`. It is still an
+      // unattended run, so autonomy stays on: the two are separate axes, and
+      // conflating them is what made Codex tasks stream `codex exec` output
+      // into a window that was supposed to show its TUI.
       headless: opts.headless ?? true,
+      interactive: true,
+      cwd: opts.cwd,
       registry: opts.registry
     });
     await this.ensureSession();
@@ -10729,18 +10804,33 @@ var CODEX_MANIFEST = {
   version: "1.0.0",
   runner: {
     command: "codex",
-    // Headless surfaces (CLI/web) use the non-interactive `exec` subcommand
-    // (`--skip-git-repo-check`: task workspaces aren't always git repos, and
-    // exec hard-fails outside one by default); interactive surfaces (VS Code
-    // terminal) launch the TUI with the prompt as its positional argument.
-    // Reasoning effort has no dedicated flag — it travels as a `-c` config
-    // override (see {{feature:reasoningEffortConfig}}). Both `exec` and the
-    // TUI accept `-m`, `-c`, and `--sandbox`.
+    // Headless surfaces (a piped subprocess) use the non-interactive `exec`
+    // subcommand (`--skip-git-repo-check`: task workspaces aren't always git
+    // repos, and exec hard-fails outside one by default); interactive surfaces
+    // (a tmux window, the VS Code terminal) launch the TUI with the prompt as
+    // its positional argument. Reasoning effort has no dedicated flag — it
+    // travels as a `-c` config override (see {{feature:reasoningEffortConfig}}).
+    // Both `exec` and the TUI accept `-m`, `-c`, and `--sandbox`.
+    //
+    // The two interactive-only entries restore what `exec` gives implicitly and
+    // the TUI does not: `exec` is non-interactive, so it can neither ask for
+    // command approval nor ask whether the directory is trusted. The TUI asks
+    // for both by default, and an orchestrated task has nobody to answer —
+    // without these it stalls on a menu instead of working. `-a` does not exist
+    // on `exec`, hence the shape gate rather than a `{{if headless}}` one.
     argsTemplate: [
       "{{if headlessSession}}",
       "exec",
       "--skip-git-repo-check",
       "{{/if}}",
+      "{{if interactive}}",
+      "-a",
+      "never",
+      "{{/if}}",
+      "{{if projectTrust}}",
+      "-c",
+      "{{projectTrust}}",
+      "{{/if}}",
       "{{if model}}",
       "-m",
       "{{model}}",
@@ -10760,9 +10850,9 @@ var CODEX_MANIFEST = {
     planMode: true,
     planModeFlag: "--sandbox",
     permissionModeValues: {
-      // Map mode IDs to --sandbox CLI values. `codex exec` is non-interactive
-      // and has no approval flag, so the sandbox axis is the whole permission
-      // story for headless runs.
+      // Map mode IDs to --sandbox CLI values. Approvals are off on both shapes
+      // (implicitly under `exec`, via `-a never` in the TUI), so the sandbox
+      // axis is the whole permission story for a Codex task.
       "agent": "workspace-write",
       "plan": "read-only",
       "fullAccess": "danger-full-access",
@@ -11369,6 +11459,7 @@ export {
   clearAugmentedPathCache,
   clearResearchShellCache,
   clearState,
+  clipboardCopyCommand,
   coerceAssignments,
   collectDirectDependencyOutputs,
   collectProviderCredentials,