@vercel/dream 0.2.7 → 0.2.8

package/dist/dream.js

@@ -3,9 +3,11 @@
 // bin/dream.ts
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
 import { createOpencode } from "@opencode-ai/sdk/v2";
 import { init } from "@vercel/dream-init";
 import { program } from "commander";
+import { $ } from "zx";
 var STOP_WORD = "<DREAM DONE>";
 var PROJECT_PROMPT_FILES = [
   "loop-prompt.md",
@@ -87,7 +89,7 @@ Context for next iteration.
 
 ## Browser Automation
 
-You have \`agent-browser\` available for UI verification.
+Dream bootstraps \`agent-browser\` before the loop starts. Use it for UI verification.
 
 Use it to test running app routes (typically localhost dev server or preview URL), not only static files.
 
@@ -122,62 +124,106 @@ ${STOP_WORD}
 Without this signal, the system keeps launching new iterations.`;
 var DEFAULT_TIMEOUT = 36e5;
 var DEFAULT_MAX_ITERATIONS = 100;
-var DEFAULT_MODEL = "vercel/anthropic/claude-opus-4.5";
+var DEFAULT_MODEL = "vercel/anthropic/claude-opus-4.6";
+var DEFAULT_BOOTSTRAP_SKILL_REPOS = [
+  { repo: "vercel-labs/agent-browser", skills: ["agent-browser"] },
+  { repo: "vercel-labs/agent-skills", skills: ["react-best-practices"] }
+];
 var dim = (s) => `\x1B[2m${s}\x1B[22m`;
 var bold = (s) => `\x1B[1m${s}\x1B[22m`;
 var green = (s) => `\x1B[32m${s}\x1B[39m`;
 var red = (s) => `\x1B[31m${s}\x1B[39m`;
 var cyan = (s) => `\x1B[36m${s}\x1B[39m`;
 var log = console.log;
+var INDENT_MAIN = "  ";
+var INDENT_LIST = "    ";
+var INDENT_SESSION = "       ";
+var INDENT_SESSION_DETAIL = "              ";
+var KEY_WIDTH = 13;
+function printLine(line = "") {
+  log(line);
+}
+function printTitle(topic) {
+  printLine(`
+${INDENT_MAIN}${bold("\u25B2 dream")} ${dim("\xB7")} ${topic}
+`);
+}
+function printKV(key, value) {
+  printLine(`${INDENT_MAIN}${dim(key.padEnd(KEY_WIDTH))}${value}`);
+}
+function printStep(message) {
+  printLine(`${INDENT_MAIN}${dim("\u25CC")} ${message}`);
+}
+function printNote(message) {
+  printLine(`${INDENT_MAIN}${dim("\xB7")} ${message}`);
+}
+function printListItem(message) {
+  printLine(`${INDENT_LIST}${dim("\xB7")} ${message}`);
+}
+function printSuccess(message) {
+  printLine(`${INDENT_MAIN}${green("\u25CF")} ${message}`);
+}
+function printError(message) {
+  printLine(`${INDENT_MAIN}${red("\u2717")} ${message}`);
+}
+function printAdded(message) {
+  printLine(`${INDENT_MAIN}${green("+")} ${message}`);
+}
+function printSession(message) {
+  printLine(`${INDENT_SESSION}${message}`);
+}
+function printSessionDim(message) {
+  printSession(dim(message));
+}
+function printSessionError(message) {
+  printSession(`${red("\u2717")} ${message}`);
+}
 program.name("dream").description("Run OpenCode in a loop until specs are complete").version("0.1.0").option("-d, --dir <directory>", "Working directory", ".");
 program.command("init").description("Initialize a new dream project").action(() => {
   const workDir = path.resolve(program.opts().dir);
-  log(`
-  ${bold("\u25B2 dream")} ${dim("\xB7 init")}
-`);
+  printTitle("init");
   const result = init({ dir: workDir, version: "^0.2.1" });
   if (result.specsCreated) {
-    log(`  ${green("+")} specs/2048.md`);
+    printAdded("specs/2048.md");
   } else {
-    log(`  ${dim("\xB7")} specs/ ${dim("already exists")}`);
+    printNote(`specs/ ${dim("already exists")}`);
   }
   if (result.packageJsonCreated) {
-    log(`  ${green("+")} package.json`);
+    printAdded("package.json");
   } else {
-    log(`  ${dim("\xB7")} package.json ${dim("already exists")}`);
+    printNote(`package.json ${dim("already exists")}`);
   }
-  log(`
-  Run ${cyan("pnpm install")} then ${cyan("dream")} to start
-`);
+  printLine(
+    `
+${INDENT_MAIN}Run ${cyan("pnpm install")} then ${cyan("dream")} to start
+`
+  );
 });
 program.command("config").description("Show project configuration and specs").action(() => {
   const workDir = path.resolve(program.opts().dir);
   const specsDir = path.join(workDir, "specs");
-  log(`
-  ${bold("\u25B2 dream")} ${dim("\xB7 config")}
-`);
-  log(`  ${dim("dir")}         ${workDir}`);
-  log(`  ${dim("timeout")}     ${formatTime(DEFAULT_TIMEOUT)}`);
-  log(`  ${dim("max")}         ${DEFAULT_MAX_ITERATIONS} iterations`);
+  printTitle("config");
+  printKV("dir", workDir);
+  printKV("timeout", formatTime(DEFAULT_TIMEOUT));
+  printKV("max", `${DEFAULT_MAX_ITERATIONS} iterations`);
   if (!fs.existsSync(specsDir)) {
-    log(`
-  ${red("\u2717")} specs/ not found
-`);
+    printError("specs/ not found");
+    printLine();
     return;
   }
   const specFiles = fs.readdirSync(specsDir).filter((f) => f.endsWith(".md"));
-  log(`
-  ${dim("specs")} ${dim(`(${specFiles.length})`)}`);
+  printLine(
+    `
+${INDENT_MAIN}${dim("specs")} ${dim(`(${specFiles.length})`)}`
+  );
   for (const file of specFiles) {
-    log(`    ${dim("\xB7")} ${file}`);
+    printListItem(file);
   }
-  log("");
+  printLine();
 });
 program.command("models").description("List available models and check provider auth").action(async () => {
-  log(`
-  ${bold("\u25B2 dream")} ${dim("\xB7 models")}
-`);
-  log(`  ${dim("\u25CC")} Starting OpenCode...`);
+  printTitle("models");
+  printStep("Starting OpenCode...");
   const { client, server } = await createOpencode({
     port: 0,
     config: { enabled_providers: ["vercel"] }
@@ -185,8 +231,8 @@ program.command("models").description("List available models and check provider
   try {
     const res = await client.provider.list();
     if (res.error) {
-      log(`  ${red("\u2717")} Failed to list providers
-`);
+      printError("Failed to list providers");
+      printLine();
       return;
     }
     const { all, connected } = res.data;
@@ -194,34 +240,32 @@ program.command("models").description("List available models and check provider
       const isConnected = connected.includes(provider.id);
       const icon = isConnected ? green("\u25CF") : red("\u25CB");
       const npm = provider.npm ? dim(` npm:${provider.npm}`) : "";
-      log(
-        `  ${icon} ${bold(provider.name)} ${dim(`(${provider.id})`)}${npm}`
+      printLine(
+        `${INDENT_MAIN}${icon} ${bold(provider.name)} ${dim(`(${provider.id})`)}${npm}`
       );
       const models = Object.entries(provider.models);
       for (const [id, model] of models) {
         const name = model.name ?? id;
-        log(`    ${dim("\xB7")} ${provider.id}/${id} ${dim(name)}`);
+        printListItem(`${provider.id}/${id} ${dim(name)}`);
       }
       if (models.length === 0) {
-        log(`    ${dim("no models")}`);
+        printLine(`${INDENT_LIST}${dim("no models")}`);
       }
-      log("");
+      printLine();
     }
-    log(
-      `  ${dim("connected")}   ${connected.length ? connected.join(", ") : "none"}
-`
-    );
+    printKV("connected", connected.length ? connected.join(", ") : "none");
+    printLine();
   } finally {
     server.close();
     process.exit(0);
   }
 });
-program.option("-m, --model <model>", "Model to use (provider/model format)").option("-t, --timeout <ms>", "Timeout in milliseconds").option("-i, --max-iterations <n>", "Maximum iterations").option("-v, --verbose", "Verbose output").action(async (opts) => {
+program.option("-m, --model <model>", "Model to use (provider/model format)").option("-t, --timeout <ms>", "Timeout in milliseconds").option("-i, --max-iterations <n>", "Maximum iterations").option("-v, --verbose", "Verbose output").option("--skip-bootstrap", "Skip runtime bootstrap").action(async (opts) => {
   const workDir = path.resolve(opts.dir);
   const specsDir = path.join(workDir, "specs");
   if (!fs.existsSync(specsDir)) {
-    log(`
-  ${red("\u2717")} specs/ not found in ${workDir}
+    printLine(`
+${INDENT_MAIN}${red("\u2717")} specs/ not found in ${workDir}
 `);
     process.exit(1);
   }
@@ -236,18 +280,32 @@ program.option("-m, --model <model>", "Model to use (provider/model format)").op
 ## Project Prompt Overlay (${projectPrompt.file})
 
 ${projectPrompt.content}` : SYSTEM_PROMPT;
-  log(`
-  ${bold("\u25B2 dream")} ${dim("\xB7")} ${title}
-`);
-  log(`  ${dim("dir")}         ${workDir}`);
-  log(`  ${dim("model")}       ${model || dim("default")}`);
-  log(`  ${dim("timeout")}     ${formatTime(timeout)}`);
-  log(`  ${dim("max")}         ${maxIterations} iterations
-`);
+  printTitle(title);
+  printKV("dir", workDir);
+  printKV("model", model || dim("default"));
+  printKV("timeout", formatTime(timeout));
+  printKV("max", `${maxIterations} iterations`);
+  printLine();
   if (projectPrompt) {
-    log(`  ${dim("overlay")}     ${projectPrompt.file}`);
+    printKV("overlay", projectPrompt.file);
   }
-  log(`  ${dim("\u25CC")} Starting OpenCode...`);
+  if (opts.skipBootstrap) {
+    printKV("bootstrap", dim("skipped"));
+  }
+  if (!opts.skipBootstrap) {
+    try {
+      await bootstrapRuntime(workDir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "bootstrap failed";
+      printLine(
+        `
+${INDENT_MAIN}${red("\u2717")} Runtime bootstrap failed: ${message}
+`
+      );
+      process.exit(1);
+    }
+  }
+  printStep("Starting OpenCode...");
   const oidcToken = process.env.VERCEL_OIDC_TOKEN;
   const { client, server } = await createOpencode({
     port: 0,
@@ -280,25 +338,23 @@ ${projectPrompt.content}` : SYSTEM_PROMPT;
       enabled_providers: ["vercel"]
     }
   });
-  log(`  ${green("\u25CF")} OpenCode ready`);
+  printSuccess("OpenCode ready");
   const providerId = model?.split("/")[0];
   if (providerId) {
     const providers = await client.provider.list();
     if (providers.error) {
-      log(`  ${red("\u2717")} Failed to list providers
-`);
+      printError("Failed to list providers");
+      printLine();
       server.close();
       process.exit(1);
     }
     const connected = providers.data.connected ?? [];
     if (!connected.includes(providerId)) {
-      log(`  ${red("\u2717")} Provider ${bold(providerId)} is not connected`);
-      log(
-        `  ${dim("connected")}   ${connected.length ? connected.join(", ") : "none"}`
-      );
-      log(
+      printError(`Provider ${bold(providerId)} is not connected`);
+      printKV("connected", connected.length ? connected.join(", ") : "none");
+      printLine(
         `
-  Run ${cyan("opencode")} and authenticate the ${bold(providerId)} provider
+${INDENT_MAIN}Run ${cyan("opencode")} and authenticate the ${bold(providerId)} provider
 `
       );
       server.close();
@@ -307,21 +363,20 @@ ${projectPrompt.content}` : SYSTEM_PROMPT;
     const provider = providers.data.all.find((p) => p.id === providerId);
     const modelId = model.split("/").slice(1).join("/");
     if (provider && modelId && !provider.models[modelId]) {
-      log(
-        `  ${red("\u2717")} Model ${bold(modelId)} not found in ${bold(providerId)}`
-      );
+      printError(`Model ${bold(modelId)} not found in ${bold(providerId)}`);
       const available = Object.keys(provider.models);
       if (available.length) {
-        log(
-          `  ${dim("available")}   ${available.slice(0, 5).join(", ")}${available.length > 5 ? ` (+${available.length - 5} more)` : ""}`
+        printKV(
+          "available",
+          `${available.slice(0, 5).join(", ")}${available.length > 5 ? ` (+${available.length - 5} more)` : ""}`
         );
       }
-      log("");
+      printLine();
       server.close();
       process.exit(1);
     }
-    log(`  ${green("\u25CF")} Provider ${bold(providerId)} connected
-`);
+    printSuccess(`Provider ${bold(providerId)} connected`);
+    printLine();
   }
   const cleanup = () => {
     server.close();
@@ -335,14 +390,16 @@ ${projectPrompt.content}` : SYSTEM_PROMPT;
     while (iteration < maxIterations) {
       const elapsed = Date.now() - startTime;
       if (elapsed >= timeout) {
-        log(`
-  ${red("\u2717")} Timeout after ${formatTime(elapsed)}
-`);
+        printLine(
+          `
+${INDENT_MAIN}${red("\u2717")} Timeout after ${formatTime(elapsed)}
+`
+        );
         process.exit(1);
       }
       iteration++;
       const iterStart = Date.now();
-      log(`  ${cyan(`[${iteration}]`)} Running session...`);
+      printLine(`${INDENT_MAIN}${cyan(`[${iteration}]`)} Running session...`);
       const result = await runSession(
         client,
         title,
@@ -351,31 +408,31 @@ ${projectPrompt.content}` : SYSTEM_PROMPT;
       );
       const iterElapsed = Date.now() - iterStart;
       if (result === "done") {
-        log(
-          `  ${cyan(`[${iteration}]`)} ${green("\u2713")} Done ${dim(`(${formatTime(iterElapsed)})`)}`
+        printLine(
+          `${INDENT_MAIN}${cyan(`[${iteration}]`)} ${green("\u2713")} Done ${dim(`(${formatTime(iterElapsed)})`)}`
         );
-        log(
+        printLine(
           `
-  ${green("\u2713")} Completed in ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}
+${INDENT_MAIN}${green("\u2713")} Completed in ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}
 `
         );
         process.exit(0);
       }
       if (result === "error") {
-        log(
+        printLine(
           `
-  ${red("\u2717")} Session failed after ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}
+${INDENT_MAIN}${red("\u2717")} Session failed after ${bold(String(iteration))} iteration(s) ${dim(`(${formatTime(Date.now() - startTime)})`)}
 `
         );
         process.exit(1);
       }
-      log(
-        `  ${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} \xB7 continuing...`)}
+      printLine(
+        `${INDENT_MAIN}${cyan(`[${iteration}]`)} ${dim(`${formatTime(iterElapsed)} \xB7 continuing...`)}
 `
       );
     }
-    log(`
-  ${red("\u2717")} Max iterations reached
+    printLine(`
+${INDENT_MAIN}${red("\u2717")} Max iterations reached
 `);
     process.exit(1);
   } finally {
@@ -383,7 +440,7 @@ ${projectPrompt.content}` : SYSTEM_PROMPT;
   }
 });
 async function runSession(client, title, systemPrompt, verbose) {
-  log(`       ${dim("creating session...")}`);
+  printSessionDim("creating session...");
   const sessionResponse = await client.session.create({
     title: `Dream: ${title}`
   });
@@ -393,18 +450,16 @@ async function runSession(client, title, systemPrompt, verbose) {
     );
   }
   const sessionId = sessionResponse.data.id;
-  log(`       ${dim(`session ${sessionId.slice(0, 8)}`)}`);
-  log(`       ${dim("subscribing to events...")}`);
+  printSessionDim(`session ${sessionId.slice(0, 8)}`);
+  printSessionDim("subscribing to events...");
   const events = await client.event.subscribe();
-  log(`       ${dim("sending prompt...")}`);
+  printSessionDim("sending prompt...");
   const promptResponse = await client.session.promptAsync({
     sessionID: sessionId,
     parts: [{ type: "text", text: systemPrompt }]
   });
   if (promptResponse.error) {
-    log(
-      `       ${red("\u2717")} prompt error: ${JSON.stringify(promptResponse.error)}`
-    );
+    printSessionError(`prompt error: ${JSON.stringify(promptResponse.error)}`);
     return "error";
   }
   let responseText = "";
@@ -414,16 +469,15 @@ async function runSession(client, title, systemPrompt, verbose) {
   let totalTokensOut = 0;
   const seenTools = /* @__PURE__ */ new Set();
   let lastOutput = "none";
-  const pad = "       ";
   for await (const event of events.stream) {
     const props = event.properties;
     if (verbose) {
       const sid = props.sessionID ? props.sessionID.slice(0, 8) : "global";
-      log(dim(`       event: ${event.type} [${sid}]`));
+      printSessionDim(`event: ${event.type} [${sid}]`);
       if (event.type !== "server.connected") {
-        log(
+        printLine(
           dim(
-            `              ${JSON.stringify(event.properties).slice(0, 200)}`
+            `${INDENT_SESSION_DETAIL}${JSON.stringify(event.properties).slice(0, 200)}`
           )
         );
       }
@@ -438,18 +492,18 @@ async function runSession(client, title, systemPrompt, verbose) {
         responseText += delta;
         if (lastOutput === "tool") process.stdout.write("\n");
         const indented = delta.replace(/\n/g, `
-${pad}`);
+${INDENT_SESSION}`);
         process.stdout.write(
-          lastOutput !== "text" ? `${pad}${dim(indented)}` : dim(indented)
+          lastOutput !== "text" ? `${INDENT_SESSION}${dim(indented)}` : dim(indented)
         );
         lastOutput = "text";
       }
       if (part.type === "reasoning" && delta) {
         if (lastOutput === "tool") process.stdout.write("\n");
         const indented = delta.replace(/\n/g, `
-${pad}`);
+${INDENT_SESSION}`);
         process.stdout.write(
-          lastOutput !== "text" ? `${pad}${dim(indented)}` : dim(indented)
+          lastOutput !== "text" ? `${INDENT_SESSION}${dim(indented)}` : dim(indented)
         );
         lastOutput = "text";
       }
@@ -462,14 +516,14 @@ ${pad}`);
           toolCalls++;
           if (lastOutput === "text") process.stdout.write("\n\n");
           const context = toolContext(toolName, state.input) ?? state.title;
-          log(
-            `${pad}${dim("\u25B8")} ${toolName}${context ? dim(` ${context}`) : ""}`
+          printSession(
+            `${dim("\u25B8")} ${toolName}${context ? dim(` ${context}`) : ""}`
           );
           lastOutput = "tool";
         }
         if (state.status === "error") {
           if (lastOutput === "text") process.stdout.write("\n");
-          log(`${pad}${red("\u2717")} ${toolName}: ${state.error}`);
+          printSession(`${red("\u2717")} ${toolName}: ${state.error}`);
           lastOutput = "tool";
         }
       }
@@ -485,7 +539,7 @@ ${pad}`);
       if (file) {
         if (lastOutput === "text") process.stdout.write("\n");
         const relative = file.replace(`${process.cwd()}/`, "");
-        log(`${pad}${green("\u270E")} ${relative}`);
+        printSession(`${green("\u270E")} ${relative}`);
         lastOutput = "tool";
       }
     }
@@ -493,7 +547,7 @@ ${pad}`);
       const errProps = event.properties;
       const msg = errProps.error?.data?.message ?? errProps.error?.name ?? "session error";
       if (lastOutput === "text") process.stdout.write("\n");
-      log(`${pad}${red("\u2717")} ${msg}`);
+      printSession(`${red("\u2717")} ${msg}`);
       return "error";
     }
     if (event.type === "session.idle") {
@@ -503,9 +557,9 @@ ${pad}`);
   if (lastOutput === "text") process.stdout.write("\n");
   const tokens = `${formatTokens(totalTokensIn)}\u2192${formatTokens(totalTokensOut)}`;
   const cost = totalCost > 0 ? ` \xB7 $${totalCost.toFixed(2)}` : "";
-  log(`${pad}${dim(`${toolCalls} tools \xB7 ${tokens}${cost}`)}`);
+  printSessionDim(`${toolCalls} tools \xB7 ${tokens}${cost}`);
   if (responseText.length === 0) {
-    log(`${pad}${red("\u2717")} No response from model`);
+    printSessionError("No response from model");
     return "error";
   }
   return responseText.includes(STOP_WORD) ? "done" : "continue";
@@ -553,4 +607,65 @@ function loadProjectPrompt(specsDir) {
   }
   return null;
 }
+function packageRootFromScript() {
+  const scriptPath = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(scriptPath), "..");
+}
+function prependLocalBinsToPath(workDir) {
+  const packageRoot = packageRootFromScript();
+  const binPaths = [
+    path.join(workDir, "node_modules", ".bin"),
+    path.join(packageRoot, "node_modules", ".bin")
+  ];
+  const currentPath = process.env.PATH ?? "";
+  process.env.PATH = [...binPaths, currentPath].filter((entry) => Boolean(entry)).join(path.delimiter);
+}
+async function commandExists(command) {
+  try {
+    await $`command -v ${command}`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installSkills(skillRepos) {
+  for (const entry of skillRepos) {
+    const skills = entry.skills?.filter((skill) => skill.trim().length > 0) ?? [];
+    if (skills.length === 0) {
+      printNote(`Installing skills from ${entry.repo}...`);
+      await $`npx skills@latest add ${entry.repo} --yes --global`;
+      continue;
+    }
+    for (const skill of skills) {
+      printNote(`Installing skill ${skill} from ${entry.repo}...`);
+      await $`npx skills@latest add ${entry.repo} --skill ${skill} --yes --global`;
+    }
+  }
+}
+async function bootstrapRuntime(workDir) {
+  prependLocalBinsToPath(workDir);
+  printStep("Bootstrapping runtime tools...");
+  let hasAgentBrowser = await commandExists("agent-browser");
+  if (!hasAgentBrowser) {
+    printNote("Installing agent-browser globally...");
+    await $`npm install --global agent-browser`;
+    hasAgentBrowser = await commandExists("agent-browser");
+  }
+  printNote("Installing browser runtime...");
+  if (hasAgentBrowser) {
+    await $`agent-browser install`;
+  } else {
+    printNote("Falling back to npx for agent-browser install...");
+    await $`npx --yes agent-browser install`;
+  }
+  if (process.env.DREAM_SKIP_SKILL_SETUP === "1") {
+    printNote("Skipping skill setup (DREAM_SKIP_SKILL_SETUP=1)");
+    return;
+  }
+  if (DEFAULT_BOOTSTRAP_SKILL_REPOS.length === 0) {
+    printNote("No bootstrap skills configured");
+    return;
+  }
+  await installSkills(DEFAULT_BOOTSTRAP_SKILL_REPOS);
+}
 await program.parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/dream",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "A CLI that runs OpenCode in a loop until specs are complete",
   "type": "module",
   "bin": {
@@ -12,9 +12,9 @@
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.39",
     "@opencode-ai/sdk": "^1.1.0",
-    "agent-browser": ">=0.9.0",
     "commander": "^12.0.0",
     "opencode-ai": ">=1.0.0",
+    "zx": "^8.8.4",
     "@vercel/dream-init": "0.2.2"
   },
   "devDependencies": {