@kadj-amoah/showrunner 1.1.3 → 1.1.5

package/dist/cli.js

@@ -1413,10 +1413,10 @@ function extractAndValidate(response, schema) {
   if (response.parsed_output !== void 0 && response.parsed_output !== null) {
     return schema.parse(response.parsed_output);
   }
-  const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+  const text2 = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
   throw new LLMProviderError(
-    text.length > 0 ? `Anthropic returned no parseable structured output. Raw text:
-${text.slice(0, 2e3)}` : "Anthropic returned an empty response with no parseable output.",
+    text2.length > 0 ? `Anthropic returned no parseable structured output. Raw text:
+${text2.slice(0, 2e3)}` : "Anthropic returned an empty response with no parseable output.",
     "anthropic"
   );
 }
@@ -1824,7 +1824,7 @@ async function fileExists2(p) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve27) => setTimeout(resolve27, ms));
+  return new Promise((resolve28) => setTimeout(resolve28, ms));
 }
 
 // src/providers/llm/custom.ts
@@ -2351,20 +2351,20 @@ function isOriginsList(value) {
 function buildFormFill(auth) {
   return async (page) => {
     const email = process.env[auth.fields.email.env];
-    const password = process.env[auth.fields.password.env];
+    const password2 = process.env[auth.fields.password.env];
     if (!email) {
       throw new AuthError(
         `Form auth: env var ${auth.fields.email.env} is not set`
       );
     }
-    if (!password) {
+    if (!password2) {
       throw new AuthError(
         `Form auth: env var ${auth.fields.password.env} is not set`
       );
     }
     await page.goto(auth.login_url);
     await page.fill(auth.fields.email.selector, email);
-    await page.fill(auth.fields.password.selector, password);
+    await page.fill(auth.fields.password.selector, password2);
     await page.click(auth.submit_selector);
     try {
       await page.waitForURL(auth.success_url_pattern, { timeout: auth.timeout_ms });
@@ -2719,9 +2719,9 @@ async function recordDemo(opts) {
     const page = await context.newPage();
     if (recording.cursor_highlight) {
       page.on("console", (msg) => {
-        const text = msg.text();
-        if (text.startsWith("[showrunner-cursor]")) {
-          logger.debug(`browser: ${text}`);
+        const text2 = msg.text();
+        if (text2.startsWith("[showrunner-cursor]")) {
+          logger.debug(`browser: ${text2}`);
         }
       });
     }
@@ -4602,8 +4602,8 @@ async function fileExists7(path) {
     return false;
   }
 }
-function escapeFilterText(text) {
-  return text.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/:/g, "\\:").replace(/,/g, "\\,");
+function escapeFilterText(text2) {
+  return text2.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/:/g, "\\:").replace(/,/g, "\\,");
 }
 function escapeFilterPath(path) {
   return path.replace(/\\/g, "/").replace(/:/g, "\\\\:");
@@ -4680,14 +4680,14 @@ function chunkAlignmentToCues(alignment, segmentStartSec) {
   let lastBoundaryIdx = -1;
   let i = 0;
   const pushCue = (endIdx) => {
-    const text = cueChars.join("").replace(/\s+/g, " ").trim();
-    if (text.length === 0) return;
+    const text2 = cueChars.join("").replace(/\s+/g, " ").trim();
+    if (text2.length === 0) return;
     cues.push({
       index: 0,
       // assigned by caller
       startSec: segmentStartSec + cueStart,
       endSec: segmentStartSec + ends[endIdx],
-      text
+      text: text2
     });
   };
   while (i < chars.length) {
@@ -5317,14 +5317,14 @@ function printRow(r) {
   else logger.info(line);
 }
 async function checkBinary(name, args) {
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     const child = spawn3(name, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
     });
     child.on("error", () => {
-      resolve27({
+      resolve28({
         status: "FAIL",
         label: `${name} not on PATH`,
         detail: installHintFor(name)
@@ -5333,9 +5333,9 @@ async function checkBinary(name, args) {
     child.on("exit", (code) => {
       if (code === 0) {
         const firstLine = stdout.split("\n")[0]?.trim() ?? "";
-        resolve27({ status: "PASS", label: `${name} present`, detail: firstLine });
+        resolve28({ status: "PASS", label: `${name} present`, detail: firstLine });
       } else {
-        resolve27({
+        resolve28({
           status: "FAIL",
           label: `${name} exited with code ${code}`,
           detail: installHintFor(name)
@@ -5595,8 +5595,654 @@ async function runCommand2(opts) {
 }
 
 // src/commands/init.ts
-import { mkdir as mkdir11, writeFile as writeFile12, access as access2 } from "fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute8, join as join10, resolve as resolve15 } from "path";
+import { mkdir as mkdir11, writeFile as writeFile12, access as access3 } from "fs/promises";
+import { dirname as dirname10, isAbsolute as isAbsolute8, join as join11, resolve as resolve15 } from "path";
+
+// src/setup/detect.ts
+import { spawn as spawn4 } from "child_process";
+import { access as access2, stat as stat10 } from "fs/promises";
+async function detectEnvironment() {
+  const [claudeCli, ffmpeg, ffprobe, chromium6] = await Promise.all([
+    isOnPath("claude"),
+    isOnPath("ffmpeg"),
+    isOnPath("ffprobe"),
+    chromiumInstalled()
+  ]);
+  return {
+    claudeCli,
+    ffmpeg,
+    ffprobe,
+    chromium: chromium6,
+    envVars: {
+      anthropic: Boolean(process.env["ANTHROPIC_API_KEY"]),
+      openai: Boolean(process.env["OPENAI_API_KEY"]),
+      elevenlabs: Boolean(process.env["ELEVENLABS_API_KEY"])
+    }
+  };
+}
+async function isOnPath(binary) {
+  return new Promise((resolve28) => {
+    const useShell = process.platform === "win32";
+    const child = spawn4(binary, ["--version"], {
+      stdio: ["ignore", "ignore", "ignore"],
+      shell: useShell
+    });
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve28(ok);
+    };
+    child.on("error", () => finish(false));
+    child.on("exit", (code) => finish(code === 0));
+    setTimeout(() => {
+      if (!settled) {
+        child.kill("SIGKILL");
+        finish(false);
+      }
+    }, 4e3);
+  });
+}
+async function chromiumInstalled() {
+  try {
+    const { chromium: chromium6 } = await import("playwright-core");
+    const exec = chromium6.executablePath();
+    await stat10(exec);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/setup/wizard.ts
+import {
+  intro,
+  outro,
+  text,
+  password,
+  select,
+  confirm,
+  note,
+  spinner,
+  isCancel,
+  cancel
+} from "@clack/prompts";
+
+// src/setup/targetProbe.ts
+import { request as undiciRequest2 } from "undici";
+var DEFAULT_TIMEOUT_MS = 4e3;
+async function probeUrl(url, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const start = Date.now();
+  try {
+    const res = await undiciRequest2(url, {
+      method: "HEAD",
+      bodyTimeout: timeoutMs,
+      headersTimeout: timeoutMs
+    });
+    const elapsedMs = Date.now() - start;
+    return {
+      url,
+      reachable: res.statusCode >= 200 && res.statusCode < 500,
+      statusCode: res.statusCode,
+      elapsedMs
+    };
+  } catch (err) {
+    return {
+      url,
+      reachable: false,
+      reason: err instanceof Error ? err.message : String(err),
+      elapsedMs: Date.now() - start
+    };
+  }
+}
+
+// src/setup/portScan.ts
+var COMMON_DEV_PORTS = [3e3, 3001, 4321, 5173, 5174, 8e3, 8080];
+async function scanLocalPorts(host = "localhost", ports = COMMON_DEV_PORTS, timeoutMs = 800) {
+  const probes = ports.map(async (port) => {
+    const url = `http://${host}:${port}`;
+    const result = await probeUrl(url, timeoutMs);
+    if (!result.reachable) return null;
+    return {
+      url,
+      port,
+      statusCode: result.statusCode ?? 0,
+      elapsedMs: result.elapsedMs ?? 0
+    };
+  });
+  const all = await Promise.all(probes);
+  return all.filter((x) => x !== null).sort((a, b) => a.port - b.port);
+}
+
+// src/setup/agentDiscover.ts
+import { z as z9 } from "zod";
+
+// src/setup/projectSnapshot.ts
+import { readFile as readFile10, readdir as readdir2, stat as stat11 } from "fs/promises";
+import { join as join10, relative } from "path";
+var FILE_CAP_BYTES = 2048;
+var README_LINE_CAP = 100;
+var CONFIG_FILE_PATTERNS = [
+  /^vite\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^next\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^astro\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^nuxt\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^svelte\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^vue\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^webpack\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^remix\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^gatsby-config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^rsbuild\.config\.(?:js|mjs|cjs|ts|mts|cts)$/,
+  /^manage\.py$/,
+  /^pyproject\.toml$/,
+  /^Cargo\.toml$/
+];
+async function collectProjectSnapshot(projectDir) {
+  const sections = [];
+  const pkg = await readFileSafe(join10(projectDir, "package.json"));
+  if (pkg) sections.push({ label: "package.json", path: "package.json", body: pkg });
+  for (const candidate of ["README.md", "readme.md", "README.MD"]) {
+    const r = await readFileSafe(join10(projectDir, candidate), { lineCap: README_LINE_CAP });
+    if (r) {
+      sections.push({ label: "README (head)", path: candidate, body: r });
+      break;
+    }
+  }
+  const envEx = await readFileSafe(join10(projectDir, ".env.example"));
+  if (envEx) sections.push({ label: ".env.example", path: ".env.example", body: envEx });
+  else {
+    const envSample = await readFileSafe(join10(projectDir, ".env.sample"));
+    if (envSample) sections.push({ label: ".env.sample", path: ".env.sample", body: envSample });
+  }
+  let topEntries;
+  try {
+    topEntries = await readdir2(projectDir);
+  } catch {
+    topEntries = [];
+  }
+  for (const entry of topEntries) {
+    if (CONFIG_FILE_PATTERNS.some((re) => re.test(entry))) {
+      const body = await readFileSafe(join10(projectDir, entry));
+      if (body) sections.push({ label: entry, path: entry, body });
+    }
+  }
+  return { projectDir, sections };
+}
+function renderSnapshot(snap) {
+  if (snap.sections.length === 0) {
+    return `(empty or non-readable project at ${snap.projectDir})`;
+  }
+  const out = [];
+  for (const s of snap.sections) {
+    out.push(`### ${s.label} \u2014 ${s.path}`);
+    out.push("```");
+    out.push(s.body.trim());
+    out.push("```");
+    out.push("");
+  }
+  return out.join("\n");
+}
+async function readFileSafe(path, options = {}) {
+  try {
+    const s = await stat11(path);
+    if (!s.isFile()) return null;
+  } catch {
+    return null;
+  }
+  let text2;
+  try {
+    text2 = await readFile10(path, "utf8");
+  } catch {
+    return null;
+  }
+  if (options.lineCap !== void 0) {
+    const lines = text2.split("\n");
+    if (lines.length > options.lineCap) {
+      text2 = lines.slice(0, options.lineCap).join("\n") + `
+\u2026[truncated at ${options.lineCap} lines]`;
+    }
+  }
+  const byteCap = options.byteCap ?? FILE_CAP_BYTES;
+  if (Buffer.byteLength(text2, "utf8") > byteCap) {
+    text2 = text2.slice(0, byteCap) + `
+\u2026[truncated at ${byteCap} bytes]`;
+  }
+  return text2;
+}
+
+// src/setup/agentDiscover.ts
+var DevServerProposalSchema = z9.object({
+  command: z9.string().min(1).describe('Executable name, e.g. "npm" or "pnpm".'),
+  args: z9.array(z9.string()).describe('CLI arguments, e.g. ["run", "dev"].'),
+  url: z9.string().url().describe("URL the dev server will listen on once started."),
+  confidence: z9.enum(["high", "medium", "low"]),
+  rationale: z9.string().min(1).describe("One short sentence on why this is the right command.")
+});
+var SYSTEM_PROMPT = [
+  "You are helping the Showrunner CLI identify how to start a project's development server.",
+  "You will be given a project snapshot (package.json, README head, common framework config files, .env.example).",
+  "",
+  "Your job: identify the command + arguments to run the dev server, and the URL it will listen on.",
+  "",
+  "Rules:",
+  '- Use the scripts in package.json as your primary signal. Prefer "dev" > "start" > "serve" when present.',
+  "- For Vite default port = 5173; Next/CRA = 3000; Astro = 4321; Vue CLI = 8080; Django = 8000.",
+  "- If the project explicitly sets a port (via env, config, or CLI flags), use that, NOT the framework default.",
+  '- If the snapshot is too sparse to tell, set confidence to "low" and use your best guess for both command and URL.',
+  '- "confidence" reflects how sure you are. "high" = explicit script + config-confirmed port; "medium" = explicit script, default port; "low" = guessing.',
+  '- "rationale" is one short sentence, plain English. No marketing speak.',
+  "",
+  "Return only the structured output. No prose outside the JSON."
+].join("\n");
+async function discoverDevServer(projectDir, opts = {}) {
+  const snapshot = await collectProjectSnapshot(projectDir);
+  const rendered = renderSnapshot(snapshot);
+  const provider = new AgentBridgeLLMProvider({
+    mode: "spawn",
+    command: opts.command ?? "claude",
+    args: opts.args ?? ["-p", "--output-format", "json"],
+    timeoutMs: opts.timeoutMs ?? 9e4
+  });
+  const userPrompt = [
+    `Project directory: ${projectDir}`,
+    "",
+    "Project snapshot follows:",
+    "",
+    rendered,
+    "",
+    "Identify the dev-server command + args + URL."
+  ].join("\n");
+  return await provider.generateStructured({
+    systemPrompt: SYSTEM_PROMPT,
+    userPrompt,
+    schema: DevServerProposalSchema,
+    schemaName: "DevServerProposal"
+  });
+}
+
+// src/setup/spawnDevServer.ts
+import { spawn as spawn5 } from "child_process";
+async function spawnAndWait(opts) {
+  const waitTimeoutMs = opts.waitTimeoutMs ?? 6e4;
+  const pollIntervalMs = opts.pollIntervalMs ?? 750;
+  const useShell = process.platform === "win32";
+  let child;
+  try {
+    child = spawn5(opts.command, opts.args, {
+      cwd: opts.cwd,
+      detached: true,
+      stdio: "ignore",
+      shell: useShell
+    });
+    child.unref();
+  } catch (err) {
+    return {
+      ok: false,
+      command: opts.command,
+      args: opts.args,
+      url: opts.url,
+      reason: `failed to spawn: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const pid = child.pid;
+  const start = Date.now();
+  let lastReason = "";
+  while (Date.now() - start < waitTimeoutMs) {
+    if (child.exitCode !== null) {
+      return {
+        ok: false,
+        pid,
+        command: opts.command,
+        args: opts.args,
+        url: opts.url,
+        reason: `child process exited with code ${child.exitCode} before the URL came up`
+      };
+    }
+    const probe = await probeUrl(opts.url, pollIntervalMs);
+    if (probe.reachable) {
+      return {
+        ok: true,
+        pid,
+        command: opts.command,
+        args: opts.args,
+        url: opts.url
+      };
+    }
+    lastReason = probe.reason ?? `HTTP ${probe.statusCode ?? "?"}`;
+    await sleep3(pollIntervalMs);
+  }
+  return {
+    ok: false,
+    pid,
+    command: opts.command,
+    args: opts.args,
+    url: opts.url,
+    reason: `timed out after ${waitTimeoutMs}ms waiting for ${opts.url} (last: ${lastReason}). Child still running as pid ${pid}.`
+  };
+}
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/setup/wizard.ts
+var SLUG_RE = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
+async function runWizard(env) {
+  intro("Showrunner setup");
+  note(formatDetection(env), "Detected on this machine");
+  const projectName = await ask(
+    text({
+      message: "What's the project directory name?",
+      placeholder: "showrunner-demo",
+      defaultValue: "showrunner-demo",
+      validate: (v) => {
+        if (!v) return void 0;
+        if (!SLUG_RE.test(v)) {
+          return "Use letters/digits/dash/underscore/dot, starting & ending with alphanumeric.";
+        }
+        return void 0;
+      }
+    })
+  );
+  if (projectName === null) return null;
+  const resolutionPreset = await ask(
+    select({
+      message: "Recording resolution preset?",
+      options: [
+        { value: "low", label: "low  (854\xD7480) \u2014 draft / fast iteration" },
+        { value: "standard", label: "standard  (1280\xD7720) \u2014 recommended default" },
+        { value: "high", label: "high  (1920\xD71080)" },
+        { value: "extreme", label: "extreme  (3840\xD72160) \u2014 needs serious RAM" }
+      ],
+      initialValue: "standard"
+    })
+  );
+  if (resolutionPreset === null) return null;
+  if (!RESOLUTION_PRESETS.includes(resolutionPreset)) {
+    cancel("Invalid resolution preset.");
+    return null;
+  }
+  const llmDefault = env.claudeCli ? "agent_bridge" : "anthropic";
+  const llm = await ask(
+    select({
+      message: "Which LLM provider should drive comprehension + script?",
+      options: [
+        {
+          value: "agent_bridge",
+          label: env.claudeCli ? "agent_bridge \u2014 uses your local `claude` CLI (detected). No API key required." : "agent_bridge \u2014 uses a local headless agent CLI. No API key required."
+        },
+        {
+          value: "anthropic",
+          label: env.envVars.anthropic ? "anthropic \u2014 Claude via API (ANTHROPIC_API_KEY already in env)" : "anthropic \u2014 Claude via API (you'll paste an API key in a moment)"
+        },
+        {
+          value: "openai",
+          label: env.envVars.openai ? "openai \u2014 GPT via API (OPENAI_API_KEY already in env)" : "openai \u2014 GPT via API (you'll paste an API key in a moment)"
+        }
+      ],
+      initialValue: llmDefault
+    })
+  );
+  if (llm === null) return null;
+  const collectedKeys = {};
+  if (llm === "anthropic" && !env.envVars.anthropic) {
+    const key = await askKey("ANTHROPIC_API_KEY", "https://console.anthropic.com/settings/keys");
+    if (key === null) return null;
+    if (key.length > 0) collectedKeys["ANTHROPIC_API_KEY"] = key;
+  }
+  if (llm === "openai" && !env.envVars.openai) {
+    const key = await askKey("OPENAI_API_KEY", "https://platform.openai.com/api-keys");
+    if (key === null) return null;
+    if (key.length > 0) collectedKeys["OPENAI_API_KEY"] = key;
+  }
+  const ttsDefault = llm === "agent_bridge" && !env.envVars.openai && !env.envVars.elevenlabs ? "custom" : "elevenlabs";
+  const tts = await ask(
+    select({
+      message: "Which TTS provider for voiceover?",
+      options: [
+        {
+          value: "elevenlabs",
+          label: env.envVars.elevenlabs ? "elevenlabs \u2014 best alignment (ELEVENLABS_API_KEY already in env)" : "elevenlabs \u2014 best alignment (you'll paste an API key)"
+        },
+        {
+          value: "openai",
+          label: env.envVars.openai || llm === "openai" ? "openai \u2014 tts-1-hd (reuses your OpenAI key)" : "openai \u2014 tts-1-hd (you'll paste an API key)"
+        },
+        {
+          value: "custom",
+          label: "custom \u2014 plug in your own TTSProvider module. No API key required here."
+        }
+      ],
+      initialValue: ttsDefault
+    })
+  );
+  if (tts === null) return null;
+  if (tts === "elevenlabs" && !env.envVars.elevenlabs) {
+    const key = await askKey("ELEVENLABS_API_KEY", "https://elevenlabs.io/app/settings/api-keys");
+    if (key === null) return null;
+    if (key.length > 0) collectedKeys["ELEVENLABS_API_KEY"] = key;
+  }
+  if (tts === "openai" && !env.envVars.openai && !collectedKeys["OPENAI_API_KEY"]) {
+    const key = await askKey("OPENAI_API_KEY", "https://platform.openai.com/api-keys");
+    if (key === null) return null;
+    if (key.length > 0) collectedKeys["OPENAI_API_KEY"] = key;
+  }
+  const resolved = await resolveTargetUrl({
+    env,
+    llm,
+    projectDir: process.cwd()
+  });
+  if (resolved === null) return null;
+  const url = resolved.url;
+  const proceed = await ask(
+    confirm({
+      message: `Scaffold ${projectName}/ with these choices?`,
+      initialValue: true
+    })
+  );
+  if (proceed === null || proceed === false) {
+    cancel("Setup cancelled. Nothing written.");
+    return null;
+  }
+  outro("Scaffolding now...");
+  return {
+    projectName,
+    url,
+    llm,
+    tts,
+    resolutionPreset,
+    collectedKeys
+  };
+}
+async function askKey(envVar, dashUrl) {
+  const value = await ask(
+    password({
+      message: `Paste your ${envVar} (or press enter to skip and fill .env later)`
+    })
+  );
+  if (value === null) return null;
+  return typeof value === "string" ? value.trim() : "";
+}
+async function ask(promptResult) {
+  const result = await promptResult;
+  if (isCancel(result)) {
+    cancel("Setup cancelled.");
+    return null;
+  }
+  return result;
+}
+function formatDetection(env) {
+  const lines = [];
+  lines.push(`claude CLI:    ${env.claudeCli ? "found" : "not found"}`);
+  lines.push(`ffmpeg:        ${env.ffmpeg ? "found" : "NOT found  \u2190 required for muxing"}`);
+  lines.push(`ffprobe:       ${env.ffprobe ? "found" : "NOT found  \u2190 required for muxing"}`);
+  lines.push(`chromium:      ${env.chromium ? "installed" : "NOT installed  \u2190 run `showrunner install-browser`"}`);
+  lines.push("");
+  lines.push("env vars:");
+  lines.push(`  ANTHROPIC_API_KEY:  ${env.envVars.anthropic ? "set" : "unset"}`);
+  lines.push(`  OPENAI_API_KEY:     ${env.envVars.openai ? "set" : "unset"}`);
+  lines.push(`  ELEVENLABS_API_KEY: ${env.envVars.elevenlabs ? "set" : "unset"}`);
+  return lines.join("\n");
+}
+async function resolveTargetUrl(input) {
+  const { env, llm, projectDir } = input;
+  const initialUrl = await ask(
+    text({
+      message: "What URL is your product dev server on?",
+      placeholder: "http://localhost:3000",
+      defaultValue: "http://localhost:3000",
+      validate: (v) => {
+        if (!v) return void 0;
+        try {
+          new URL(v);
+          return void 0;
+        } catch {
+          return "Must be a valid URL (e.g. http://localhost:3000).";
+        }
+      }
+    })
+  );
+  if (initialUrl === null) return null;
+  const probeSpin = spinner();
+  probeSpin.start(`Probing ${initialUrl} ...`);
+  const directProbe = await probeUrl(initialUrl);
+  if (directProbe.reachable) {
+    probeSpin.stop(`${initialUrl} reachable (HTTP ${directProbe.statusCode}, ${directProbe.elapsedMs}ms).`);
+    return { url: initialUrl };
+  }
+  probeSpin.stop(`${initialUrl} not reachable yet.`);
+  const scanSpin = spinner();
+  scanSpin.start("Scanning common dev-server ports on localhost...");
+  let scanHits = [];
+  try {
+    scanHits = await scanLocalPorts("localhost");
+  } catch {
+  }
+  if (scanHits.length > 0) {
+    scanSpin.stop(`Found ${scanHits.length} responding port${scanHits.length === 1 ? "" : "s"} on localhost.`);
+    const pick = await ask(
+      select({
+        message: "Use one of the running servers?",
+        options: [
+          ...scanHits.map((h) => ({
+            value: h.url,
+            label: `${h.url}  (HTTP ${h.statusCode})`
+          })),
+          { value: "__keep__", label: `No \u2014 keep what I typed (${initialUrl})` },
+          { value: "__agent__", label: "No \u2014 let the agent figure it out (only useful with agent_bridge + claude)" }
+        ],
+        initialValue: scanHits[0]?.url ?? "__keep__"
+      })
+    );
+    if (pick === null) return null;
+    if (pick !== "__keep__" && pick !== "__agent__") {
+      return { url: pick };
+    }
+    if (pick === "__keep__") {
+      warnFallback(initialUrl);
+      return { url: initialUrl, warnedUnreachable: true };
+    }
+  } else {
+    scanSpin.stop("No common dev ports responding on localhost.");
+  }
+  const agentAvailable = llm === "agent_bridge" && env.claudeCli;
+  if (!agentAvailable) {
+    if (scanHits.length === 0) {
+      warnFallback(initialUrl);
+      return { url: initialUrl, warnedUnreachable: true };
+    }
+    return { url: initialUrl, warnedUnreachable: true };
+  }
+  const useAgent = await ask(
+    confirm({
+      message: "Want me to inspect this directory with the `claude` agent and propose a dev-server command + URL?",
+      initialValue: true
+    })
+  );
+  if (useAgent === null) return null;
+  if (useAgent === false) {
+    warnFallback(initialUrl);
+    return { url: initialUrl, warnedUnreachable: true };
+  }
+  const discoverSpin = spinner();
+  discoverSpin.start("Asking the agent to read your project...");
+  let proposal;
+  try {
+    proposal = await discoverDevServer(projectDir);
+    discoverSpin.stop("Agent returned a proposal.");
+  } catch (err) {
+    discoverSpin.stop("Agent inspection failed.");
+    note(
+      `${err instanceof Error ? err.message : String(err)}
+
+Keeping your typed URL for now. Start your server, then run:
+  showrunner set-target -c demo.yaml --url ${initialUrl}`,
+      "Agent error"
+    );
+    return { url: initialUrl, warnedUnreachable: true };
+  }
+  note(formatProposal(proposal, projectDir), "Agent proposal");
+  const spawnIt = await ask(
+    confirm({
+      message: `Spawn \`${proposal.command} ${proposal.args.join(" ")}\` in ${projectDir} and wait for ${proposal.url}?`,
+      initialValue: proposal.confidence !== "low"
+    })
+  );
+  if (spawnIt === null) return null;
+  if (spawnIt === false) {
+    note(
+      `OK \u2014 start the server yourself, then run:
+  showrunner set-target -c demo.yaml --url ${proposal.url}`,
+      "Skipping spawn"
+    );
+    return { url: proposal.url, warnedUnreachable: true };
+  }
+  const spawnSpin = spinner();
+  spawnSpin.start(`Spawning and waiting for ${proposal.url} (up to 60s)...`);
+  const spawnResult = await spawnAndWait({
+    command: proposal.command,
+    args: proposal.args,
+    url: proposal.url,
+    cwd: projectDir
+  });
+  if (spawnResult.ok) {
+    spawnSpin.stop(`Dev server up at ${proposal.url} (pid ${spawnResult.pid}).`);
+    note(
+      `When you're done, stop it with:  kill ${spawnResult.pid}`,
+      "Server running"
+    );
+    return { url: proposal.url, spawnedPid: spawnResult.pid };
+  }
+  spawnSpin.stop(`Spawn or wait failed.`);
+  note(
+    `${spawnResult.reason ?? "unknown error"}
+
+Keeping ${proposal.url} as the configured target. If the server eventually comes up, no action needed; otherwise run:
+  showrunner set-target -c demo.yaml --url <actual-url>`,
+    "Spawn issue"
+  );
+  return { url: proposal.url, warnedUnreachable: true };
+}
+function warnFallback(url) {
+  note(
+    `That's fine \u2014 you can start your dev server later. When it's up, run:
+
+  showrunner set-target -c demo.yaml --url ${url}
+
+to re-probe and update the config.`,
+    "Heads up"
+  );
+}
+function formatProposal(p, cwd) {
+  return [
+    `command:    ${p.command} ${p.args.join(" ")}`,
+    `cwd:        ${cwd}`,
+    `url:        ${p.url}`,
+    `confidence: ${p.confidence}`,
+    `rationale:  ${p.rationale}`
+  ].join("\n");
+}
+
+// src/commands/init.ts
 var LLM_CHOICES = ["anthropic", "openai", "agent_bridge"];
 var TTS_CHOICES = ["elevenlabs", "openai", "custom"];
 var PLACEHOLDER_FILES = [
@@ -5608,22 +6254,52 @@ var PLACEHOLDER_FILES = [
   "output/.gitkeep"
 ];
 async function initCommand(opts) {
-  const resolutionPreset = validateChoice(
-    opts.resolution,
-    [...RESOLUTION_PRESETS],
-    "standard",
-    "--resolution"
-  );
-  const resolved = {
-    ...opts,
-    llm: validateChoice(opts.llmProvider, LLM_CHOICES, "anthropic", "--llm-provider"),
-    tts: validateChoice(opts.ttsProvider, TTS_CHOICES, "elevenlabs", "--tts-provider"),
-    resolutionPreset,
-    resolution: resolvePreset(resolutionPreset)
-  };
-  const parent = isAbsolute8(opts.dir) ? opts.dir : resolve15(process.cwd(), opts.dir);
-  const projectRoot = join10(parent, opts.name);
-  if (!opts.force && await pathExists(projectRoot)) {
+  const wantsInteractive = Boolean(process.stdout.isTTY) && !opts.yes;
+  let resolved;
+  let collectedKeys = {};
+  if (wantsInteractive) {
+    const env = await detectEnvironment();
+    const wiz = await runWizard(env);
+    if (!wiz) return;
+    resolved = {
+      name: wiz.projectName,
+      url: wiz.url,
+      dir: opts.dir,
+      force: opts.force,
+      llm: wiz.llm,
+      tts: wiz.tts,
+      resolutionPreset: wiz.resolutionPreset,
+      resolution: resolvePreset(wiz.resolutionPreset)
+    };
+    collectedKeys = wiz.collectedKeys;
+  } else {
+    const resolutionPreset = validateChoice(
+      opts.resolution,
+      [...RESOLUTION_PRESETS],
+      "standard",
+      "--resolution"
+    );
+    resolved = {
+      ...opts,
+      llm: validateChoice(
+        opts.llmProvider,
+        LLM_CHOICES,
+        "anthropic",
+        "--llm-provider"
+      ),
+      tts: validateChoice(
+        opts.ttsProvider,
+        TTS_CHOICES,
+        "elevenlabs",
+        "--tts-provider"
+      ),
+      resolutionPreset,
+      resolution: resolvePreset(resolutionPreset)
+    };
+  }
+  const parent = isAbsolute8(resolved.dir) ? resolved.dir : resolve15(process.cwd(), resolved.dir);
+  const projectRoot = join11(parent, resolved.name);
+  if (!resolved.force && await pathExists(projectRoot)) {
     logger.error(
       `Directory already exists: ${projectRoot}. Pass --force to overwrite, or choose a different --name/--dir.`
     );
@@ -5631,48 +6307,74 @@ async function initCommand(opts) {
   }
   await mkdir11(projectRoot, { recursive: true });
   for (const rel of PLACEHOLDER_FILES) {
-    const dest = join10(projectRoot, rel);
+    const dest = join11(projectRoot, rel);
     await mkdir11(dirname10(dest), { recursive: true });
     await writeFile12(dest, "", "utf8");
   }
-  await writeFile12(join10(projectRoot, "demo.yaml"), demoYamlTemplate(resolved), "utf8");
-  await writeFile12(join10(projectRoot, ".env.example"), envExampleTemplate(resolved), "utf8");
-  await writeFile12(join10(projectRoot, ".gitignore"), gitignoreTemplate(), "utf8");
-  await mkdir11(join10(projectRoot, "docs"), { recursive: true });
-  await writeFile12(join10(projectRoot, "docs/PRD.md"), prdStubTemplate(resolved), "utf8");
-  await writeFile12(join10(projectRoot, "scripts/manifest.json"), starterManifest(resolved), "utf8");
-  await writeFile12(join10(projectRoot, "scripts/seed_demo_data.sh"), seedScript(), {
+  await writeFile12(join11(projectRoot, "demo.yaml"), demoYamlTemplate(resolved), "utf8");
+  await writeFile12(join11(projectRoot, ".env.example"), envExampleTemplate(resolved), "utf8");
+  await writeFile12(join11(projectRoot, ".gitignore"), gitignoreTemplate(), "utf8");
+  await mkdir11(join11(projectRoot, "docs"), { recursive: true });
+  await writeFile12(join11(projectRoot, "docs/PRD.md"), prdStubTemplate(resolved), "utf8");
+  await writeFile12(join11(projectRoot, "scripts/manifest.json"), starterManifest(resolved), "utf8");
+  await writeFile12(join11(projectRoot, "scripts/seed_demo_data.sh"), seedScript(), {
     mode: 493
   });
-  await writeFile12(join10(projectRoot, "scripts/reset_demo_data.sh"), resetScript(), {
+  await writeFile12(join11(projectRoot, "scripts/reset_demo_data.sh"), resetScript(), {
     mode: 493
   });
-  await writeFile12(join10(projectRoot, "scripts/teardown.sh"), teardownScript(), {
+  await writeFile12(join11(projectRoot, "scripts/teardown.sh"), teardownScript(), {
     mode: 493
   });
-  await writeFile12(join10(projectRoot, "README.md"), readmeTemplate(resolved), "utf8");
+  await writeFile12(join11(projectRoot, "README.md"), readmeTemplate(resolved), "utf8");
+  if (Object.keys(collectedKeys).length > 0) {
+    await writeFile12(join11(projectRoot, ".env"), buildEnvFile(collectedKeys, resolved), "utf8");
+  }
   logger.info(`Showrunner project scaffolded at ${projectRoot} (llm=${resolved.llm}, tts=${resolved.tts})`);
-  printNextSteps(opts.name, resolved);
+  printNextSteps(resolved.name, resolved, collectedKeys);
+}
+function buildEnvFile(keys, resolved) {
+  const lines = [`# Showrunner secrets \u2014 generated by \`showrunner init\`.`];
+  for (const [k, v] of Object.entries(keys)) {
+    lines.push(`${k}=${v}`);
+  }
+  lines.push("");
+  lines.push(`# Optional: form / setup-script auth.`);
+  lines.push(`DEMO_EMAIL=`);
+  lines.push(`DEMO_PASSWORD=`);
+  lines.push("");
+  lines.push(`# Optional log level: debug | info | warn | error`);
+  lines.push(`SHOWRUNNER_LOG_LEVEL=info`);
+  lines.push("");
+  if (resolved.llm === "openai" || resolved.tts === "openai") {
+  }
+  return lines.join("\n");
 }
-function printNextSteps(projectName, resolved) {
+function printNextSteps(projectName, resolved, collectedKeys) {
   const envVars = requiredEnvVars(resolved);
+  const keysProvidedByWizard = Object.keys(collectedKeys);
+  const remainingEnvVars = envVars.filter((v) => !keysProvidedByWizard.includes(v));
   const lines = ["", `Next:`, ""];
   let step = 1;
   lines.push(`  ${step++}. cd ${projectName}`);
-  if (envVars.length > 0) {
-    lines.push(`  ${step++}. cp .env.example .env`);
+  if (envVars.length === 0) {
+    lines.push(
+      `  ${step++}. (.env not needed \u2014 agent_bridge LLM + ${resolved.tts} TTS don't use API keys.)`
+    );
+  } else if (remainingEnvVars.length === 0) {
+    lines.push(`  ${step++}. .env is already populated with the keys you pasted.`);
+  } else {
+    if (keysProvidedByWizard.length === 0) {
+      lines.push(`  ${step++}. cp .env.example .env`);
+    }
     lines.push(`  ${step++}. Edit .env to fill in:`);
-    for (const v of envVars) {
+    for (const v of remainingEnvVars) {
       const dash = PROVIDER_DASHBOARDS[v];
       lines.push(`       ${v}${dash ? `  (get it at ${dash})` : ""}`);
     }
     lines.push(
       `     (No keys? Switch llm.default.provider to \`agent_bridge\` in demo.yaml \u2014 uses your local Claude CLI instead.)`
     );
-  } else {
-    lines.push(
-      `  ${step++}. (.env not needed \u2014 agent_bridge LLM + ${resolved.tts} TTS don't use API keys.)`
-    );
   }
   lines.push(`  ${step++}. Edit docs/PRD.md (the stub explains what each section is for).`);
   lines.push(`  ${step++}. showrunner doctor -c demo.yaml`);
@@ -5708,7 +6410,7 @@ function validateChoice(value, allowed, defaultValue, flagName) {
 }
 async function pathExists(p) {
   try {
-    await access2(p);
+    await access3(p);
     return true;
   } catch {
     return false;
@@ -6127,22 +6829,22 @@ and \`at_word\` actions degrade to \`at\`).
 }
 
 // src/commands/installBrowser.ts
-import { spawn as spawn4 } from "child_process";
-import { access as access3 } from "fs/promises";
+import { spawn as spawn6 } from "child_process";
+import { access as access4 } from "fs/promises";
 import { fileURLToPath } from "url";
-import { dirname as dirname11, join as join11 } from "path";
+import { dirname as dirname11, join as join12 } from "path";
 var DEFAULT_BROWSER = "chromium";
 async function installBrowserCommand(opts) {
   const browser = opts.browser ?? DEFAULT_BROWSER;
   const cli = await resolvePlaywrightCoreCli();
   logger.info(`installing Playwright ${browser} (via bundled playwright-core, no project required)`);
-  const child = spawn4(process.execPath, [cli, "install", browser], {
+  const child = spawn6(process.execPath, [cli, "install", browser], {
     stdio: "inherit",
     env: process.env
   });
-  const code = await new Promise((resolve27, reject) => {
+  const code = await new Promise((resolve28, reject) => {
     child.on("error", reject);
-    child.on("close", (c) => resolve27(c ?? 0));
+    child.on("close", (c) => resolve28(c ?? 0));
   });
   if (code !== 0) {
     logger.error(`playwright install exited with code ${code}`);
@@ -6155,9 +6857,9 @@ async function resolvePlaywrightCoreCli() {
   let dir = dirname11(here);
   const root = dir.split(/[\\/]/)[0] + "/";
   while (dir && dir !== root) {
-    const candidate = join11(dir, "node_modules", "playwright-core", "cli.js");
+    const candidate = join12(dir, "node_modules", "playwright-core", "cli.js");
     try {
-      await access3(candidate);
+      await access4(candidate);
       return candidate;
     } catch {
     }
@@ -6170,9 +6872,60 @@ async function resolvePlaywrightCoreCli() {
   );
 }
 
-// src/commands/validate.ts
-import { stat as stat10 } from "fs/promises";
+// src/commands/setTarget.ts
+import { readFile as readFile11, writeFile as writeFile13 } from "fs/promises";
 import { isAbsolute as isAbsolute9, resolve as resolve16 } from "path";
+import yaml2 from "js-yaml";
+async function setTargetCommand(opts) {
+  try {
+    new URL(opts.url);
+  } catch {
+    logger.error(`Invalid URL: ${opts.url}`);
+    process.exit(2);
+  }
+  try {
+    await loadConfig(opts.config);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      logger.error(err.message);
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (!opts.force) {
+    logger.info(`probing ${opts.url} ...`);
+    const probe = await probeUrl(opts.url);
+    if (!probe.reachable) {
+      logger.error(
+        `target ${opts.url} not reachable${probe.reason ? ` (${probe.reason})` : ""}. Start your dev server first, or pass --force to set the URL anyway.`
+      );
+      process.exit(1);
+    }
+    logger.info(`reachable (HTTP ${probe.statusCode}, ${probe.elapsedMs}ms).`);
+  }
+  const absPath = isAbsolute9(opts.config) ? opts.config : resolve16(process.cwd(), opts.config);
+  const rawText = await readFile11(absPath, "utf8");
+  const doc = yaml2.load(rawText);
+  if (!doc || typeof doc !== "object" || !doc["recording"] || typeof doc["recording"] !== "object") {
+    logger.error(
+      `config has no \`recording\` block \u2014 has it been edited by hand into an invalid shape?`
+    );
+    process.exit(2);
+  }
+  doc["recording"]["target_url"] = opts.url;
+  const newText = yaml2.dump(doc, {
+    lineWidth: 100,
+    noRefs: true,
+    sortKeys: false
+  });
+  await writeFile13(absPath, newText, "utf8");
+  logger.info(`updated recording.target_url \u2192 ${opts.url}`);
+  logger.info(`(comments in demo.yaml may have been stripped \u2014 re-add them if needed.)`);
+}
+
+// src/commands/validate.ts
+import { stat as stat12 } from "fs/promises";
+import { isAbsolute as isAbsolute10, resolve as resolve17 } from "path";
 async function validateCommand(opts) {
   try {
     process.loadEnvFile?.();
@@ -6207,9 +6960,9 @@ async function checkReferencedPaths(config, configDir) {
   const warnings = [];
   const check = async (relPath, label) => {
     if (!relPath) return;
-    const abs = isAbsolute9(relPath) ? relPath : resolve16(configDir, relPath);
+    const abs = isAbsolute10(relPath) ? relPath : resolve17(configDir, relPath);
     try {
-      await stat10(abs);
+      await stat12(abs);
     } catch {
       warnings.push(`${label} not found: ${abs}`);
     }
@@ -6237,7 +6990,7 @@ async function checkReferencedPaths(config, configDir) {
 }
 
 // src/commands/printVo.ts
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 async function printVoCommand(opts) {
   let loaded;
   try {
@@ -6249,7 +7002,7 @@ async function printVoCommand(opts) {
     }
     throw err;
   }
-  const manifestPath = resolve17(loaded.configDir, "./scripts/manifest.json");
+  const manifestPath = resolve18(loaded.configDir, "./scripts/manifest.json");
   let manifest;
   try {
     manifest = await readManifest(manifestPath);
@@ -6260,13 +7013,13 @@ async function printVoCommand(opts) {
     }
     throw err;
   }
-  const text = renderVoScript(manifest, { projectName: loaded.config.project.name });
-  process.stdout.write(text);
+  const text2 = renderVoScript(manifest, { projectName: loaded.config.project.name });
+  process.stdout.write(text2);
 }
 
 // src/commands/approveVo.ts
-import { rm as rm2, stat as stat11 } from "fs/promises";
-import { resolve as resolve18 } from "path";
+import { rm as rm2, stat as stat13 } from "fs/promises";
+import { resolve as resolve19 } from "path";
 async function approveVoCommand(opts) {
   let loaded;
   try {
@@ -6278,9 +7031,9 @@ async function approveVoCommand(opts) {
     }
     throw err;
   }
-  const manifestPath = resolve18(loaded.configDir, "./scripts/manifest.json");
-  const voScriptPath = resolve18(loaded.configDir, "./scripts/vo_script.txt");
-  const lockPath = resolve18(loaded.configDir, ".showrunner-lock");
+  const manifestPath = resolve19(loaded.configDir, "./scripts/manifest.json");
+  const voScriptPath = resolve19(loaded.configDir, "./scripts/vo_script.txt");
+  const lockPath = resolve19(loaded.configDir, ".showrunner-lock");
   let manifest;
   try {
     manifest = await readManifest(manifestPath);
@@ -6313,7 +7066,7 @@ async function approveVoCommand(opts) {
 }
 async function pathExists2(p) {
   try {
-    await stat11(p);
+    await stat13(p);
     return true;
   } catch {
     return false;
@@ -6321,8 +7074,8 @@ async function pathExists2(p) {
 }
 
 // src/commands/rerunSegment.ts
-import { mkdir as mkdir12, rename as rename3, writeFile as writeFile13 } from "fs/promises";
-import { join as join12, resolve as resolve19 } from "path";
+import { mkdir as mkdir12, rename as rename3, writeFile as writeFile14 } from "fs/promises";
+import { join as join13, resolve as resolve20 } from "path";
 import { chromium as chromium4, firefox as firefox4, webkit as webkit4 } from "playwright-core";
 var RERUN_BUFFER_MS = 500;
 var browserMap4 = { chromium: chromium4, firefox: firefox4, webkit: webkit4 };
@@ -6338,8 +7091,8 @@ async function rerunSegmentCommand(opts) {
     throw err;
   }
   const { config, configDir } = loaded;
-  const manifestPath = resolve19(configDir, "./scripts/manifest.json");
-  const videoDir = resolve19(configDir, config.recording.output_dir);
+  const manifestPath = resolve20(configDir, "./scripts/manifest.json");
+  const videoDir = resolve20(configDir, config.recording.output_dir);
   let manifest;
   try {
     manifest = await readManifest(manifestPath);
@@ -6439,9 +7192,9 @@ async function rerunSegmentCommand(opts) {
       }
     }
     await page.waitForTimeout(config.recording.segment_buffer_ms);
-    const traceDir = resolve19(configDir, config.recording.trace_dir);
+    const traceDir = resolve20(configDir, config.recording.trace_dir);
     await mkdir12(traceDir, { recursive: true });
-    await ctx.tracing.stopChunk({ path: join12(traceDir, `${segment.id}.zip`) });
+    await ctx.tracing.stopChunk({ path: join13(traceDir, `${segment.id}.zip`) });
     const videoHandle = page.video();
     await ctx.close();
     if (!videoHandle) {
@@ -6449,10 +7202,10 @@ async function rerunSegmentCommand(opts) {
       process.exit(1);
     }
     const original = await videoHandle.path();
-    const dest = join12(videoDir, `${segment.id}.webm`);
+    const dest = join13(videoDir, `${segment.id}.webm`);
     await rename3(original, dest);
-    const metadataPath = join12(videoDir, `${segment.id}.rerun.json`);
-    await writeFile13(
+    const metadataPath = join13(videoDir, `${segment.id}.rerun.json`);
+    await writeFile14(
       metadataPath,
       JSON.stringify(
         {
@@ -6480,12 +7233,12 @@ async function rerunSegmentCommand(opts) {
 
 // src/commands/captureAuth.ts
 import { mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname12, isAbsolute as isAbsolute10, resolve as resolve21 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute11, resolve as resolve22 } from "path";
 import { createInterface } from "readline/promises";
 
 // src/recording/headed.ts
 import { mkdir as mkdir13 } from "fs/promises";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 import {
   chromium as chromium5,
   firefox as firefox5,
@@ -6499,7 +7252,7 @@ async function launchHeadedSession(opts) {
     viewport: { width: recording.viewport.width, height: recording.viewport.height }
   };
   if (opts.recordVideo) {
-    const videoDir = resolve20(configDir, recording.output_dir);
+    const videoDir = resolve21(configDir, recording.output_dir);
     await mkdir13(videoDir, { recursive: true });
     contextOptions.recordVideo = {
       dir: videoDir,
@@ -6531,9 +7284,9 @@ async function launchHeadedSession(opts) {
   const page = await context.newPage();
   if (opts.withCursor) {
     page.on("console", (msg) => {
-      const text = msg.text();
-      if (text.startsWith("[showrunner-cursor]")) {
-        logger.debug(`browser: ${text}`);
+      const text2 = msg.text();
+      if (text2.startsWith("[showrunner-cursor]")) {
+        logger.debug(`browser: ${text2}`);
       }
     });
   }
@@ -6560,13 +7313,13 @@ async function captureAuthCommand(opts) {
     }
     throw err;
   }
-  const envFile = resolve21(loaded.configDir, ".env");
+  const envFile = resolve22(loaded.configDir, ".env");
   try {
     process.loadEnvFile(envFile);
   } catch {
   }
   const cookiesRel = opts.outputCookies ?? "./auth/session.json";
-  const cookiesPath = isAbsolute10(cookiesRel) ? cookiesRel : resolve21(loaded.configDir, cookiesRel);
+  const cookiesPath = isAbsolute11(cookiesRel) ? cookiesRel : resolve22(loaded.configDir, cookiesRel);
   await mkdir14(dirname12(cookiesPath), { recursive: true });
   logger.info("Launching headed browser for auth capture", {
     target: loaded.config.recording.target_url,
@@ -6607,8 +7360,8 @@ Then re-run \`showrunner run --config <demo.yaml>\`.
 }
 
 // src/commands/trace.ts
-import { readdir as readdir2, stat as stat12 } from "fs/promises";
-import { isAbsolute as isAbsolute11, join as join13, resolve as resolve22 } from "path";
+import { readdir as readdir3, stat as stat14 } from "fs/promises";
+import { isAbsolute as isAbsolute12, join as join14, resolve as resolve23 } from "path";
 async function traceCommand(opts) {
   let loaded;
   try {
@@ -6620,9 +7373,9 @@ async function traceCommand(opts) {
     }
     throw err;
   }
-  const traceDir = resolve22(loaded.configDir, loaded.config.recording.trace_dir);
-  const videoDir = resolve22(loaded.configDir, loaded.config.recording.output_dir);
-  const slicePlanPath = join13(videoDir, "slice_plan.json");
+  const traceDir = resolve23(loaded.configDir, loaded.config.recording.trace_dir);
+  const videoDir = resolve23(loaded.configDir, loaded.config.recording.output_dir);
+  const slicePlanPath = join14(videoDir, "slice_plan.json");
   if (opts.all) {
     let plan;
     try {
@@ -6633,14 +7386,14 @@ async function traceCommand(opts) {
       process.exit(1);
     }
     for (const seg of plan.segments) {
-      const tracePath = seg.trace_path && isAbsolute11(seg.trace_path) ? seg.trace_path : seg.trace_path ? resolve22(loaded.configDir, seg.trace_path) : join13(traceDir, `${seg.id}.zip`);
+      const tracePath = seg.trace_path && isAbsolute12(seg.trace_path) ? seg.trace_path : seg.trace_path ? resolve23(loaded.configDir, seg.trace_path) : join14(traceDir, `${seg.id}.zip`);
       logger.info(`Opening trace for ${seg.id}`, { path: tracePath });
       await openTrace(tracePath);
     }
     return;
   }
   if (opts.segment) {
-    const tracePath = join13(traceDir, `${opts.segment}.zip`);
+    const tracePath = join14(traceDir, `${opts.segment}.zip`);
     if (!await fileExists8(tracePath)) {
       logger.error(`No trace found at ${tracePath}`);
       process.exit(1);
@@ -6681,7 +7434,7 @@ async function openTrace(tracePath) {
 }
 async function listTraces(dir) {
   try {
-    const entries = await readdir2(dir);
+    const entries = await readdir3(dir);
     return entries.filter((e) => e.endsWith(".zip")).sort();
   } catch {
     return [];
@@ -6689,7 +7442,7 @@ async function listTraces(dir) {
 }
 async function fileExists8(path) {
   try {
-    await stat12(path);
+    await stat14(path);
     return true;
   } catch {
     return false;
@@ -6697,8 +7450,8 @@ async function fileExists8(path) {
 }
 
 // src/commands/preview.ts
-import { stat as stat13 } from "fs/promises";
-import { resolve as resolve23 } from "path";
+import { stat as stat15 } from "fs/promises";
+import { resolve as resolve24 } from "path";
 async function previewCommand(opts) {
   let loaded;
   try {
@@ -6710,7 +7463,7 @@ async function previewCommand(opts) {
     }
     throw err;
   }
-  const previewSpec = resolve23(loaded.configDir, "./scripts/playwright_demo.spec.ts");
+  const previewSpec = resolve24(loaded.configDir, "./scripts/playwright_demo.spec.ts");
   if (!await fileExists9(previewSpec)) {
     logger.error(
       `No preview spec at ${previewSpec}. Run \`showrunner run --stages script\` first to generate it.`
@@ -6736,7 +7489,7 @@ async function previewCommand(opts) {
 }
 async function fileExists9(path) {
   try {
-    await stat13(path);
+    await stat15(path);
     return true;
   } catch {
     return false;
@@ -6744,8 +7497,8 @@ async function fileExists9(path) {
 }
 
 // src/commands/understand.ts
-import { mkdir as mkdir15, readFile as readFile10, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname13, isAbsolute as isAbsolute12, resolve as resolve24 } from "path";
+import { mkdir as mkdir15, readFile as readFile12, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname13, isAbsolute as isAbsolute13, resolve as resolve25 } from "path";
 
 // src/productModel/prompts.ts
 var PRODUCT_MODEL_SYSTEM_PROMPT = `You build product_model.json for Showrunner, an automated product demo recorder.
@@ -6869,13 +7622,13 @@ var LineReader = class {
     if (this.closed) {
       return Promise.reject(new Error("stdin closed before answer was provided"));
     }
-    return new Promise((resolve27, reject) => {
-      this.waiter = resolve27;
+    return new Promise((resolve28, reject) => {
+      this.waiter = resolve28;
       this.rejecter = reject;
     });
   }
 };
-async function ask(reader, prompt) {
+async function ask2(reader, prompt) {
   process.stdout.write(prompt);
   return reader.read();
 }
@@ -6886,23 +7639,23 @@ async function runInteractiveQA() {
     process.stdout.write(
       "\nLet's build a product_model interactively. Answer each prompt with a short line.\n\n"
     );
-    const productName = (await ask(reader, "1. Product name: ")).trim();
+    const productName = (await ask2(reader, "1. Product name: ")).trim();
     if (!productName) throw new Error("product name is required");
-    const tagline = (await ask(reader, "2. One-sentence tagline: ")).trim();
-    const primaryUser = (await ask(reader, "3. Who is the primary user? ")).trim();
-    const featuresLine = (await ask(reader, "4. Top 3-6 features, comma-separated:\n   ")).trim();
+    const tagline = (await ask2(reader, "2. One-sentence tagline: ")).trim();
+    const primaryUser = (await ask2(reader, "3. Who is the primary user? ")).trim();
+    const featuresLine = (await ask2(reader, "4. Top 3-6 features, comma-separated:\n   ")).trim();
     const topFeatures = featuresLine.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    const flowCountStr = (await ask(reader, "5. How many flows would you like to demo (2-4)? ")).trim();
+    const flowCountStr = (await ask2(reader, "5. How many flows would you like to demo (2-4)? ")).trim();
     const flowCount = clamp(parseInt(flowCountStr, 10) || 2, 2, 4);
     const topFlows = [];
     for (let i = 0; i < flowCount; i++) {
-      const name = (await ask(reader, `   Flow ${i + 1} name: `)).trim();
-      const stepsLine = (await ask(reader, `   Flow ${i + 1} steps, '|' separated:
+      const name = (await ask2(reader, `   Flow ${i + 1} name: `)).trim();
+      const stepsLine = (await ask2(reader, `   Flow ${i + 1} steps, '|' separated:
    `)).trim();
       const steps = stepsLine.split("|").map((s) => s.trim()).filter((s) => s.length > 0);
       topFlows.push({ name, steps });
     }
-    const durationStr = (await ask(reader, "6. Target demo duration in seconds (60-120, default 75): ")).trim();
+    const durationStr = (await ask2(reader, "6. Target demo duration in seconds (60-120, default 75): ")).trim();
     const suggestedDurationSeconds = clamp(parseInt(durationStr, 10) || 75, 30, 180);
     return {
       productName,
@@ -6943,13 +7696,13 @@ async function understandCommand(opts) {
     }
     sources = loaded.config.comprehension.sources.map((s) => ({ path: s.path, type: s.type }));
     llmConfig = loaded.config.llm;
-    const envFile = resolve24(loaded.configDir, ".env");
+    const envFile = resolve25(loaded.configDir, ".env");
     try {
       process.loadEnvFile(envFile);
     } catch {
     }
   }
-  const outputPath = isAbsolute12(outputRel) ? outputRel : resolve24(configDir, outputRel);
+  const outputPath = isAbsolute13(outputRel) ? outputRel : resolve25(configDir, outputRel);
   await mkdir15(dirname13(outputPath), { recursive: true });
   let productModel;
   const provider = resolveDefaultLLMProvider({ configDir, llm: llmConfig });
@@ -6967,9 +7720,9 @@ async function understandCommand(opts) {
       }
       const docs = [];
       for (const src of sources) {
-        const abs = isAbsolute12(src.path) ? src.path : resolve24(configDir, src.path);
+        const abs = isAbsolute13(src.path) ? src.path : resolve25(configDir, src.path);
         try {
-          const content = await readFile10(abs, "utf8");
+          const content = await readFile12(abs, "utf8");
           docs.push({ path: src.path, type: src.type, content });
         } catch (err) {
           const cause = err instanceof Error ? err.message : String(err);
@@ -6992,16 +7745,16 @@ async function understandCommand(opts) {
     }
     throw err;
   }
-  await writeFile14(outputPath, JSON.stringify(productModel, null, 2) + "\n", "utf8");
+  await writeFile15(outputPath, JSON.stringify(productModel, null, 2) + "\n", "utf8");
   logger.info("Wrote product_model.json", { path: outputPath });
 }
 
 // src/commands/instrument.ts
-import { mkdir as mkdir16, readdir as readdir3, writeFile as writeFile15 } from "fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute13, join as join14, resolve as resolve25, relative as relative2 } from "path";
+import { mkdir as mkdir16, readdir as readdir4, writeFile as writeFile16 } from "fs/promises";
+import { dirname as dirname14, isAbsolute as isAbsolute14, join as join15, resolve as resolve26, relative as relative3 } from "path";
 
 // src/instrument/scan.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
 var traverse = _traverse.default ?? _traverse;
@@ -7019,7 +7772,7 @@ var TARGET_TAGS = /* @__PURE__ */ new Set([
   "Form"
 ]);
 async function scanFile(filePath) {
-  const source = await readFile11(filePath, "utf8");
+  const source = await readFile13(filePath, "utf8");
   let ast;
   try {
     ast = parse(source, {
@@ -7078,23 +7831,23 @@ function pickAttr(node, attr) {
 }
 
 // src/instrument/suggest.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var DEFAULT_MAX_TOKENS5 = 8e3;
-var suggestionSchema = z9.object({
-  suggestions: z9.array(
-    z9.object({
-      file: z9.string(),
-      line: z9.number().int().positive(),
-      original: z9.string(),
-      replacement: z9.string(),
-      reasoning: z9.string().default("")
+var suggestionSchema = z10.object({
+  suggestions: z10.array(
+    z10.object({
+      file: z10.string(),
+      line: z10.number().int().positive(),
+      original: z10.string(),
+      replacement: z10.string(),
+      reasoning: z10.string().default("")
     })
   )
 });
 var InstrumentSuggestionError = class extends Error {
   name = "InstrumentSuggestionError";
 };
-var SYSTEM_PROMPT = `You add data-testid attributes to JSX elements so they can be reliably targeted by automated demo tools.
+var SYSTEM_PROMPT2 = `You add data-testid attributes to JSX elements so they can be reliably targeted by automated demo tools.
 
 Rules:
 - For each candidate, propose a stable kebab-case data-testid based on visible text, surrounding context, or the element's role. Examples: "login-submit", "new-article-button", "todo-item-toggle".
@@ -7121,7 +7874,7 @@ For each, return {file, line, original (exact source line), replacement (source
   });
   try {
     const result = await opts.provider.generateStructured({
-      systemPrompt: SYSTEM_PROMPT,
+      systemPrompt: SYSTEM_PROMPT2,
       userPrompt,
       schema: suggestionSchema,
       schemaName: "instrument_suggestions",
@@ -7136,8 +7889,8 @@ For each, return {file, line, original (exact source line), replacement (source
 }
 
 // src/instrument/diff.ts
-import { readFile as readFile12 } from "fs/promises";
-import { relative } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { relative as relative2 } from "path";
 async function buildDiff(suggestions, opts = {}) {
   const byFile = /* @__PURE__ */ new Map();
   for (const s of suggestions) {
@@ -7150,7 +7903,7 @@ async function buildDiff(suggestions, opts = {}) {
   for (const [file, perFile] of byFile) {
     let source;
     try {
-      source = await readFile12(file, "utf8");
+      source = await readFile14(file, "utf8");
     } catch (err) {
       for (const s of perFile) {
         skipped.push({
@@ -7186,7 +7939,7 @@ async function buildDiff(suggestions, opts = {}) {
       );
     }
     if (hunks.length === 0) continue;
-    const displayPath = opts.basePath ? relative(opts.basePath, file).replace(/\\/g, "/") : file;
+    const displayPath = opts.basePath ? relative2(opts.basePath, file).replace(/\\/g, "/") : file;
     fileDiffs.push(`--- a/${displayPath}
 +++ b/${displayPath}
 ${hunks.join("\n")}`);
@@ -7206,7 +7959,7 @@ async function instrumentCommand(opts) {
     }
     throw err;
   }
-  const envFile = resolve25(loaded.configDir, ".env");
+  const envFile = resolve26(loaded.configDir, ".env");
   try {
     process.loadEnvFile(envFile);
   } catch {
@@ -7221,13 +7974,13 @@ async function instrumentCommand(opts) {
   const filesToScan = /* @__PURE__ */ new Set();
   const IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
   async function walk(root, accept) {
-    const entries = await readdir3(root, { withFileTypes: true });
+    const entries = await readdir4(root, { withFileTypes: true });
     for (const entry of entries) {
-      const abs = join14(root, entry.name);
+      const abs = join15(root, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         await walk(abs, accept);
-      } else if (entry.isFile() && accept(relative2(root, abs))) {
+      } else if (entry.isFile() && accept(relative3(root, abs))) {
         filesToScan.add(abs);
       }
     }
@@ -7238,7 +7991,7 @@ async function instrumentCommand(opts) {
     await walk(root, isJsxFile);
   } else {
     for (const src of codebaseSources) {
-      const root = isAbsolute13(src.path) ? src.path : resolve25(loaded.configDir, src.path);
+      const root = isAbsolute14(src.path) ? src.path : resolve26(loaded.configDir, src.path);
       await walk(root, isJsxFile);
     }
   }
@@ -7279,9 +8032,9 @@ async function instrumentCommand(opts) {
   for (const s of skipped) {
     logger.warn(`Skipped suggestion at ${s.file}:${s.line} \u2014 ${s.reason}`);
   }
-  const outputPath = isAbsolute13(opts.output) ? opts.output : resolve25(loaded.configDir, opts.output);
+  const outputPath = isAbsolute14(opts.output) ? opts.output : resolve26(loaded.configDir, opts.output);
   await mkdir16(dirname14(outputPath), { recursive: true });
-  await writeFile15(outputPath, patch, "utf8");
+  await writeFile16(outputPath, patch, "utf8");
   logger.info("Wrote instrumentation patch", { path: outputPath, suggestions: suggestions.length });
   process.stdout.write(`
 Apply with:  cd ${loaded.configDir} && git apply ${opts.output}
@@ -7291,8 +8044,8 @@ Apply with:  cd ${loaded.configDir} && git apply ${opts.output}
 
 // src/commands/recordActions.ts
 import { createInterface as createInterface3 } from "readline/promises";
-import { resolve as resolve26 } from "path";
-import { stat as stat14 } from "fs/promises";
+import { resolve as resolve27 } from "path";
+import { stat as stat16 } from "fs/promises";
 
 // src/recording/captureEvents.ts
 async function installCaptureBinding(context, onEvent) {
@@ -7490,12 +8243,12 @@ async function recordActionsCommand(opts) {
     }
     throw err;
   }
-  const envFile = resolve26(loaded.configDir, ".env");
+  const envFile = resolve27(loaded.configDir, ".env");
   try {
     process.loadEnvFile(envFile);
   } catch {
   }
-  const manifestPath = opts.output ? resolve26(loaded.configDir, opts.output) : resolve26(loaded.configDir, "./scripts/manifest.json");
+  const manifestPath = opts.output ? resolve27(loaded.configDir, opts.output) : resolve27(loaded.configDir, "./scripts/manifest.json");
   logger.info("Launching headed browser for action capture", {
     target: loaded.config.recording.target_url
   });
@@ -7606,7 +8359,7 @@ async function mergeIntoManifest(opts) {
 }
 async function fileExists10(path) {
   try {
-    await stat14(path);
+    await stat16(path);
     return true;
   } catch {
     return false;
@@ -7615,7 +8368,7 @@ async function fileExists10(path) {
 
 // src/cli.ts
 var program = new Command();
-program.name("showrunner").description("Automated product demo recording & production tool").version("1.1.3").option("--json", "emit structured JSON logs to stdout").option("--log-level <level>", "log level (debug|info|warn|error)").hook("preAction", (thisCmd) => {
+program.name("showrunner").description("Automated product demo recording & production tool").version("1.1.5").option("--json", "emit structured JSON logs to stdout").option("--log-level <level>", "log level (debug|info|warn|error)").hook("preAction", (thisCmd) => {
   const opts = thisCmd.opts();
   if (opts.json) logger.setJson(true);
   if (opts.logLevel) logger.setLevel(opts.logLevel);
@@ -7635,7 +8388,7 @@ program.command("run").description("Run the full Showrunner pipeline").requiredO
   "--resolution <preset>",
   "override resolution for this run: low (854x480), standard (720p), high (1080p), extreme (4K)"
 ).action(runCommand2);
-program.command("init").description("Scaffold a new Showrunner project").option("--name <name>", "project name", "showrunner-demo").option("--url <url>", "target URL of the product to demo", "http://localhost:3000").option("--dir <dir>", "parent directory in which to create the project", process.cwd()).option("--force", "overwrite an existing directory", false).option(
+program.command("init").description("Scaffold a new Showrunner project (interactive by default; use --yes to skip prompts)").option("--name <name>", "project name", "showrunner-demo").option("--url <url>", "target URL of the product to demo", "http://localhost:3000").option("--dir <dir>", "parent directory in which to create the project", process.cwd()).option("--force", "overwrite an existing directory", false).option("--yes", "skip interactive prompts and use defaults / passed flags", false).option(
   "--llm-provider <name>",
   "LLM provider for comprehension + script + instrument (anthropic | openai | agent_bridge)",
   "anthropic"
@@ -7648,6 +8401,7 @@ program.command("init").description("Scaffold a new Showrunner project").option(
   "scaffold resolution: low (854x480) | standard (720p) | high (1080p) | extreme (4K)",
   "standard"
 ).action(initCommand);
+program.command("set-target").description("Update demo.yaml's recording.target_url and re-probe it").requiredOption("-c, --config <path>", "path to demo.yaml").requiredOption("--url <url>", "new target URL (e.g. http://localhost:5173)").option("--force", "skip the reachability probe and update the URL anyway", false).action(setTargetCommand);
 program.command("install-browser").description("Install the Playwright browser binary (chromium by default) \u2014 wraps playwright-core install").option("--browser <name>", "browser to install: chromium | firefox | webkit", "chromium").action(installBrowserCommand);
 program.command("doctor").description("Run preflight checks on the current config + environment").requiredOption("-c, --config <path>", "path to demo.yaml").option("--json", "emit results as JSON instead of human-readable rows").action(doctorCommand);
 program.command("validate").description("Validate a demo.yaml config file").requiredOption("-c, --config <path>", "path to demo.yaml").option("--strict", "exit nonzero on any warning (e.g. missing provider env var)").action(validateCommand);
@@ -7666,17 +8420,17 @@ program.parseAsync(process.argv).catch((err) => {
   process.exit(1);
 });
 async function printWelcome() {
-  const { access: access4 } = await import("fs/promises");
-  const { resolve: resolve27 } = await import("path");
-  const demoYaml = resolve27(process.cwd(), "demo.yaml");
+  const { access: access5 } = await import("fs/promises");
+  const { resolve: resolve28 } = await import("path");
+  const demoYaml = resolve28(process.cwd(), "demo.yaml");
   let inProject = false;
   try {
-    await access4(demoYaml);
+    await access5(demoYaml);
     inProject = true;
   } catch {
   }
   const browserMissing = await isChromiumMissing();
-  const lines = ["", `Showrunner v1.1.3`, ""];
+  const lines = ["", `Showrunner v1.1.5`, ""];
   if (browserMissing) {
     lines.push(`Showrunner records using Chromium. You haven't installed it yet.`);
     lines.push(``);
@@ -7704,8 +8458,8 @@ async function isChromiumMissing() {
   try {
     const { chromium: chromium6 } = await import("playwright-core");
     const exec = chromium6.executablePath();
-    const { stat: stat15 } = await import("fs/promises");
-    await stat15(exec);
+    const { stat: stat17 } = await import("fs/promises");
+    await stat17(exec);
     return false;
   } catch {
     return true;