@codyswann/lisa 2.339.0 → 2.341.0

package/plugins/lisa-copilot/skills/lisa-secrets-access/scripts/bootstrap-store.mjs

@@ -0,0 +1,232 @@
+/**
+ * Store the one credential that unlocks the provider, on the machine that needs
+ * it.
+ *
+ * Reading it already existed; writing it did not, so every operator ran a
+ * platform-specific `security add-generic-password` copied from documentation.
+ * That is a command with a credential in it, typed by hand, on the one value
+ * whose compromise costs every other secret.
+ *
+ * **Two stores, because there is no third option.** macOS has a keychain that
+ * is encrypted at rest and unlocked with the login session. Linux has no
+ * equivalent that can be assumed present — libsecret needs a running daemon and
+ * a desktop session, which a server or a container does not have. So the
+ * fallback is a `0600` file under `$XDG_CONFIG_HOME`, which is the same
+ * protection the materialized secrets file already relies on. It is weaker than
+ * a keychain and it is stated as such, rather than pretending the two are equal.
+ * @module bootstrap-store
+ */
+
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/**
+ * Where a file-backed bootstrap lives, for platforms with no keychain.
+ * @param {string} key Bootstrap variable name.
+ * @param {Record<string, string|undefined>} [env] Environment to read.
+ * @returns {string} Absolute path.
+ */
+export function bootstrapFile(key, env = process.env) {
+  const root = env.XDG_CONFIG_HOME || join(env.HOME || homedir(), ".config");
+  return join(root, "lisa", "bootstrap", assertKey(key));
+}
+
+/**
+ * Reject a key that is not exactly one safe path segment.
+ *
+ * The key is joined onto a directory, and every entry point — store, clear and
+ * read — routes through that join. A `/` or a `..` in it escapes the bootstrap
+ * directory, so an unvalidated key can write, delete, or read an arbitrary file
+ * as the operator. Validating in `bootstrapFile` covers all three at once
+ * rather than trusting each caller to remember.
+ *
+ * Same guard `assertNamespace` applies to the namespace, and for the same
+ * reason. The character set is what a variable name can hold anyway, so nothing
+ * legitimate is refused.
+ * @param {string} key Candidate bootstrap variable name.
+ * @returns {string} The key, unchanged, when valid.
+ */
+export function assertKey(key) {
+  if (
+    typeof key !== "string" ||
+    !/^[A-Za-z0-9._-]+$/.test(key) ||
+    key === ".."
+  ) {
+    throw new Error(
+      `bootstrap key must be one safe path segment, got ${JSON.stringify(key)}`
+    );
+  }
+  return key;
+}
+
+/**
+ * Quote a word for `security -i`, which tokenizes its stdin like a shell.
+ *
+ * A token is usually base64-ish and needs no quoting, but "usually" is not a
+ * property to rely on for a credential: an unquoted value containing a space
+ * would be parsed as two arguments and silently store only the first part.
+ * A newline is refused outright rather than escaped, because it terminates the
+ * command line and there is no quoting that survives it.
+ * @param {string} word Value to quote.
+ * @returns {string} A single quoted token.
+ */
+function quote(word) {
+  if (/[\n\r]/.test(word)) {
+    throw new Error("bootstrap value must not contain a newline");
+  }
+  return `"${String(word).replace(/(["\\])/g, "\\$1")}"`;
+}
+
+/**
+ * Which store this platform uses.
+ * @param {string} [platform] Platform name, injectable for tests.
+ * @returns {"keychain"|"file"} The store.
+ */
+export function storeKind(platform = process.platform) {
+  return platform === "darwin" ? "keychain" : "file";
+}
+
+/**
+ * Write the bootstrap where this machine's sessions will look for it.
+ *
+ * The value never reaches a command line on either path. The keychain path
+ * feeds `security -i` a command stream on **stdin**, because an argument is
+ * visible in `ps` to every process running as this user for as long as the call
+ * lasts. The file path writes and chmods a temporary before renaming, so the
+ * credential is never briefly world-readable on a filesystem where the default
+ * umask would have made it so.
+ * @param {string} key Bootstrap variable name.
+ * @param {string} value The token.
+ * @param {object} [deps] Injected seams, for tests.
+ * @returns {{kind: string, where: string}} Where it went.
+ */
+export function storeBootstrap(key, value, deps = {}) {
+  const kind = deps.kind ?? storeKind();
+  const env = deps.env ?? process.env;
+
+  if (kind === "keychain") {
+    const run = deps.run ?? execFileSync;
+    assertKey(key);
+    // `security -i` reads a COMMAND STREAM on stdin, which is what keeps the
+    // value out of `argv` — where `ps` would show it to every process running
+    // as this user for as long as the call lasts.
+    //
+    // The obvious `-w` with no argument does NOT read the password from stdin.
+    // It opens an interactive prompt on the terminal, and with stdin piped it
+    // stores an EMPTY value and exits 0 — verified against the real binary,
+    // which is how this shipped broken the first time: unit tests injected the
+    // runner and never executed it.
+    //
+    // `-U` updates in place; without it a second run fails with "already
+    // exists", making rotation — the common case — the broken one.
+    run("security", ["-i"], {
+      input: `add-generic-password -U -s ${quote(key)} -a ${quote(
+        env.USER ?? ""
+      )} -w ${quote(value)}\n`,
+      stdio: ["pipe", "ignore", "ignore"],
+    });
+    return { kind, where: `keychain (service ${key})` };
+  }
+
+  const path = deps.path ?? bootstrapFile(key, env);
+  const write = deps.write ?? writeFileSync;
+  const chmod = deps.chmod ?? chmodSync;
+  const rename = deps.rename ?? renameSync;
+  const makeDir = deps.mkdir ?? mkdirSync;
+
+  makeDir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.tmp`;
+  // mode on write applies only when the file is CREATED, so an existing
+  // temporary from a crashed run would keep its old permissions. chmod after
+  // writing is what makes 0600 true rather than usually true.
+  write(temporary, `${value}\n`, { mode: 0o600 });
+  chmod(temporary, 0o600);
+  rename(temporary, path);
+  return { kind, where: path };
+}
+
+/**
+ * Remove a stored bootstrap, so a rotation can be proven rather than assumed.
+ * @param {string} key Bootstrap variable name.
+ * @param {object} [deps] Injected seams, for tests.
+ */
+export function clearBootstrap(key, deps = {}) {
+  const kind = deps.kind ?? storeKind();
+  const env = deps.env ?? process.env;
+
+  if (kind === "keychain") {
+    const run = deps.run ?? execFileSync;
+    try {
+      run(
+        "security",
+        ["delete-generic-password", "-s", key, "-a", env.USER ?? ""],
+        {
+          stdio: "ignore",
+        }
+      );
+    } catch {
+      // Absent is the desired state, and `security` exits non-zero for it.
+    }
+    return;
+  }
+  const remove = deps.remove ?? rmSync;
+  remove(deps.path ?? bootstrapFile(key, env), { force: true });
+}
+
+/**
+ * Whether this machine already holds a bootstrap under that name.
+ *
+ * Asked so `environment local` can re-materialize after a rotation in the vault
+ * without demanding the token again — that is the common case, and prompting
+ * every time would make it the tedious one.
+ *
+ * Presence only. The value is never read here, because nothing about deciding
+ * whether to prompt needs it.
+ * @param {string} key Bootstrap variable name.
+ * @param {object} [deps] Injected seams, for tests.
+ * @returns {boolean} True when a value is stored.
+ */
+export function hasBootstrap(key, deps = {}) {
+  const kind = deps.kind ?? storeKind();
+  const env = deps.env ?? process.env;
+
+  if (kind === "keychain") {
+    const run = deps.run ?? execFileSync;
+    try {
+      run(
+        "security",
+        ["find-generic-password", "-s", assertKey(key), "-a", env.USER ?? ""],
+        { stdio: "ignore" }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return (deps.exists ?? existsSync)(deps.path ?? bootstrapFile(key, env));
+}
+
+/**
+ * Read a file-backed bootstrap, treating absence as empty.
+ *
+ * The keychain reader lives beside the other provider concerns in
+ * `providers.mjs`; this is its counterpart for platforms without one.
+ * @param {string} key Bootstrap variable name.
+ * @param {Record<string, string|undefined>} [env] Environment to read.
+ * @returns {string} The value, or an empty string.
+ */
+export function readBootstrapFile(key, env = process.env) {
+  const path = bootstrapFile(key, env);
+  if (!existsSync(path)) return "";
+  return readFileSync(path, "utf8").trim();
+}

package/plugins/lisa-copilot/skills/lisa-secrets-access/scripts/materialize-secrets.mjs

@@ -299,12 +299,28 @@ export function installAwsProfiles(bundle, options = {}) {
   return rendered.profiles;
 }
 
-export function materialize(cfg = readConfig()) {
-  if (!cfg.capabilities.mayWriteValues) {
+export function materialize(cfg = readConfig(), options = {}) {
+  // `requested` distinguishes an OPERATOR asking from a flow deciding.
+  //
+  // The capability governs automated behaviour: a session-start hook on a
+  // laptop must not write credentials to disk, because the provider CLI is
+  // authenticated there and a copy would add drift and exposure without adding
+  // capability. That reasoning holds, and the guard below still enforces it.
+  //
+  // It does not hold for `lisa environment local`, where the operator typed the
+  // command whose entire purpose is to put credentials on this machine — the
+  // AWS `-static` profiles reference variables that exist only once the env
+  // file is materialized, so refusing there means the profiles never work.
+  //
+  // Two different questions, so two different answers, rather than flipping
+  // `local` to `materialized: true` and silently starting to write on every
+  // machine that upgrades.
+  if (!cfg.capabilities.mayWriteValues && !options.requested) {
     throw new Error(
       `surface "${cfg.surface}" may not write secret values to disk.\n` +
         `It can read through to the provider, so a copy on disk would add drift ` +
-        `and exposure without adding capability.`
+        `and exposure without adding capability.\n` +
+        `Run 'lisa environment local --tenant=<name>' to ask for it explicitly.`
     );
   }
 

package/plugins/lisa-copilot/skills/lisa-secrets-access/scripts/prompt-secret.mjs

@@ -0,0 +1,79 @@
+/**
+ * Ask an operator for a credential, without it appearing anywhere.
+ *
+ * The obvious alternatives all leave a copy behind:
+ *
+ * - **A command-line argument** is visible in `ps` to every process on the
+ *   machine for as long as the call runs, and a shell records it in history.
+ * - **The clipboard** is worse than it looks. Raycast, Alfred, Maccy and every
+ *   other clipboard manager persist history in plaintext, searchable, long
+ *   after the paste — so a bootstrap routed through it outlives the operation
+ *   in a database nobody thinks about. Reading it silently also takes whatever
+ *   happens to be there, which is the wrong thing whenever the operator copied
+ *   something else in between.
+ * - **Echoed input** puts it in the terminal scrollback, which is frequently
+ *   logged.
+ *
+ * So: read from the tty with echo off, and never touch anything else.
+ * @module prompt-secret
+ */
+
+import { execFileSync } from "node:child_process";
+import { closeSync, openSync, readSync, writeSync } from "node:fs";
+
+/**
+ * Whether a human can actually answer.
+ *
+ * Checked so an automated caller SKIPS the prompt rather than hanging on a
+ * read that will never return. A setup script blocked forever is worse than one
+ * that says what it could not do — the first looks like a slow install.
+ * @param {object} [io] Injected seams, for tests.
+ * @returns {boolean} True when stdin is a terminal.
+ */
+export function canPrompt(io = {}) {
+  return Boolean(io.isTTY ?? process.stdin.isTTY);
+}
+
+/**
+ * Prompt for a secret with terminal echo disabled.
+ *
+ * Echo is turned off with `stty` and restored in a `finally`, because a caller
+ * that throws mid-read would otherwise leave the operator's terminal silently
+ * not echoing anything they type afterwards.
+ * @param {string} message Prompt to display.
+ * @param {object} [io] Injected seams, for tests.
+ * @returns {string} What was typed, trimmed.
+ */
+export function promptSecret(message, io = {}) {
+  const run = io.run ?? execFileSync;
+  const open = io.open ?? openSync;
+  const read = io.read ?? readSync;
+  const close = io.close ?? closeSync;
+  const write = io.write ?? writeSync;
+
+  const tty = open("/dev/tty", "r+");
+  try {
+    write(tty, message);
+    // `stty` must be pointed at the descriptor the credential is READ from, not
+    // at this process's stdin. With "inherit" it configures whatever stdin
+    // happens to be: a pipe, where stty exits non-zero and this throws; or a
+    // different terminal, where echo stays on for the device the operator is
+    // typing into and the credential lands in their scrollback.
+    run("stty", ["-echo"], { stdio: [tty, "ignore", "ignore"] });
+    const buffer = Buffer.alloc(4096);
+    try {
+      const bytes = read(tty, buffer, 0, buffer.length, null);
+      return buffer.toString("utf8", 0, bytes).trim();
+    } finally {
+      // Zeroed rather than left for the collector: a 4 KiB buffer holding a
+      // bootstrap credential is exactly the page that ends up in a core dump.
+      buffer.fill(0);
+      run("stty", ["echo"], { stdio: [tty, "ignore", "ignore"] });
+      // The newline the operator typed was not echoed, so without this the next
+      // line of output starts halfway across the prompt.
+      write(tty, "\n");
+    }
+  } finally {
+    close(tty);
+  }
+}

package/plugins/lisa-copilot/skills/lisa-secrets-access/scripts/providers.mjs

@@ -11,6 +11,8 @@
 
 import { execFileSync } from "node:child_process";
 
+import { readBootstrapFile } from "./bootstrap-store.mjs";
+
 /**
  * A provider key becomes a shell variable name on materializing surfaces, so
  * only names valid in every POSIX-like shell are accepted. Anything else stays
@@ -129,13 +131,29 @@ export function bootstrapToken(bootstrap) {
 }
 
 /**
- * Read one value from the macOS keychain, treating absence as empty.
- * @param {string} key Keychain service name.
+ * Read one value from this machine's credential store, treating absence as
+ * empty.
+ *
+ * The `keychain` source names a role, not a macOS API: "wherever this machine
+ * keeps its bootstrap". On macOS that is the keychain. Elsewhere there is no
+ * store that can be assumed present — libsecret needs a daemon and a desktop
+ * session, which a server or container does not have — so it is a `0600` file,
+ * the same protection the materialized secrets file already relies on.
+ *
+ * Returning empty on the other platform, as this did before, meant a Linux
+ * machine could store a bootstrap and never read it back.
+ * @param {string} key Bootstrap variable name.
  * @returns {string} The value, or an empty string when unavailable.
  */
 function fromKeychain(key) {
-  if (process.platform !== "darwin") return "";
   try {
+    // Inside the `try`, not before it. `readBootstrapFile` uses `readFileSync`,
+    // which throws on a permission error, on EISDIR, and when the file is
+    // removed between the existence check and the read. This function's
+    // contract is to return empty when the value is unavailable, and
+    // `bootstrapToken` has no handler — so a raw filesystem error would
+    // replace the curated "not found in: ..." message with a stack trace.
+    if (process.platform !== "darwin") return readBootstrapFile(key);
     return execFileSync(
       "security",
       ["find-generic-password", "-s", key, "-a", process.env.USER ?? "", "-w"],

package/plugins/lisa-copilot/skills/lisa-secrets-access/scripts/surfaces.mjs

@@ -252,6 +252,33 @@ function resolveBootstrap(bootstrap, provider, namespace) {
   };
 }
 
+/**
+ * Build a configuration for a tenant the operator named outright.
+ *
+ * Deliberately ignores any `.lisa.config.json` in the working directory. The
+ * flag is the more specific statement — someone who typed `--tenant=acme` means
+ * acme, whichever repository they happen to be standing in — and silently
+ * preferring the file would materialize a different tenant than the one on the
+ * command line.
+ *
+ * Getting this wrong is not a cosmetic error. Every namespace is a directory
+ * under `$XDG_CONFIG_HOME`, so resolving to the wrong one writes one tenant's
+ * credentials where another tenant's sessions read, and on a machine serving
+ * several the two would share a store.
+ * @param {{tenant: string, provider?: string}} options Named identity.
+ * @param {Record<string, string|undefined>} [env] Environment to inherit.
+ * @returns {object} A resolved configuration.
+ */
+export function configForTenant({ tenant, provider }, env = process.env) {
+  return withSurface(
+    fromEnvironment({
+      ...env,
+      LISA_TENANT: tenant,
+      ...(provider ? { LISA_PROVIDER: provider } : {}),
+    })
+  );
+}
+
 /**
  * Build a configuration from the environment, for sessions with no checkout.
  *

package/plugins/lisa-copilot/skills/lisa-setup-remote-env/scripts/environment.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * Configure one surface for one tenant.
+ *
+ * One verb, one axis — *which surface* — and the only difference between them
+ * is whether Lisa can execute there or has to hand an operator text to paste.
+ *
+ *     environment local        runs it here
+ *     environment container    emits an image definition and a run command
+ *     environment claude-web   emits, because the dialog has no API
+ *     environment codex-cloud  emits, same reason
+ *
+ * This replaces `remote-env --emit=<surface>`, whose name described the
+ * machinery rather than the task: from a laptop, `remote-env` reads as
+ * "prepare the remote environment I am currently in", which is the opposite of
+ * what an operator configuring a cloud environment is doing. The old spelling
+ * still works so nothing in flight breaks.
+ *
+ * `workstation` remains a separate command and a separate concern: it answers
+ * "what binaries does this machine have", with no tenant and no credentials. So
+ * **rotating a token is `environment local` again**, not re-running an
+ * installer that wants to reinstall six coding agents.
+ * @module environment
+ */
+
+import { pathToFileURL } from "node:url";
+
+/** Surfaces this command can configure, and how each is delivered. */
+export const TARGETS = {
+  local: { mode: "run", label: "this machine" },
+  container: { mode: "emit", label: "a container image you build" },
+  "claude-web": { mode: "emit", label: "a Claude cloud environment" },
+  "codex-cloud": { mode: "emit", label: "a Codex Cloud environment" },
+};
+
+/**
+ * Resolve the surface name an operator asked for.
+ *
+ * An unknown name is an error rather than a default, because defaulting would
+ * configure something other than what they typed — and on this command the
+ * difference between surfaces is where a credential ends up.
+ * @param {string|undefined} name Requested surface.
+ * @returns {string} A key of {@link TARGETS}.
+ */
+export function assertTarget(name) {
+  if (!name || !TARGETS[name]) {
+    throw new Error(
+      `unknown environment "${name ?? ""}".\n` +
+        `Known: ${Object.keys(TARGETS).join(", ")}`
+    );
+  }
+  return name;
+}
+
+/**
+ * Prepare THIS machine: store the bootstrap, then materialize.
+ *
+ * The prompt is skipped rather than blocked when nothing can answer it, and
+ * skipped rather than repeated when the machine already holds a bootstrap —
+ * `environment local` is also how an operator re-materializes after rotating a
+ * secret in the vault, and demanding the token again every time would make the
+ * common case the tedious one. `--rotate` is how you say you mean to replace it.
+ * @param {object} options Resolved tenant, provider and flags.
+ * @param {object} [deps] Injected seams, for tests.
+ * @returns {Promise<string[]>} Lines to report.
+ */
+export async function configureLocal(options, deps = {}) {
+  const { tenant, provider, bootstrapKey: key, rotate = false } = options;
+  const lines = [];
+
+  // A tenant is required here, unlike the emit paths, because this one WRITES.
+  // Without it the config falls back to the default namespace and materializes
+  // one tenant's credentials into another's directory — and on a machine
+  // serving several, the two would then share a store.
+  if (!tenant) {
+    throw new Error(
+      "environment local needs --tenant=<name>.\n" +
+        "It writes credentials into a per-tenant directory, so guessing the " +
+        "name would put one tenant's secrets where another's sessions read."
+    );
+  }
+
+  const wired = deps.prompt
+    ? deps
+    : { ...(await localDeps({ tenant, provider })), ...deps };
+  const { canPrompt, promptSecret } = wired.prompt;
+  const { storeBootstrap, hasBootstrap } = wired.store;
+  const materialize = wired.materialize;
+
+  if (!key) {
+    lines.push(
+      `${provider} has no environment-variable bootstrap, so there is nothing`,
+      `to store. Authenticate it the way its own CLI expects.`
+    );
+  } else if (hasBootstrap(key) && !rotate) {
+    lines.push(`${key} is already stored; pass --rotate to replace it.`);
+  } else if (!canPrompt()) {
+    // Not fatal. A non-interactive caller can legitimately have supplied the
+    // bootstrap through the environment, and refusing would break that.
+    lines.push(
+      `No terminal to prompt on, so ${key} was not stored.`,
+      `Set it in the environment, or re-run where a human can type.`
+    );
+  } else {
+    const value = promptSecret(`Paste the access token for ${tenant}: `);
+    if (!value) {
+      lines.push(`Nothing entered, so ${key} was not stored.`);
+    } else {
+      const { where } = storeBootstrap(key, value);
+      lines.push(`Stored ${key} in ${where}.`);
+    }
+  }
+
+  const result = await materialize();
+  lines.push(...result);
+  return lines;
+}
+
+/**
+ * Run the command.
+ * @param {string[]} argv Arguments after the command name.
+ * @param {object} [deps] Injected seams, for tests.
+ * @returns {Promise<number>} Exit code.
+ */
+export async function run(argv, deps = {}) {
+  const out = deps.log ?? console.log;
+  const err = deps.error ?? console.error;
+
+  try {
+    const target = assertTarget(argv.find(a => !a.startsWith("-")));
+    const resolve = deps.resolveTarget ?? (await defaultResolver());
+    const identity = await resolve(argv);
+
+    if (TARGETS[target].mode === "run") {
+      const lines = await (deps.configureLocal ?? configureLocal)(
+        { ...identity, rotate: argv.includes("--rotate") },
+        deps
+      );
+      out(lines.join("\n"));
+      return 0;
+    }
+
+    out((deps.emit ?? (await defaultEmitter()))(target, identity));
+    return 0;
+  } catch (error) {
+    err(String(error.message));
+    return 1;
+  }
+}
+
+// Executed directly by the CLI, imported by tests. Without this the module
+// exported a `run` nobody called and the command printed nothing at all.
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  run(process.argv.slice(2)).then(code => {
+    process.exitCode = code;
+  });
+}
+
+/**
+ * Wire the local path to the real prompt, store and materializer.
+ *
+ * Loaded lazily so the emit paths — which need none of it — do not pay for it,
+ * and so tests can substitute the lot without touching a keychain or a vault.
+ *
+ * `materialize` is called with `requested: true`: the operator typed the
+ * command whose purpose is to put credentials on this machine, which is a
+ * different question from whether an automated flow may write here. The
+ * capability guard still refuses the automated case.
+ * @returns {Promise<object>} Default dependencies for `configureLocal`.
+ */
+async function localDeps(identity) {
+  const at = name =>
+    new URL(`../../lisa-secrets-access/scripts/${name}`, import.meta.url).href;
+  const prompt = await import(at("prompt-secret.mjs"));
+  const store = await import(at("bootstrap-store.mjs"));
+  const secrets = await import(at("materialize-secrets.mjs"));
+  const surfaces = await import(at("surfaces.mjs"));
+
+  return {
+    prompt,
+    store,
+    materialize: () => {
+      // The NAMED tenant, not whatever config the working directory holds.
+      // Reading the directory materialized the default namespace instead of the
+      // one on the command line — observed writing 49 secrets of the wrong
+      // tenant into the wrong directory.
+      const { count, derived, dir, profiles } = secrets.materialize(
+        surfaces.configForTenant(identity),
+        { requested: true }
+      );
+      return [
+        `Materialized ${count} secret(s) into ${dir}.`,
+        ...(derived ? [`${derived} variable(s) derived from the bundle.`] : []),
+        ...(profiles?.length
+          ? [`AWS profiles installed: ${profiles.join(", ")}`]
+          : []),
+      ];
+    },
+  };
+}
+
+/**
+ * Load the identity resolver from the sibling runner.
+ * @returns {Promise<Function>} The resolver.
+ */
+async function defaultResolver() {
+  // Already a URL — passing it through pathToFileURL again throws.
+  const mod = await import(
+    new URL("./setup-remote-env.mjs", import.meta.url).href
+  );
+  return argv => mod.resolveEmitTarget(argv);
+}
+
+/**
+ * Load the emitter from the sibling runner.
+ * @returns {Promise<Function>} The emitter.
+ */
+async function defaultEmitter() {
+  // Already a URL — passing it through pathToFileURL again throws.
+  const mod = await import(
+    new URL("./setup-remote-env.mjs", import.meta.url).href
+  );
+  return (target, identity) => mod.emitFor(target, identity);
+}