@standardagents/cli 0.10.1-dev.d2d335e → 0.10.1-next.9e1860c

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import fs, { readFileSync } from 'fs';
-import path, { dirname, resolve } from 'path';
+import fs3, { readFileSync } from 'fs';
+import path3, { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
 import readline from 'readline';
@@ -10,6 +10,7 @@ import chalk from 'chalk';
 import { parse, modify, applyEdits } from 'jsonc-parser';
 import { loadFile, writeFile, generateCode } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
+import net from 'net';
 
 var logger = {
   success: (message) => {
@@ -115,30 +116,32 @@ agents/
 
 Files are **auto-discovered** at runtime. No manual registration needed.
 
-## FlowState
+## ThreadState
 
-\`FlowState\` is the central state object available in tools and hooks:
+\`ThreadState\` is the state object available in tools and hooks:
 
 \`\`\`typescript
-interface FlowState {
-  thread: {
-    id: string;           // Thread identifier
-    instance: DurableThread;  // Durable Object instance
-  };
-  agent: AgentConfig;     // Current agent configuration
-  prompt: PromptConfig;   // Current prompt configuration
-  model: ModelConfig;     // Current model configuration
-  messages: Message[];    // Conversation history
-  env: Env;               // Cloudflare Worker environment
-  rootState: FlowState;   // Parent state (for sub-prompts)
+interface ThreadState {
+  // Identity (readonly)
+  threadId: string;           // Thread identifier
+  agentId: string;            // Agent identifier
+  userId: string | null;      // User identifier (if set)
+  createdAt: number;          // Creation timestamp
+
+  // Methods
+  getMessages(options?): Promise<MessagesResult>;  // Get conversation history
+  injectMessage(input): Promise<Message>;          // Add message to thread
+  loadModel(name): Promise<ModelConfig>;           // Load model definition
+  loadPrompt(name): Promise<PromptConfig>;         // Load prompt definition
+  loadAgent(name): Promise<AgentConfig>;           // Load agent definition
 }
 \`\`\`
 
 Access in tools:
 \`\`\`typescript
 export default defineTool('...', schema, async (flow, args) => {
-  const threadId = flow.thread.id;
-  const messages = flow.messages;
+  const threadId = flow.threadId;
+  const { messages } = await flow.getMessages();
   // ...
 });
 \`\`\`
@@ -282,15 +285,12 @@ Prompts define system instructions, model selection, and available tools for LLM
 | \`toolDescription\` | \`string\` | Yes | Description shown when used as a tool |
 | \`prompt\` | \`string \\| StructuredPrompt\` | Yes | System instructions |
 | \`model\` | \`string\` | Yes | Model name to use (references \`agents/models/\`) |
-| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools for LLM |
-| \`handoffAgents\` | \`string[]\` | No | Agents this prompt can hand off to |
+| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools (include ai_human agent names for handoffs) |
 | \`includeChat\` | \`boolean\` | No | Include full conversation history |
 | \`includePastTools\` | \`boolean\` | No | Include previous tool results |
 | \`parallelToolCalls\` | \`boolean\` | No | Allow multiple concurrent tool calls |
 | \`toolChoice\` | \`'auto' \\| 'none' \\| 'required'\` | No | Tool calling strategy |
 | \`requiredSchema\` | \`z.ZodObject\` | No | Input validation when called as tool |
-| \`beforeTool\` | \`string\` | No | Tool to run before LLM request |
-| \`afterTool\` | \`string\` | No | Tool to run after LLM response |
 | \`reasoning\` | \`ReasoningConfig\` | No | Extended thinking configuration |
 
 ## Basic Example
@@ -490,7 +490,7 @@ export default defineAgent({
 });
 \`\`\`
 
-Other prompts can then include it in their \`handoffAgents\` array.
+Other prompts can then include the agent name in their \`tools\` array to enable handoffs.
 
 ## Stop Conditions (Priority Order)
 
@@ -565,28 +565,27 @@ export default defineTool(
 | \`result\` | \`string\` | Tool output (required for success) |
 | \`error\` | \`string\` | Error message (for error status) |
 
-## FlowState Access
+## ThreadState Access
 
-The \`flow\` parameter provides access to:
+The \`flow\` parameter (a \`ThreadState\` object) provides access to:
 
 \`\`\`typescript
 async (flow, args) => {
-  // Thread information
-  const threadId = flow.thread.id;
-  const thread = flow.thread.instance;
-
-  // Configuration
-  const agentName = flow.agent.name;
-  const modelName = flow.model.name;
+  // Thread identity (readonly)
+  const threadId = flow.threadId;
+  const agentId = flow.agentId;
+  const userId = flow.userId;       // string | null
 
   // Message history
-  const messages = flow.messages;
+  const { messages } = await flow.getMessages();
+  const { messages: recent } = await flow.getMessages({ limit: 10, order: 'desc' });
 
-  // Environment bindings
-  const env = flow.env;
+  // Resource loading
+  const model = await flow.loadModel('gpt-4o');
+  const prompt = await flow.loadPrompt('support-prompt');
 
-  // Parent state (for sub-prompts)
-  const root = flow.rootState;
+  // Inject messages
+  await flow.injectMessage({ role: 'system', content: 'Note: ...' });
 }
 \`\`\`
 
@@ -635,14 +634,14 @@ import { queueTool } from '@standardagents/builder';
 
 export default defineTool(
   'Create order and send confirmation',
-  z.object({ items: z.array(z.string()) }),
+  z.object({ items: z.array(z.string()), email: z.string() }),
   async (flow, args) => {
     const order = await createOrder(args.items);
 
     // Queue email tool to run next
     queueTool(flow, 'send_confirmation_email', {
       orderId: order.id,
-      email: flow.thread.metadata.userEmail,
+      email: args.email,
     });
 
     return { status: 'success', result: JSON.stringify(order) };
@@ -981,17 +980,19 @@ Full reference: https://docs.standardagentbuilder.com/core-concepts/api
 `;
 
 // src/commands/scaffold.ts
-var WRANGLER_TEMPLATE = (name) => `{
+var WRANGLER_TEMPLATE = (name) => {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `{
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "${name}",
   "main": "worker/index.ts",
-  "compatibility_date": "2025-01-01",
+  "compatibility_date": "${today}",
   "compatibility_flags": ["nodejs_compat"],
   "observability": {
     "enabled": true
   },
   "assets": {
-    "directory": "dist",
+    "directory": "dist/client",
     "not_found_handling": "single-page-application",
     "binding": "ASSETS",
     "run_worker_first": ["/**"]
@@ -1020,6 +1021,7 @@ var WRANGLER_TEMPLATE = (name) => `{
   ]
 }
 `;
+};
 var THREAD_TS = `import { DurableThread } from 'virtual:@standardagents/builder'
 
 export default class Thread extends DurableThread {}
@@ -1042,23 +1044,23 @@ export default {
 export { DurableThread, DurableAgentBuilder }
 `;
 function getProjectName(cwd) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const pkg2 = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      const pkg2 = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
       if (pkg2.name) {
         return pkg2.name.replace(/^@[^/]+\//, "");
       }
     } catch {
     }
   }
-  return path.basename(cwd);
+  return path3.basename(cwd);
 }
 function findViteConfig(cwd) {
   const candidates = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1067,8 +1069,8 @@ function findViteConfig(cwd) {
 function findWranglerConfig(cwd) {
   const candidates = ["wrangler.jsonc", "wrangler.json"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1077,21 +1079,13 @@ function findWranglerConfig(cwd) {
 async function modifyViteConfig(configPath, force) {
   try {
     const mod = await loadFile(configPath);
-    const code = fs.readFileSync(configPath, "utf-8");
+    const code = fs3.readFileSync(configPath, "utf-8");
     const hasCloudflare = code.includes("@cloudflare/vite-plugin") || code.includes("cloudflare()");
     const hasAgentBuilder = code.includes("@standardagents/builder") || code.includes("agentbuilder()");
     if (hasCloudflare && hasAgentBuilder && !force) {
       logger.info("Vite config already includes Standard Agents plugins");
       return true;
     }
-    if (!hasCloudflare || force) {
-      addVitePlugin(mod, {
-        from: "@cloudflare/vite-plugin",
-        imported: "cloudflare",
-        constructor: "cloudflare"
-      });
-      logger.success("Added cloudflare plugin to vite.config");
-    }
     if (!hasAgentBuilder || force) {
       addVitePlugin(mod, {
         from: "@standardagents/builder",
@@ -1101,6 +1095,14 @@ async function modifyViteConfig(configPath, force) {
       });
       logger.success("Added agentbuilder plugin to vite.config");
     }
+    if (!hasCloudflare || force) {
+      addVitePlugin(mod, {
+        from: "@cloudflare/vite-plugin",
+        imported: "cloudflare",
+        constructor: "cloudflare"
+      });
+      logger.success("Added cloudflare plugin to vite.config");
+    }
     await writeFile(mod, configPath);
     return true;
   } catch (error) {
@@ -1108,10 +1110,10 @@ async function modifyViteConfig(configPath, force) {
     logger.log("");
     logger.log("Please manually add the following to your vite.config.ts:");
     logger.log("");
-    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log(`  import { agentbuilder } from '@standardagents/builder'`);
+    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log("");
-    logger.log(`  plugins: [cloudflare(), agentbuilder({ mountPoint: '/' })]`);
+    logger.log(`  plugins: [agentbuilder({ mountPoint: '/' }), cloudflare()]`);
     logger.log("");
     return false;
   }
@@ -1120,7 +1122,7 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
   const existingConfig = findWranglerConfig(cwd);
   if (existingConfig && !force) {
     try {
-      const text = fs.readFileSync(existingConfig, "utf-8");
+      const text = fs3.readFileSync(existingConfig, "utf-8");
       const config = parse(text);
       const hasBindings = config.durable_objects?.bindings?.some(
         (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
@@ -1160,14 +1162,14 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       }
       if (!config.assets) {
         const edits = modify(result, ["assets"], {
-          directory: "dist",
+          directory: "dist/client",
           not_found_handling: "single-page-application",
           binding: "ASSETS",
           run_worker_first: ["/**"]
         }, {});
         result = applyEdits(result, edits);
       }
-      fs.writeFileSync(existingConfig, result, "utf-8");
+      fs3.writeFileSync(existingConfig, result, "utf-8");
       logger.success("Updated wrangler.jsonc with Standard Agents configuration");
       return true;
     } catch (error) {
@@ -1175,9 +1177,9 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       return false;
     }
   }
-  const wranglerPath = path.join(cwd, "wrangler.jsonc");
+  const wranglerPath = path3.join(cwd, "wrangler.jsonc");
   const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  fs.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
+  fs3.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
   logger.success("Created wrangler.jsonc");
   return true;
 }
@@ -1185,33 +1187,33 @@ function getWorkerEntryPoint(cwd) {
   const wranglerConfig = findWranglerConfig(cwd);
   if (wranglerConfig) {
     try {
-      const text = fs.readFileSync(wranglerConfig, "utf-8");
+      const text = fs3.readFileSync(wranglerConfig, "utf-8");
       const config = parse(text);
       if (config.main) {
-        return path.join(cwd, config.main);
+        return path3.join(cwd, config.main);
       }
     } catch {
     }
   }
-  return path.join(cwd, "worker", "index.ts");
+  return path3.join(cwd, "worker", "index.ts");
 }
 async function createOrUpdateWorkerEntry(cwd, force) {
   const entryPath = getWorkerEntryPoint(cwd);
-  const entryDir = path.dirname(entryPath);
-  if (!fs.existsSync(entryDir)) {
-    fs.mkdirSync(entryDir, { recursive: true });
-    logger.success(`Created ${path.relative(cwd, entryDir)} directory`);
-  }
-  if (!fs.existsSync(entryPath)) {
-    fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-    logger.success(`Created ${path.relative(cwd, entryPath)}`);
+  const entryDir = path3.dirname(entryPath);
+  if (!fs3.existsSync(entryDir)) {
+    fs3.mkdirSync(entryDir, { recursive: true });
+    logger.success(`Created ${path3.relative(cwd, entryDir)} directory`);
+  }
+  if (!fs3.existsSync(entryPath)) {
+    fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+    logger.success(`Created ${path3.relative(cwd, entryPath)}`);
     return true;
   }
-  const content = fs.readFileSync(entryPath, "utf-8");
+  const content = fs3.readFileSync(entryPath, "utf-8");
   const hasRouter = content.includes("virtual:@standardagents/builder") && content.includes("router");
   const hasDurableExports = content.includes("DurableThread") && content.includes("DurableAgentBuilder");
   if (hasRouter && hasDurableExports && !force) {
-    logger.info(`${path.relative(cwd, entryPath)} already configured`);
+    logger.info(`${path3.relative(cwd, entryPath)} already configured`);
     return true;
   }
   try {
@@ -1239,17 +1241,17 @@ async function createOrUpdateWorkerEntry(cwd, force) {
     }
     const { code } = generateCode(mod);
     if (force || !hasRouter) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Updated ${path.relative(cwd, entryPath)} with Standard Agents router`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Updated ${path3.relative(cwd, entryPath)} with Standard Agents router`);
     }
     return true;
   } catch (error) {
     if (force) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Created ${path.relative(cwd, entryPath)}`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Created ${path3.relative(cwd, entryPath)}`);
       return true;
     }
-    logger.warning(`Could not automatically modify ${path.relative(cwd, entryPath)}`);
+    logger.warning(`Could not automatically modify ${path3.relative(cwd, entryPath)}`);
     logger.log("");
     logger.log("Please ensure your worker entry point includes:");
     logger.log("");
@@ -1268,30 +1270,30 @@ async function createOrUpdateWorkerEntry(cwd, force) {
   }
 }
 function createDurableObjects(cwd) {
-  const agentsDir = path.join(cwd, "agents");
-  if (!fs.existsSync(agentsDir)) {
-    fs.mkdirSync(agentsDir, { recursive: true });
+  const agentsDir = path3.join(cwd, "agents");
+  if (!fs3.existsSync(agentsDir)) {
+    fs3.mkdirSync(agentsDir, { recursive: true });
   }
-  const threadPath = path.join(agentsDir, "Thread.ts");
-  if (!fs.existsSync(threadPath)) {
-    fs.writeFileSync(threadPath, THREAD_TS, "utf-8");
+  const threadPath = path3.join(agentsDir, "Thread.ts");
+  if (!fs3.existsSync(threadPath)) {
+    fs3.writeFileSync(threadPath, THREAD_TS, "utf-8");
     logger.success("Created agents/Thread.ts");
   } else {
     logger.info("agents/Thread.ts already exists");
   }
-  const agentBuilderPath = path.join(agentsDir, "AgentBuilder.ts");
-  if (!fs.existsSync(agentBuilderPath)) {
-    fs.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
+  const agentBuilderPath = path3.join(agentsDir, "AgentBuilder.ts");
+  if (!fs3.existsSync(agentBuilderPath)) {
+    fs3.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
     logger.success("Created agents/AgentBuilder.ts");
   } else {
     logger.info("agents/AgentBuilder.ts already exists");
   }
 }
 function createDirectoriesAndDocs(cwd) {
-  path.join(cwd, "agents");
-  const rootDocPath = path.join(cwd, "CLAUDE.md");
-  if (!fs.existsSync(rootDocPath)) {
-    fs.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
+  path3.join(cwd, "agents");
+  const rootDocPath = path3.join(cwd, "CLAUDE.md");
+  if (!fs3.existsSync(rootDocPath)) {
+    fs3.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
     logger.success("Created CLAUDE.md");
   }
   const directories = [
@@ -1303,26 +1305,26 @@ function createDirectoriesAndDocs(cwd) {
     { path: "agents/api", doc: API_CLAUDE_MD }
   ];
   for (const dir of directories) {
-    const dirPath = path.join(cwd, dir.path);
-    const docPath = path.join(dirPath, "CLAUDE.md");
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+    const dirPath = path3.join(cwd, dir.path);
+    const docPath = path3.join(dirPath, "CLAUDE.md");
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
       logger.success(`Created ${dir.path}`);
     }
-    if (!fs.existsSync(docPath)) {
-      fs.writeFileSync(docPath, dir.doc, "utf-8");
+    if (!fs3.existsSync(docPath)) {
+      fs3.writeFileSync(docPath, dir.doc, "utf-8");
       logger.success(`Created ${dir.path}/CLAUDE.md`);
     }
   }
 }
 function updateTsConfig(cwd) {
-  const tsconfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) {
+  const tsconfigPath = path3.join(cwd, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) {
     logger.info("No tsconfig.json found, skipping TypeScript configuration");
     return;
   }
   try {
-    const text = fs.readFileSync(tsconfigPath, "utf-8");
+    const text = fs3.readFileSync(tsconfigPath, "utf-8");
     const config = parse(text);
     let result = text;
     const types = config.compilerOptions?.types || [];
@@ -1344,7 +1346,7 @@ function updateTsConfig(cwd) {
       result = applyEdits(result, edits);
     }
     if (newTypes.length > 0 || newIncludes.length > 0) {
-      fs.writeFileSync(tsconfigPath, result, "utf-8");
+      fs3.writeFileSync(tsconfigPath, result, "utf-8");
       logger.success("Updated tsconfig.json with Standard Agents types");
     } else {
       logger.info("tsconfig.json already configured");
@@ -1365,21 +1367,21 @@ function cleanupViteDefaults(cwd) {
   ];
   const dirsToRemove = ["src", "public"];
   for (const file of filesToRemove) {
-    const filePath = path.join(cwd, file);
-    if (fs.existsSync(filePath)) {
+    const filePath = path3.join(cwd, file);
+    if (fs3.existsSync(filePath)) {
       try {
-        fs.unlinkSync(filePath);
+        fs3.unlinkSync(filePath);
       } catch {
       }
     }
   }
   for (const dir of dirsToRemove) {
-    const dirPath = path.join(cwd, dir);
-    if (fs.existsSync(dirPath)) {
+    const dirPath = path3.join(cwd, dir);
+    if (fs3.existsSync(dirPath)) {
       try {
-        const files = fs.readdirSync(dirPath);
+        const files = fs3.readdirSync(dirPath);
         if (files.length === 0) {
-          fs.rmdirSync(dirPath);
+          fs3.rmdirSync(dirPath);
         }
       } catch {
       }
@@ -1513,12 +1515,27 @@ function detectPackageManager() {
     if (userAgent.includes("yarn")) return "yarn";
     if (userAgent.includes("bun")) return "bun";
   }
-  if (fs.existsSync("pnpm-lock.yaml")) return "pnpm";
-  if (fs.existsSync("yarn.lock")) return "yarn";
-  if (fs.existsSync("bun.lockb")) return "bun";
-  if (fs.existsSync("package-lock.json")) return "npm";
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
+function getBuilderPackageVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const version = pkg2.version;
+    const prereleaseMatch = version.match(/-([a-z]+)\./i);
+    if (prereleaseMatch) {
+      return `@${prereleaseMatch[1]}`;
+    }
+    return `@^${version}`;
+  } catch {
+    return "";
+  }
+}
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
   const detectedIndex = options.indexOf(detected);
@@ -1600,8 +1617,8 @@ async function init(projectNameArg, options = {}) {
     logger.error("Project name is required");
     process.exit(1);
   }
-  const projectPath = path.join(cwd, projectName);
-  if (fs.existsSync(projectPath)) {
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
     logger.error(`Directory "${projectName}" already exists`);
     process.exit(1);
   }
@@ -1633,24 +1650,24 @@ async function init(projectNameArg, options = {}) {
     logger.error("Failed to create Vite project");
     process.exit(1);
   }
-  const viteConfigPath = path.join(projectPath, "vite.config.ts");
-  if (!fs.existsSync(viteConfigPath)) {
+  const viteConfigPath = path3.join(projectPath, "vite.config.ts");
+  if (!fs3.existsSync(viteConfigPath)) {
     const viteConfigContent = `import { defineConfig } from 'vite'
 
 export default defineConfig({
   plugins: [],
 })
 `;
-    fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+    fs3.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
     logger.success("Created vite.config.ts");
   }
-  const packageJsonPath = path.join(projectPath, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path3.join(projectPath, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
     const kebabName = toKebabCase(projectName);
     if (packageJson.name !== kebabName) {
       packageJson.name = kebabName;
-      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
     }
   }
   logger.log("");
@@ -1659,12 +1676,16 @@ export default defineConfig({
   try {
     const installCmd = pm === "npm" ? "install" : "add";
     const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    const builderVersion = getBuilderPackageVersion();
     await runCommand(pm, [
       installCmd,
       devFlag,
       "@cloudflare/vite-plugin",
-      "@standardagents/builder",
-      "wrangler",
+      "wrangler"
+    ], projectPath);
+    await runCommand(pm, [
+      installCmd,
+      `@standardagents/builder${builderVersion}`,
       "zod"
     ], projectPath);
   } catch (error) {
@@ -1737,14 +1758,14 @@ export default defineConfig({
     devVarsLines.push("# OPENAI_API_KEY=your-openai-key");
   }
   devVarsLines.push("");
-  const devVarsPath = path.join(projectPath, ".dev.vars");
-  fs.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
+  const devVarsPath = path3.join(projectPath, ".dev.vars");
+  fs3.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
   logger.success("Created .dev.vars with encryption key");
-  const gitignorePath = path.join(projectPath, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const gitignoreContent = fs3.readFileSync(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".dev.vars")) {
-      fs.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
+      fs3.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
       logger.success("Added .dev.vars to .gitignore");
     }
   }
@@ -1766,6 +1787,535 @@ export default defineConfig({
   logger.log("");
   logger.log("For more information, visit: https://standardagents.ai/docs");
 }
+function getReactPackageVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const version = pkg2.version;
+    const prereleaseMatch = version.match(/-([a-z]+)\./i);
+    if (prereleaseMatch) {
+      return prereleaseMatch[1];
+    }
+    return `^${version}`;
+  } catch {
+    return "latest";
+  }
+}
+function getChatSourceDir() {
+  const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(__dirname2, "../chat");
+}
+async function prompt2(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function runCommand2(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function detectPackageManager2() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.includes("pnpm")) return "pnpm";
+    if (userAgent.includes("yarn")) return "yarn";
+    if (userAgent.includes("bun")) return "bun";
+  }
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
+  return "npm";
+}
+async function selectPackageManager2(detected) {
+  const options = ["npm", "pnpm", "yarn", "bun"];
+  const detectedIndex = options.indexOf(detected);
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = detectedIndex;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a package manager:\n");
+      options.forEach((opt, i) => {
+        const marker = i === detectedIndex ? " (detected)" : "";
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a package manager:\n");
+    options.forEach((opt, i) => {
+      const marker = i === detectedIndex ? " (detected)" : "";
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function selectFramework() {
+  const options = [
+    { value: "vite", label: "Vite (React + TypeScript)" },
+    { value: "nextjs", label: "Next.js (App Router)" }
+  ];
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a framework:\n");
+      options.forEach((opt, i) => {
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a framework:\n");
+    options.forEach((opt, i) => {
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex].value);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isPortOpen(port) {
+  const tryConnect = (host) => {
+    return new Promise((resolve2) => {
+      const socket = new net.Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve2(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.connect(port, host);
+    });
+  };
+  if (await tryConnect("127.0.0.1")) return true;
+  if (await tryConnect("::1")) return true;
+  return false;
+}
+async function isAgentbuilderInstance(url) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e3);
+    const response = await fetch(`${url}/api/agents`, {
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    clearTimeout(timeout);
+    if (response.status === 401) {
+      return true;
+    }
+    if (response.ok) {
+      const data = await response.json();
+      return Array.isArray(data.agents);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function detectAgentbuilderInstance() {
+  const portsToScan = [
+    5173,
+    5174,
+    5175,
+    5176,
+    5177,
+    5178,
+    5179,
+    5180,
+    3e3,
+    3001,
+    3002,
+    3003,
+    8080,
+    8e3,
+    4e3
+  ];
+  logger.log("\x1B[90mScanning for running agentbuilder instance...\x1B[0m");
+  const openPorts = [];
+  await Promise.all(
+    portsToScan.map(async (port) => {
+      if (await isPortOpen(port)) {
+        openPorts.push(port);
+      }
+    })
+  );
+  for (const port of openPorts.sort((a, b) => a - b)) {
+    const url = `http://localhost:${port}`;
+    if (await isAgentbuilderInstance(url)) {
+      return url;
+    }
+  }
+  return null;
+}
+function copyDir(src, dest, skip = []) {
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skip.includes(entry.name)) continue;
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skip);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function initChat(projectNameArg, options = {}) {
+  const cwd = process.cwd();
+  const chatSourceDir = getChatSourceDir();
+  if (!fs3.existsSync(chatSourceDir)) {
+    logger.error("Chat source files not found. This CLI installation may be corrupted.");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info("Scaffolding a frontend chat application...");
+  logger.log("");
+  let projectName = projectNameArg;
+  if (!projectName && !options.yes) {
+    projectName = await prompt2("Project name: ");
+  }
+  if (!projectName) {
+    logger.error("Project name is required");
+    process.exit(1);
+  }
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
+    logger.error(`Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  let framework;
+  if (options.framework) {
+    framework = options.framework;
+  } else if (options.yes) {
+    framework = "vite";
+  } else {
+    framework = await selectFramework();
+    logger.log("");
+  }
+  let serverUrl;
+  if (options.yes) {
+    serverUrl = "http://localhost:5173";
+  } else {
+    const detectedUrl = await detectAgentbuilderInstance();
+    if (detectedUrl) {
+      logger.success(`Found agentbuilder at ${detectedUrl}`);
+      const urlInput = await prompt2(`Agentbuilder dev server URL [${detectedUrl}]: `);
+      serverUrl = urlInput || detectedUrl;
+    } else {
+      logger.log("\x1B[90mNo running agentbuilder instance found\x1B[0m");
+      const urlInput = await prompt2("Agentbuilder dev server URL [http://localhost:5173]: ");
+      serverUrl = urlInput || "http://localhost:5173";
+    }
+    if (!isValidUrl(serverUrl)) {
+      logger.error("Invalid URL format");
+      process.exit(1);
+    }
+  }
+  const detectedPm = detectPackageManager2();
+  let pm;
+  if (options.yes) {
+    pm = detectedPm;
+  } else {
+    pm = await selectPackageManager2(detectedPm);
+    logger.log("");
+  }
+  logger.log("");
+  logger.info(`Creating ${framework === "vite" ? "Vite" : "Next.js"} project...`);
+  logger.log("");
+  fs3.mkdirSync(projectPath, { recursive: true });
+  const reactVersion = getReactPackageVersion();
+  if (framework === "vite") {
+    await scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  } else {
+    await scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  }
+  logger.log("");
+  logger.info("Installing dependencies...");
+  logger.log("");
+  try {
+    await runCommand2(pm, pm === "npm" ? ["install"] : ["install"], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.success("Chat UI scaffolded successfully!");
+  logger.log("");
+  logger.info("Starting development server...");
+  logger.log("");
+  const devArgs = pm === "npm" ? ["run", "dev"] : ["dev"];
+  const devProcess = spawn(pm, devArgs, {
+    cwd: projectPath,
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: false
+  });
+  let browserOpened = false;
+  const openBrowser = (url) => {
+    if (browserOpened) return;
+    browserOpened = true;
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn(openCmd, [url], { stdio: "ignore", detached: true }).unref();
+  };
+  devProcess.stdout?.on("data", (data) => {
+    const text = data.toString();
+    process.stdout.write(data);
+    const urlMatch = text.match(/Local:\s+(https?:\/\/localhost:\d+\/?)/);
+    if (urlMatch && !browserOpened) {
+      openBrowser(urlMatch[1]);
+    }
+  });
+  devProcess.stderr?.on("data", (data) => {
+    process.stderr.write(data);
+  });
+  devProcess.on("error", (error) => {
+    logger.error(`Failed to start dev server: ${error.message}`);
+    process.exit(1);
+  });
+}
+async function scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const viteDir = path3.join(chatSourceDir, "vite");
+  let indexHtml = fs3.readFileSync(path3.join(viteDir, "index.html"), "utf-8");
+  indexHtml = indexHtml.replace('src="/main.tsx"', 'src="/src/main.tsx"');
+  fs3.writeFileSync(path3.join(projectPath, "index.html"), indexHtml, "utf-8");
+  logger.success("Created index.html");
+  fs3.copyFileSync(path3.join(viteDir, "main.tsx"), path3.join(projectPath, "src", "main.tsx"));
+  logger.success("Created src/main.tsx");
+  let viteConfig = fs3.readFileSync(path3.join(viteDir, "vite.config.ts"), "utf-8");
+  viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+  ],
+})
+`;
+  fs3.writeFileSync(path3.join(projectPath, "vite.config.ts"), viteConfig, "utf-8");
+  logger.success("Created vite.config.ts");
+  fs3.copyFileSync(path3.join(chatSourceDir, "tsconfig.json"), path3.join(projectPath, "tsconfig.json"));
+  const tsconfig = JSON.parse(fs3.readFileSync(path3.join(projectPath, "tsconfig.json"), "utf-8"));
+  tsconfig.include = ["src"];
+  delete tsconfig.compilerOptions?.paths;
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  fs3.copyFileSync(path3.join(chatSourceDir, "package.json"), path3.join(projectPath, "package.json"));
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(projectPath, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "vite",
+    build: "vite build",
+    preview: "vite preview"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.dependencies?.["next"];
+  delete pkg2.devDependencies?.["@tailwindcss/postcss"];
+  delete pkg2.devDependencies?.["postcss"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+VITE_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env"), envContent, "utf-8");
+  logger.success("Created .env");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+dist
+.env
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let mainTsx = fs3.readFileSync(path3.join(projectPath, "src", "main.tsx"), "utf-8");
+  mainTsx = mainTsx.replace(/from '\.\.\/src\//g, "from './").replace(/import '\.\.\/src\//g, "import './");
+  fs3.writeFileSync(path3.join(projectPath, "src", "main.tsx"), mainTsx, "utf-8");
+  if (fs3.existsSync(path3.join(viteDir, "favicon.svg"))) {
+    fs3.copyFileSync(path3.join(viteDir, "favicon.svg"), path3.join(projectPath, "favicon.svg"));
+    logger.success("Created favicon.svg");
+  }
+}
+async function scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const nextDir = path3.join(chatSourceDir, "next");
+  copyDir(path3.join(nextDir, "app"), path3.join(projectPath, "app"), []);
+  logger.success("Copied app/");
+  fs3.copyFileSync(path3.join(nextDir, "next.config.ts"), path3.join(projectPath, "next.config.ts"));
+  logger.success("Created next.config.ts");
+  fs3.copyFileSync(path3.join(nextDir, "postcss.config.mjs"), path3.join(projectPath, "postcss.config.mjs"));
+  logger.success("Created postcss.config.mjs");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  };
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(chatSourceDir, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.devDependencies?.["@tailwindcss/vite"];
+  delete pkg2.devDependencies?.["@vitejs/plugin-react"];
+  delete pkg2.devDependencies?.["vite"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+NEXT_PUBLIC_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env.local"), envContent, "utf-8");
+  logger.success("Created .env.local");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+.next
+out
+.env.local
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let layoutTsx = fs3.readFileSync(path3.join(projectPath, "app", "layout.tsx"), "utf-8");
+  layoutTsx = layoutTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "layout.tsx"), layoutTsx, "utf-8");
+  let pageTsx = fs3.readFileSync(path3.join(projectPath, "app", "page.tsx"), "utf-8");
+  pageTsx = pageTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "page.tsx"), pageTsx, "utf-8");
+}
 
 // src/index.ts
 var __dirname$1 = dirname(fileURLToPath(import.meta.url));
@@ -1774,6 +2324,7 @@ var program = new Command();
 program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version(pkg.version);
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
+program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map