humanish 0.16.0 → 0.18.0

package/dist/program.js

@@ -11,8 +11,12 @@ import { runInit } from "./init.js";
 import { inspectLabManifest, listLabManifests, resolveLabManifest } from "./labs.js";
 import { runLabPreflight } from "./lab-preflight.js";
 import { runLab, resolveLabDryRun, selectLabBackend } from "./lab-engine.js";
+import { CUA_ACTOR_LAB_SCHEMA } from "./cua-actor-lab.js";
 import { openTarget, renderObserver, serveObserver } from "./observer.js";
 import { serveObserverStatic } from "./observer-static.js";
+import { SERVE_SCHEMA, serveObserverLibrary } from "./observer-serve.js";
+import { startExposedObserver, validateExposure } from "./serve-exposure.js";
+import { ServeTunnelError } from "./serve-tunnel.js";
 import { DEFAULT_OSS_REPOS, runOssLab } from "./oss-lab.js";
 import { cleanupOssMetaLabSandboxes, cleanupStaleOssMetaLabSandboxes, runOssMetaLab, startOssMetaLabLiveRefresh } from "./oss-meta-lab.js";
 import { cleanupRun, doctor, listRuns, readReview, runDryRun, verifyRun } from "./run.js";
@@ -163,6 +167,7 @@ export function createProgram(io = {}) {
     registerRunsCommand(program, cliIo);
     registerWatchCommand(program, cliIo);
     registerObserveCommand(program, cliIo);
+    registerServeCommand(program, cliIo);
     registerCodexCommands(program, cliIo);
     registerLabCommands(program, cliIo);
     registerFeedbackCommands(program, cliIo);
@@ -484,6 +489,14 @@ function registerWatchCommand(parent, io) {
         .addOption(new Option("--follow", "Deprecated; human output follows by default.").hideHelp())
         .option("--detach", "Render/open once and exit without attached watch server.")
         .option("--port <port>", "Local observer server port when following.", "0")
+        .option("--expose", "CUA lab only: expose the live run through an authenticated edge so you can watch from a phone. Requires edge auth.")
+        .addOption(new Option("--tunnel <provider>", "Spawn the external tunnel binary against the loopback port.").choices(["ngrok"]))
+        .option("--tunnel-domain <domain>", "Reserved domain passed to ngrok as --url (e.g. observer.example.com). Requires --tunnel.")
+        .addOption(new Option("--oauth <provider>", "Turn on ngrok edge OAuth. Requires --tunnel.").choices(["google"]))
+        .option("--allow-email <addr>", "Edge OAuth allow rule: permit this email. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--allow-domain <domain>", "Edge OAuth allow rule: permit this domain. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--public-url <origin>", "Bring-your-own authed edge (Cloudflare Access/Tailscale/manual). Binds loopback and trusts your edge. Requires --expose.")
+        .option("--safe", "Not applicable to watch: a live run is never share_ready, so --safe (a `serve` library filter) is rejected here. Restrict viewers with edge auth (--allow-email/--allow-domain).")
         .option("--json", JSON_OPTION_DESCRIPTION)
         .addHelpText("after", [
         "",
@@ -492,6 +505,9 @@ function registerWatchCommand(parent, io) {
         "  humanish watch first-run",
         "  humanish watch --lab .humanish/labs/local.yaml",
         "",
+        "Watch a live CUA run from your phone (tunnel-edge auth):",
+        "  humanish watch my-cua-lab --expose --tunnel ngrok --oauth google --allow-email you@example.com",
+        "",
         "Agent/CI path:",
         "  humanish watch --json --no-open",
         "",
@@ -558,11 +574,38 @@ function registerWatchCommand(parent, io) {
                     repo: options.repo,
                     ...(options.repos === undefined ? {} : { repos: options.repos }),
                     ...(options.runId === undefined ? {} : { runId: options.runId }),
-                    ...(options.sims === undefined ? {} : { sims: options.sims })
+                    ...(options.sims === undefined ? {} : { sims: options.sims }),
+                    ...(options.expose === undefined ? {} : { expose: options.expose }),
+                    ...(options.tunnel === undefined ? {} : { tunnel: options.tunnel }),
+                    ...(options.tunnelDomain === undefined ? {} : { tunnelDomain: options.tunnelDomain }),
+                    ...(options.oauth === undefined ? {} : { oauth: options.oauth }),
+                    allowEmail: options.allowEmail,
+                    allowDomain: options.allowDomain,
+                    ...(options.publicUrl === undefined ? {} : { publicUrl: options.publicUrl }),
+                    ...(options.safe === undefined ? {} : { safe: options.safe }),
+                    ...(options.json === undefined ? {} : { json: options.json })
                 }
             });
             return;
         }
+        // Exposure is only meaningful for a live CUA lab run (it serves the live desktop). The
+        // non-lab watch path (existing evidence, or a fresh synthetic run) has no live desktop to
+        // stream, so exposure flags there are refused rather than silently ignored — use `serve`.
+        if (watchExposeRequested(options)) {
+            const result = {
+                schema: "humanish.run-result.v1",
+                ok: false,
+                cwd: options.cwd,
+                warnings: [],
+                error: {
+                    code: "HUMANISH_WATCH_OPTION_CONFLICT",
+                    message: "--expose/--tunnel/--oauth apply only to a live CUA lab run; to expose finished evidence use `humanish serve --expose`."
+                }
+            };
+            writeResult(command, io, result, formatRunHuman);
+            io.setExitCode(2);
+            return;
+        }
         const runOptionSource = typeof command.getOptionValueSource === "function"
             ? command.getOptionValueSource("run")
             : undefined;
@@ -788,6 +831,203 @@ async function serveObserveUntilSignal(io, server, options) {
         }
     });
 }
+function registerServeCommand(parent, io) {
+    parent
+        .command("serve")
+        .description("Serve the local run library over loopback http, with optional tunnel-edge authenticated exposure.")
+        .summary("Serve the run library; optional tunnel-edge exposure.")
+        .option("--cwd <path>", "Target project directory.", ".")
+        .option("--port <port>", "Loopback port to bind on 127.0.0.1. Defaults to an ephemeral port.", "0")
+        .option("--run <id>", "Land on this run id (or latest) instead of the library index.")
+        .option("--safe", "Serve only runs whose verify shareSafety is share_ready; everything else is absent (fail-closed).")
+        .option("--expose", "Declare exposure intent. Requires edge auth (--oauth or --public-url) OR --safe.")
+        .addOption(new Option("--tunnel <provider>", "Spawn the external tunnel binary against the loopback port.").choices(["ngrok"]))
+        .option("--tunnel-domain <domain>", "Reserved domain passed to ngrok as --url (e.g. observer.example.com). Requires --tunnel.")
+        .addOption(new Option("--oauth <provider>", "Turn on ngrok edge OAuth. Requires --tunnel.").choices(["google"]))
+        .option("--allow-email <addr>", "Edge OAuth allow rule: permit this email. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--allow-domain <domain>", "Edge OAuth allow rule: permit this domain. Repeatable. Requires --oauth.", collectRepeated, [])
+        .option("--public-url <origin>", "Bring-your-own authed edge (e.g. https://observer.example.com). Requires --expose; never affects binding.")
+        .option("--open", "Open the library in the default browser.")
+        .option("--no-open", "Serve without opening a browser.")
+        .option("--json", JSON_OPTION_DESCRIPTION)
+        .addHelpText("after", [
+        "",
+        "Happy path:",
+        "  humanish serve",
+        "  humanish serve --expose --tunnel ngrok --oauth google --allow-email you@example.com",
+        "  humanish serve --safe --expose --tunnel ngrok",
+        "  humanish serve --expose --public-url https://observer.example.com",
+        "",
+        "Agent/CI path:",
+        "  humanish serve --json --no-open",
+        "",
+        "The server always binds 127.0.0.1; exposure only ever happens through an authenticated",
+        "edge (ngrok --oauth google, or an operator --public-url you secure) forwarding to the",
+        "loopback port. humanish carries no in-process auth — the gate lives at the edge. Live",
+        "desktop stream URLs are never served here; remote viewers see persisted evidence only.",
+        "--safe composes with any exposure for defense in depth."
+    ].join("\n"))
+        .action(async (options, command) => {
+        const wantsMachine = wantsJson(command);
+        const fail = (code, message) => {
+            const result = {
+                schema: SERVE_SCHEMA,
+                ok: false,
+                cwd: options.cwd,
+                mode: "loopback",
+                safe: options.safe === true,
+                host: "127.0.0.1",
+                runsListed: 0,
+                warnings: [],
+                error: { code, message }
+            };
+            writeResult(command, io, result, formatServeHuman);
+            io.setExitCode(2);
+        };
+        const port = parseObserverPort(options.port);
+        if (port === null) {
+            fail("HUMANISH_INVALID_PORT", "--port must be an integer between 0 and 65535.");
+            return;
+        }
+        // Fail-closed exposure matrix (shared validator; tunnel-edge auth only). All guards run before
+        // any bind/spawn.
+        const exposeValidation = validateExposure("serve", {
+            expose: options.expose === true,
+            ...(options.tunnel === undefined ? {} : { tunnel: options.tunnel }),
+            ...(options.tunnelDomain === undefined ? {} : { tunnelDomain: options.tunnelDomain }),
+            ...(options.oauth === undefined ? {} : { oauth: options.oauth }),
+            allowEmails: options.allowEmail,
+            allowDomains: options.allowDomain,
+            ...(options.publicUrl === undefined ? {} : { publicUrl: options.publicUrl }),
+            safe: options.safe === true
+        });
+        if (!exposeValidation.ok) {
+            fail(exposeValidation.error.code, exposeValidation.error.message);
+            return;
+        }
+        const plan = exposeValidation.plan;
+        const started = await serveObserverLibrary(options.cwd, {
+            port,
+            safe: options.safe === true,
+            expose: plan.exposed,
+            edgeAuthed: plan.edgeAuthed,
+            ...(plan.publicOrigin ? { publicOrigin: plan.publicOrigin.origin } : {}),
+            ...(options.run ? { entryRunId: options.run } : {})
+        });
+        if (!started.ok) {
+            fail(started.error.code, started.error.message);
+            return;
+        }
+        const server = started.server;
+        let tunnel;
+        let publicUrl;
+        const warnings = [];
+        if (plan.exposed) {
+            try {
+                const exposeResult = await startExposedObserver(server, plan);
+                tunnel = exposeResult.tunnel;
+                publicUrl = exposeResult.publicUrl;
+                warnings.push(...exposeResult.warnings);
+            }
+            catch (error) {
+                await server.close();
+                if (error instanceof ServeTunnelError) {
+                    fail(error.code, error.message);
+                }
+                else {
+                    fail("HUMANISH_SERVE_TUNNEL_START_FAILED", `Tunnel startup failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
+            }
+        }
+        if (server.mode === "exposed" && options.safe !== true) {
+            warnings.push(`edge-authed exposure grants read access to all ${server.runsListed} local runs, including any not verified share_ready (local_only raw screenshots, blocked bundles); anyone who clears the edge auth can view them; add --safe to restrict to share_ready`);
+        }
+        if (server.mode === "exposed" && options.safe === true) {
+            warnings.push(`edge-authed exposure grants read access to ${server.shareReadyCount ?? 0} share_ready runs; non-share_ready runs are absent even behind the edge`);
+        }
+        if (server.mode === "share-safe-open") {
+            warnings.push(`serving ${server.shareReadyCount ?? 0} share_ready runs to anyone who can reach ${publicUrl ?? server.url}; non-share_ready runs are absent and their URLs 404`);
+        }
+        warnings.push("live desktop stream URLs are never served here; remote viewers see persisted evidence (screenshots, events, terminal tails) only");
+        // Auto-open is suppressed under --expose so the public URL is not shoved into a local opener's
+        // argv unasked — the exposure target is a remote device anyway. Explicit --open still honors
+        // intent and opens the loopback library.
+        const shouldOpen = options.open === false
+            ? false
+            : options.open === true
+                ? true
+                : !wantsMachine && process.stdout.isTTY === true && plan.exposed !== true;
+        const openResult = shouldOpen ? openTarget(server.url) : { opened: false };
+        if (openResult.warning) {
+            warnings.push(openResult.warning);
+        }
+        const result = {
+            schema: SERVE_SCHEMA,
+            ok: true,
+            cwd: options.cwd,
+            mode: server.mode,
+            safe: options.safe === true,
+            host: "127.0.0.1",
+            port: server.port,
+            url: server.url,
+            ...(publicUrl ? { publicUrl } : {}),
+            ...(tunnel ? { tunnel: { provider: "ngrok", url: tunnel.url } } : {}),
+            ...(plan.oauth ? { oauth: { provider: plan.oauth.provider, allowEmails: plan.oauth.allowEmails, allowDomains: plan.oauth.allowDomains } } : {}),
+            runsListed: server.runsListed,
+            ...(server.shareReadyCount !== undefined ? { shareReadyCount: server.shareReadyCount } : {}),
+            ...(server.entryRunId ? { entryRunId: server.entryRunId } : {}),
+            opened: openResult.opened,
+            ...(openResult.command ? { openCommand: openResult.command } : {}),
+            warnings
+        };
+        writeResult(command, io, result, formatServeHuman);
+        io.setExitCode(0);
+        await serveObserveUntilSignal(io, {
+            url: server.url,
+            close: async () => {
+                if (tunnel) {
+                    await tunnel.close();
+                }
+                await server.close();
+            }
+        }, { json: wantsMachine });
+    });
+}
+function formatServeHuman(result) {
+    if (!result.ok) {
+        return [
+            "humanish serve failed",
+            ...(result.error ? [`error: ${result.error.code} ${result.error.message}`] : []),
+            ...result.warnings.map((warning) => `warning: ${warning}`)
+        ].join("\n") + "\n";
+    }
+    const modeSuffix = result.safe ? " (share_ready only)" : "";
+    const lines = [
+        "humanish serve",
+        `mode: ${result.mode}${modeSuffix}`,
+        `library: ${result.url ?? ""}`,
+        `runs: ${result.runsListed}`
+    ];
+    if (result.publicUrl) {
+        lines.push(`public: ${result.publicUrl}`);
+    }
+    if (result.tunnel) {
+        lines.push(`tunnel: ${result.tunnel.provider} ${result.tunnel.url}`);
+    }
+    if (result.oauth) {
+        const rules = [...result.oauth.allowEmails, ...result.oauth.allowDomains];
+        lines.push(`edge auth: ${result.oauth.provider} oauth${rules.length > 0 ? ` (allow: ${rules.join(", ")})` : " (no allow rule — any Google account)"}`);
+    }
+    if (result.entryRunId) {
+        lines.push(`entry: ${result.entryRunId}`);
+    }
+    lines.push(`opened: ${result.opened === true ? "yes" : "no"}`);
+    for (const warning of result.warnings) {
+        lines.push(`warning: ${warning}`);
+    }
+    return lines.join("\n") + "\n";
+}
 function registerFeedbackCommands(parent, io) {
     const feedback = parent
         .command("feedback")
@@ -1251,6 +1491,23 @@ async function runLabCommand(args) {
         writeUnsupportedRerunFlagsResult(args, backend);
         return;
     }
+    // Exposure serves a live desktop, which only the computer-use backend produces. Refuse it on any
+    // other backend rather than silently ignoring it.
+    if (backend !== "cua" && watchExposeRequested(args.options)) {
+        const result = {
+            schema: "humanish.run-result.v1",
+            ok: false,
+            cwd: resolve(args.options.cwd),
+            warnings: [],
+            error: {
+                code: "HUMANISH_WATCH_OPTION_CONFLICT",
+                message: `--expose/--tunnel/--oauth stream a live desktop and apply only to computer-use labs; this lab resolved to ${backend}.`
+            }
+        };
+        writeResult(args.command, args.io, result, formatRunHuman);
+        args.io.setExitCode(2);
+        return;
+    }
     switch (backend) {
         case "synthetic":
             await runSyntheticBackend({ ...args, config });
@@ -1379,30 +1636,162 @@ async function runCuaBackend(args) {
         args.io.setExitCode(2);
         return;
     }
-    const outcome = await runLab(args.config, {
-        cwd: args.options.cwd,
-        // Watch mode opens the served Observer below instead of the static render.
-        open: args.mode === "watch" ? false : shouldOpen,
-        count,
-        ...(args.options.dryRun === undefined ? {} : { dryRun: args.options.dryRun }),
-        ...(args.options.runId === undefined ? {} : { runId: args.options.runId }),
-        ...(args.options.rerunFailedFrom === undefined
-            ? {}
-            : {
-                rerun: {
-                    sourceRunId: args.options.rerunFailedFrom,
-                    ...(laneIds.length === 0 ? {} : { laneIds })
-                }
-            })
+    const dryRun = resolveLabDryRun(args.config, args.options.dryRun, true) ?? true;
+    const port = parseObserverPort(args.options.port ?? "0");
+    const wantsFollow = args.mode === "watch" && !wantsMachine && args.options.detach !== true && dryRun !== true;
+    const failCua = (code, message) => {
+        const result = {
+            schema: CUA_ACTOR_LAB_SCHEMA,
+            ok: false,
+            cwd: args.options.cwd,
+            labId: args.config.id,
+            actor: args.config.actors[0]?.type ?? "",
+            appUrl: "",
+            dryRun,
+            runId: args.options.runId ?? "not-created",
+            warnings: [],
+            error: { code, message }
+        };
+        writeResult(args.command, args.io, result, formatCuaLabHuman);
+        args.io.setExitCode(2);
+    };
+    if (port === null) {
+        failCua("HUMANISH_WATCH_OPTION_CONFLICT", "--port must be an integer between 0 and 65535.");
+        return;
+    }
+    // Validate exposure up front (fail-closed matrix), before any run/spend. A live CUA watch is the
+    // one surface that serves runtime E2B stream URLs, so it MUST sit behind edge auth.
+    const exposeValidation = validateExposure("watch", exposureRequestFromOptions(args.options), {
+        dryRun,
+        detach: args.options.detach === true,
+        json: wantsMachine
     });
+    if (!exposeValidation.ok) {
+        failCua(exposeValidation.error.code, exposeValidation.error.message);
+        return;
+    }
+    const plan = exposeValidation.plan;
+    const exposeRequested = plan.exposed;
+    let server = null;
+    let attachedObserver = null;
+    let tunnel;
+    let exposeWarnings = [];
+    let exposePublicTarget;
+    let outcome;
+    try {
+        outcome = await runLab(args.config, {
+            cwd: args.options.cwd,
+            // Watch mode opens the served Observer below (or prints the phone target under --expose)
+            // instead of the static render — preserved byte-for-byte from the pre-0.18 open policy so a
+            // non-follow watch (dry-run/--json) does not double-open. Run mode keeps the static open.
+            open: args.mode === "watch" ? false : shouldOpen,
+            count,
+            dryRun,
+            ...(wantsFollow
+                ? {
+                    // Fires INSIDE runLab, before the actor loop and before sandbox creation, so a
+                    // tunnel-auth failure aborts before any spend and leaves no orphaned sandbox.
+                    onObserverReady: async (observer) => {
+                        attachedObserver = observer;
+                        if (!server) {
+                            server = await serveObserver(observer, {
+                                open: shouldOpen && !exposeRequested,
+                                port,
+                                exposed: exposeRequested
+                            });
+                        }
+                        if (exposeRequested) {
+                            const activeServer = server;
+                            const exposeResult = await startExposedObserver(activeServer, plan);
+                            if (exposeResult.tunnel) {
+                                tunnel = exposeResult.tunnel;
+                            }
+                            exposeWarnings = exposeResult.warnings;
+                            const phoneTarget = exposeResult.publicUrl ?? activeServer.url;
+                            exposePublicTarget = phoneTarget;
+                            args.io.writeOut(`watch: exposed live desktop at ${phoneTarget} (edge-authed; open it on your phone)\n`);
+                            for (const warning of exposeResult.warnings) {
+                                args.io.writeErr(`warning: ${warning}\n`);
+                            }
+                        }
+                    }
+                }
+                : {}),
+            ...(args.options.runId === undefined ? {} : { runId: args.options.runId }),
+            ...(args.options.rerunFailedFrom === undefined
+                ? {}
+                : {
+                    rerun: {
+                        sourceRunId: args.options.rerunFailedFrom,
+                        ...(laneIds.length === 0 ? {} : { laneIds })
+                    }
+                })
+        });
+    }
+    catch (error) {
+        // Tear down the loopback server and any tunnel started inside onObserverReady before rethrowing
+        // (or surfacing a structured tunnel-startup failure). The sandbox is created AFTER
+        // onObserverReady returns, so a tunnel failure here cannot orphan one.
+        const earlyServer = server;
+        await earlyServer?.close().catch((cleanupError) => {
+            args.io.writeErr(`watch cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}\n`);
+        });
+        server = null;
+        if (tunnel) {
+            await tunnel.close().catch(() => undefined);
+            tunnel = undefined;
+        }
+        if (error instanceof ServeTunnelError) {
+            failCua(error.code, error.message);
+            return;
+        }
+        throw error;
+    }
     if (outcome.backend !== "cua") {
         throw new Error(`Expected cua backend, got ${outcome.backend}.`);
     }
     const result = outcome.result;
-    writeResult(args.command, args.io, result, formatCuaLabHuman);
+    // Serving is NOT gated on result.ok: a timed_out/failed run still comes up so the operator can
+    // inspect its evidence live (and, under --expose, from a phone). budget_reached now makes a
+    // productive open-ended watch result.ok true.
+    let output = result;
+    if (server && attachedObserver) {
+        const activeServer = server;
+        const attachedResult = result.observer?.ok ? result.observer : attachedObserver;
+        output = {
+            ...result,
+            observer: withObserverServer(attachedResult, activeServer),
+            warnings: [
+                ...result.warnings,
+                "Live CUA server is polling observer-data.json with no-store caching.",
+                ...(exposeRequested
+                    ? [
+                        `Exposed live desktop stream URLs to an edge-authenticated remote viewer${tunnel ? ` via ${tunnel.url.replace(/\/$/, "")}` : ""}.`,
+                        `this live run's raw, unverified evidence (screenshots, events) is viewable by anyone who clears the edge auth at ${exposePublicTarget ?? activeServer.url}; only the run being watched is served, not your other runs`
+                    ]
+                    : []),
+                ...exposeWarnings,
+                ...(activeServer.warning ? [activeServer.warning] : [])
+            ]
+        };
+    }
+    writeResult(args.command, args.io, output, formatCuaLabHuman);
     args.io.setExitCode(result.ok ? 0 : 2);
-    // Watch mode serves the freshly rendered Observer (and opens it unless told not to).
-    if (args.mode === "watch" && result.ok && !wantsMachine) {
+    if (server && (result.observer?.ok || attachedObserver)) {
+        const activeServer = server;
+        const followResult = output.observer?.ok ? output.observer : withObserverServer(attachedObserver, activeServer);
+        await followObserver(args.io, followResult, activeServer, {
+            onStop: async () => {
+                if (tunnel) {
+                    await tunnel.close();
+                    return ["closed ngrok tunnel"];
+                }
+                return [];
+            }
+        });
+    }
+    else if (args.mode === "watch" && result.ok && !wantsMachine) {
+        // Non-follow / dry-run watch keeps today's fallback: render the finished bundle and follow it.
         await renderAndMaybeFollowObserver({
             command: args.command,
             cwd: args.options.cwd,
@@ -2299,6 +2688,31 @@ function formatOssMetaLabCleanupHuman(result) {
 function collectRepeated(value, previous) {
     return [...previous, value];
 }
+// True when any tunnel-edge exposure flag is present (not --safe, which is an orthogonal filter).
+// Used to refuse exposure on the non-lab watch path and on non-CUA backends, where there is no live
+// desktop to stream.
+function watchExposeRequested(o) {
+    return o.expose === true
+        || o.tunnel !== undefined
+        || o.tunnelDomain !== undefined
+        || o.oauth !== undefined
+        || (o.allowEmail?.length ?? 0) > 0
+        || (o.allowDomain?.length ?? 0) > 0
+        || o.publicUrl !== undefined;
+}
+// Map LabCommandOptions onto the shared exposure validator input.
+function exposureRequestFromOptions(options) {
+    return {
+        expose: options.expose === true,
+        ...(options.tunnel === undefined ? {} : { tunnel: options.tunnel }),
+        ...(options.tunnelDomain === undefined ? {} : { tunnelDomain: options.tunnelDomain }),
+        ...(options.oauth === undefined ? {} : { oauth: options.oauth }),
+        allowEmails: options.allowEmail ?? [],
+        allowDomains: options.allowDomain ?? [],
+        ...(options.publicUrl === undefined ? {} : { publicUrl: options.publicUrl }),
+        safe: options.safe === true
+    };
+}
 function formatInitHuman(result) {
     const title = result.ok
         ? `humanish init ${result.mode}`