@standardagents/cli 0.12.9 → 0.13.0

package/dist/index.js

@@ -4,7 +4,7 @@ import path3 from 'path';
 import fs3 from 'fs';
 import crypto from 'crypto';
 import readline from 'readline';
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import chalk from 'chalk';
 import { parse, modify, applyEdits } from 'jsonc-parser';
 import { loadFile, writeFile, generateCode } from 'magicast';
@@ -127,16 +127,37 @@ interface ThreadState {
   agentId: string;            // Agent identifier
   userId: string | null;      // User identifier (if set)
   createdAt: number;          // Creation timestamp
+  children: SubagentRegistryEntry[]; // Resumable child registry
+  terminated: number | null;  // Soft-termination timestamp
 
   // Methods
   getMessages(options?): Promise<MessagesResult>;  // Get conversation history
   injectMessage(input): Promise<Message>;          // Add message to thread
+  queueMessage(input): Promise<void>;              // Queue message for next step
   loadModel(name): Promise<ModelConfig>;           // Load model definition
   loadPrompt(name): Promise<PromptConfig>;         // Load prompt definition
   loadAgent(name): Promise<AgentConfig>;           // Load agent definition
+  env(propertyName): Promise<string>;              // Resolve env value for this thread
+  setEnv(propertyName, value): Promise<void>;      // Set thread env + propagate to active descendants
+  notifyParent(content): Promise<void>;            // Explicitly queue a silent message to the parent
+  setStatus(status): Promise<void>;                // Update this child in the parent registry
+  getChildThread(referenceId): Promise<ThreadState | null>; // Resolve child thread
+  getParentThread(): Promise<ThreadState | null>;            // Resolve parent thread
+  terminate(): Promise<void>;                      // Soft-terminate thread
 }
 \`\`\`
 
+## Subagents
+
+\`dual_ai\` agents can be used as subagents from prompt tool configs:
+
+- Each subagent runs in its own thread (\`DurableThread\`)
+- Parent/child linkage is tracked in thread metadata
+- Resumable children are visible in \`state.children\`
+- Parent threads create/message resumable children via built-ins (\`subagent_create\`, \`subagent_message\`)
+- Child completion results are queued back to the parent when \`parentCommunication\` is \`implicit\`
+- Explicit relationships can stay idle until code calls \`state.notifyParent()\` or \`state.setStatus()\`
+
 Access in tools:
 \`\`\`typescript
 export default defineTool('...', schema, async (state, args) => {
@@ -297,12 +318,14 @@ 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 (include ai_human agent names for handoffs) |
+| \`tools\` | \`(string \\| ToolConfig \\| SubagentToolConfig)[]\` | No | Available tools (include ai_human agent names for handoffs and dual_ai subagent configs) |
 | \`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 |
+| \`variables\` | \`VariableDefinition[]\` | No | Variable declarations (\`name\`, \`type\`, \`required\`, \`scoped\`, \`description\`) |
+| \`env\` | \`Record<string, string>\` | No | Prompt-level default values for variables |
 | \`hooks\` | \`string[]\` | No | Hook IDs to run for this prompt (overrides agent hooks) |
 | \`reasoning\` | \`ReasoningConfig\` | No | Extended thinking configuration |
 
@@ -335,11 +358,14 @@ export default definePrompt({
   prompt: [
     { type: 'text', content: 'You are a helpful assistant.\\n\\n' },
     { type: 'include', prompt: 'common_rules' },  // Includes another prompt
+    { type: 'env', property: 'ASSISTANT_TONE' },  // Inject variable value
     { type: 'text', content: '\\n\\nBe concise.' },
   ],
 });
 \`\`\`
 
+\`type: 'env'\` inserts a resolved thread variable value. Use this only for non-secret values that are safe to expose to the LLM.
+
 ## Tool Configuration
 
 Tools can be simple names or detailed configs:
@@ -357,6 +383,48 @@ tools: [
 ],
 \`\`\`
 
+### Subagent Tool Configuration
+
+Use \`SubagentToolConfig\` when the tool is a \`dual_ai\` agent:
+
+\`\`\`typescript
+tools: [
+  // Blocking, non-resumable (default)
+  { name: 'data_processor_agent' },
+
+  // Non-blocking, resumable with a single instance
+  {
+    name: 'browser_agent',
+    blocking: false,
+    immediate: {
+      nameEnv: 'BROWSER_AGENT_NAME',
+      descriptionEnv: 'BROWSER_AGENT_DESCRIPTION',
+      scopedEnv: ['BROWSER_AGENT_API_KEY'],
+    },
+    optional: 'ENABLE_BROWSER_AGENT',
+    initAgentNameProperty: 'name',
+    resumable: {
+      receives_messages: 'side_a',
+      maxInstances: 1,
+      parentCommunication: 'explicit',
+    },
+  },
+]
+\`\`\`
+
+When prompt-configured resumable dual_ai subagents exist, the runtime auto-injects:
+- \`subagent_create\` for spawning new child instances
+- \`subagent_message\` for messaging active resumable instances
+
+\`subagent_create\` supports optional \`name\` for human-friendly child thread labels.
+Pair it with \`initAgentNameProperty\` to map that argument into a \`name:<value>\` thread tag.
+
+Set \`immediate: true\` to run a tool automatically when the prompt activates.
+Use \`immediate: { nameEnv, descriptionEnv, scopedEnv }\` when you want safe per-instance bootstrap hints while keeping copied scoped env runtime-only.
+Set \`optional: 'ENV_NAME'\` to enable a subagent branch only when env resolves to \`true\`, \`1\`, or \`yes\`.
+Set \`resumable.parentCommunication: 'explicit'\` when the child should stay quiet until its own tools or hooks call \`state.notifyParent()\` or \`state.setStatus()\`.
+If required scoped vars are missing, the runtime returns \`error_code: "subagent_env_required"\` with a temporary \`GET/POST /api/threads/:id/variables/:requestId\` endpoint in \`error_data.endpoint\`.
+
 ## Input Validation
 
 Validate inputs when prompt is called as a tool:
@@ -447,6 +515,7 @@ Agents orchestrate conversations by defining prompts, stop conditions, and turn
 | \`maxSessionTurns\` | \`number\` | No | Max total turns across both sides |
 | \`exposeAsTool\` | \`boolean\` | No | Allow other prompts to hand off to this agent |
 | \`toolDescription\` | \`string\` | No | Description when used as tool (required if exposeAsTool) |
+| \`env\` | \`Record<string, string>\` | No | Agent-level default variable values |
 | \`hooks\` | \`string[]\` | No | Hook IDs to run for this agent (fallback if prompt has no hooks) |
 | \`tags\` | \`string[]\` | No | Tags for categorization and filtering |
 
@@ -460,6 +529,8 @@ Agents orchestrate conversations by defining prompts, stop conditions, and turn
 | \`stopTool\` | \`string\` | No | Tool that stops this side's turn |
 | \`stopToolResponseProperty\` | \`string\` | No | Property to extract from stop tool result |
 | \`endConversationTool\` | \`string\` | No | Tool that ends the entire conversation |
+| \`failSessionTool\` | \`string\` | No | Tool that fails and ends the entire conversation |
+| \`statusTool\` | \`string\` | No | Tool that reports subagent status to a parent registry |
 | \`maxTurns\` | \`number\` | No | Maximum turns for this side |
 | \`manualStopCondition\` | \`boolean\` | No | Enable custom stop handling via hooks |
 
@@ -504,6 +575,34 @@ export default defineAgent({
 });
 \`\`\`
 
+## Dual-AI Subagent Pattern
+
+When a \`dual_ai\` agent is used as a subagent tool, a common split is:
+- **sideA**: performs work (tools, data gathering, execution)
+- **sideB**: reflection, verification, and quality checks
+
+\`\`\`typescript
+export default defineAgent({
+  name: 'research_subagent',
+  type: 'dual_ai',
+  exposeAsTool: true,
+  toolDescription: 'Researches and validates findings autonomously',
+  maxSessionTurns: 16,
+  sideA: {
+    label: 'Worker',
+    prompt: 'research_worker',
+    statusTool: 'set_subagent_status',
+    failSessionTool: 'fail_research_subagent',
+    endConversationTool: 'finish_subagent',
+  },
+  sideB: {
+    label: 'Reviewer',
+    prompt: 'research_reviewer',
+    stopOnResponse: true,
+  },
+});
+\`\`\`
+
 ## Agent Handoffs
 
 Expose an agent for handoffs from other prompts:
@@ -524,11 +623,12 @@ Other prompts can then include the agent name in their \`tools\` array to enable
 
 ## Stop Conditions (Priority Order)
 
-1. **endConversationTool** - Ends entire conversation (highest priority)
-2. **stopTool** - Ends current side's turn
-3. **maxTurns** - Ends side's participation when reached
-4. **stopOnResponse** - Ends turn when LLM returns text
-5. **maxSessionTurns** - Ends conversation (hard limit: 250)
+1. **failSessionTool** - Ends entire conversation with a terminal failure
+2. **endConversationTool** - Ends entire conversation successfully
+3. **stopTool** - Ends current side's turn
+4. **maxTurns** - Ends side's participation when reached
+5. **stopOnResponse** - Ends turn when LLM returns text
+6. **maxSessionTurns** - Ends conversation (hard limit: 250)
 
 ## Hooks
 
@@ -578,7 +678,7 @@ defineTool({
   description: string,           // What the tool does (shown to LLM)
   args?: z.ZodObject,            // Input validation schema (optional)
   execute: (state, args) => ToolResult,  // Implementation
-  tenvs?: z.ZodObject,           // Thread environment variables (optional)
+  variables?: VariableDefinition[], // Declared variables (optional)
 })
 \`\`\`
 
@@ -611,6 +711,8 @@ export default defineTool({
 | \`status\` | \`'success' \\| 'error'\` | Whether the tool succeeded |
 | \`result\` | \`string\` | Tool output (required for success) |
 | \`error\` | \`string\` | Error message (for error status) |
+| \`error_code\` | \`string\` | Machine-readable error code |
+| \`error_data\` | \`Record<string, unknown>\` | Structured error payload |
 | \`attachments\` | \`ToolAttachment[]\` | Files to attach (images, etc.) |
 
 ## ThreadState Access
@@ -630,8 +732,9 @@ execute: async (state, args) => {
   // Message history
   const messages = state.messages;
 
-  // Environment bindings
-  const env = state.env;
+  // Thread variable resolution
+  const apiKey = await state.env('GOOGLE_API_KEY');
+  await state.setEnv('LAST_TOOL_RUN_AT', new Date().toISOString());
 
   // Parent state (for sub-prompts)
   const root = state.rootState;
@@ -718,25 +821,33 @@ export default defineTool({
 });
 \`\`\`
 
-## Thread Environment Variables (tenvs)
+## Variables and Env
 
-Tools can declare required thread environment variables:
+Tools can declare variable requirements with \`variables\`, including \`required\` and \`description\` metadata:
 
 \`\`\`typescript
 export default defineTool({
   description: 'Search uploaded documents',
   args: z.object({ query: z.string() }),
   execute: async (state, args) => {
-    const vectorStoreId = state.tenvs.vectorStoreId;
+    const vectorStoreId = await state.env('VECTOR_STORE_ID');
     const results = await searchVectorStore(vectorStoreId, args.query);
     return { status: 'success', result: JSON.stringify(results) };
   },
-  tenvs: z.object({
-    vectorStoreId: z.string().describe('OpenAI Vector Store ID'),
-  }),
+  variables: [
+    {
+      name: 'VECTOR_STORE_ID',
+      type: 'text',
+      required: true,
+      scoped: false,
+      description: 'OpenAI Vector Store ID',
+    },
+  ],
 });
 \`\`\`
 
+Use \`scoped: true\` for per-instance values that should not inherit from parent thread env (for example per-account OAuth tokens on subagents).
+
 ## Returning Attachments
 
 Tools can return file attachments (e.g., generated images):
@@ -1056,6 +1167,10 @@ export default defineThreadEndpoint(async (req, state) => {
     order: 'desc',
   });
 
+  // Thread env (thread scope + active descendants)
+  const approvalGate = await state.env('TOPDOWN_APPROVAL_GATE');
+  await state.setEnv('TOPDOWN_APPROVAL_GATE', approvalGate || 'open');
+
   // File system operations
   const files = await state.findFiles('**/*.json');
   const data = await state.readFile('/data/config.json');
@@ -1702,7 +1817,7 @@ function getPackageVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.12.9";
+  return "0.13.0";
 }
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
@@ -1799,21 +1914,25 @@ async function init(projectNameArg, options = {}) {
     switch (pm) {
       case "pnpm":
         createCmd = "pnpm";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
         break;
       case "yarn":
         createCmd = "yarn";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
         break;
       case "bun":
         createCmd = "bun";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
         break;
       default:
         createCmd = "npm";
-        createArgs = ["create", "vite@latest", projectName, "--", "--template", template, "--no-interactive"];
+        createArgs = ["create", "vite@latest", projectName, "--", "--template", template, "--yes"];
     }
     await runCommand(createCmd, createArgs, cwd);
+    const createdPackageJsonPath = path3.join(projectPath, "package.json");
+    if (!fs3.existsSync(createdPackageJsonPath)) {
+      throw new Error("Vite project scaffolding did not create package.json");
+    }
   } catch (error) {
     logger.error("Failed to create Vite project");
     process.exit(1);
@@ -2916,16 +3035,307 @@ async function listPacked() {
     console.log("");
   }
 }
+var DEFAULT_ENDPOINT = "https://api.standardagents.ai";
+var FREE_TIER_BUNDLE_LIMIT = 5 * 1024 * 1024;
+function parseEnvFile(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function compareVersions(a, b) {
+  const [coreA, preA] = a.replace(/^v/, "").split("-", 2);
+  const [coreB, preB] = b.replace(/^v/, "").split("-", 2);
+  const partsA = coreA.split(".").map(Number);
+  const partsB = coreB.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const va = partsA[i] ?? 0;
+    const vb = partsB[i] ?? 0;
+    if (va < vb) return -1;
+    if (va > vb) return 1;
+  }
+  if (preA && !preB) return -1;
+  if (!preA && preB) return 1;
+  return 0;
+}
+function validateBundleSize(sizeBytes) {
+  if (sizeBytes > FREE_TIER_BUNDLE_LIMIT) {
+    return `Bundle size (${formatBytes(sizeBytes)}) exceeds the free tier limit (${formatBytes(FREE_TIER_BUNDLE_LIMIT)}). A paid plan may be required.`;
+  }
+  return null;
+}
+function createManifest(agents, builderVersion) {
+  return {
+    agents,
+    builder_version: builderVersion
+  };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDeployError(response) {
+  if (response.error) {
+    return `${response.error.code}: ${response.error.message}`;
+  }
+  if (response.errors && response.errors.length > 0) {
+    return response.errors.join("\n");
+  }
+  return "Unknown error";
+}
+function detectProject() {
+  const hasWranglerJsonc = fs3.existsSync("wrangler.jsonc") || fs3.existsSync("wrangler.json");
+  const hasAgentsDir = fs3.existsSync("agents/agents");
+  return hasWranglerJsonc || hasAgentsDir;
+}
+function loadConfig(options) {
+  const envFileVars = fs3.existsSync(".env") ? parseEnvFile(fs3.readFileSync(".env", "utf-8")) : {};
+  const apiKey = options.apiKey || process.env.PLATFORM_API_KEY || envFileVars.PLATFORM_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "No API key found. Provide one with --api-key, set PLATFORM_API_KEY env var, or add it to .env"
+    );
+  }
+  const endpoint = options.endpoint || process.env.PLATFORM_ENDPOINT || envFileVars.PLATFORM_ENDPOINT || DEFAULT_ENDPOINT;
+  return { apiKey, endpoint };
+}
+function discoverAgents() {
+  const agentsDir = "agents/agents";
+  if (!fs3.existsSync(agentsDir)) return [];
+  const scriptExtensions = /* @__PURE__ */ new Set([".ts", ".js", ".mts", ".mjs"]);
+  const files = fs3.readdirSync(agentsDir).filter((f) => scriptExtensions.has(path3.extname(f)));
+  return files.map((file) => {
+    const filePath = path3.join(agentsDir, file);
+    const realPath = fs3.realpathSync(filePath);
+    if (!realPath.startsWith(fs3.realpathSync("."))) {
+      return path3.basename(file, path3.extname(file));
+    }
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const nameMatch = content.match(/defineAgent\s*\(\s*\{[\s\S]*?\bname\s*:\s*['"]([^'"]+)['"]/);
+    return nameMatch ? nameMatch[1] : path3.basename(file, path3.extname(file));
+  });
+}
+function getBuilderVersion() {
+  const searchPaths = [
+    "node_modules/@standardagents/builder/package.json",
+    "../node_modules/@standardagents/builder/package.json"
+  ];
+  for (const p of searchPaths) {
+    if (fs3.existsSync(p)) {
+      const pkg = JSON.parse(fs3.readFileSync(p, "utf-8"));
+      return pkg.version;
+    }
+  }
+  throw new Error("Could not find @standardagents/builder. Is it installed?");
+}
+function detectPackageManager3() {
+  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") || fs3.existsSync("bun.lock")) return "bun";
+  return "npm";
+}
+function buildProject(endpoint) {
+  const pm = detectPackageManager3();
+  const buildCmd = pm === "npm" ? "npx vite build" : `${pm} exec vite build`;
+  execSync(buildCmd, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      PLATFORM_ENDPOINT: endpoint
+    }
+  });
+}
+function findWorkerBundle() {
+  const searchDirs = [".wrangler/tmp", "dist"];
+  for (const dir of searchDirs) {
+    if (!fs3.existsSync(dir)) continue;
+    const bundle = findBundleInDir(dir);
+    if (bundle) return bundle;
+  }
+  throw new Error(
+    "Could not find Worker bundle in build output.\nExpected build output in .wrangler/tmp/ or dist/.\nMake sure `vite build` completed successfully."
+  );
+}
+function findBundleInDir(dir) {
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  const jsFiles = entries.filter((e) => e.isFile() && (e.name.endsWith(".js") || e.name.endsWith(".mjs")));
+  jsFiles.sort((a, b) => {
+    const aIsIndex = a.name === "index.js" || a.name === "index.mjs" ? 0 : 1;
+    const bIsIndex = b.name === "index.js" || b.name === "index.mjs" ? 0 : 1;
+    if (aIsIndex !== bIsIndex) return aIsIndex - bIsIndex;
+    const aSize = fs3.statSync(path3.join(dir, a.name)).size;
+    const bSize = fs3.statSync(path3.join(dir, b.name)).size;
+    return bSize - aSize;
+  });
+  for (const entry of jsFiles) {
+    const fullPath = path3.join(dir, entry.name);
+    const content = fs3.readFileSync(fullPath);
+    if (content.length > 0 && content.toString("utf-8", 0, 1e4).includes("export")) {
+      return { bundlePath: fullPath, bundleContent: content };
+    }
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name !== "client" && entry.name !== "node_modules") {
+      const result = findBundleInDir(path3.join(dir, entry.name));
+      if (result) return result;
+    }
+  }
+  return null;
+}
+async function checkPlatformVersion(endpoint, builderVersion) {
+  const res = await fetch(`${endpoint}/manifest`);
+  if (!res.ok) {
+    throw new Error(`Failed to check platform version: ${res.status} ${res.statusText}`);
+  }
+  const manifest = await res.json();
+  if (compareVersions(builderVersion, manifest.minimum_builder_version) < 0) {
+    throw new Error(
+      `Builder version ${builderVersion} is below the platform minimum (${manifest.minimum_builder_version}).
+Please upgrade @standardagents/builder:
+  npm install @standardagents/builder@latest`
+    );
+  }
+  return manifest;
+}
+async function uploadDeploy(endpoint, apiKey, bundleContent, manifest, builderVersion) {
+  const formData = new FormData();
+  formData.append("bundle", new Blob([new Uint8Array(bundleContent)], { type: "application/javascript" }), "index.js");
+  formData.append("manifest", new Blob([JSON.stringify(manifest)], { type: "application/json" }), "manifest.json");
+  formData.append("builder_version", builderVersion);
+  formData.append("agent_count", String(manifest.agents.length));
+  const res = await fetch(`${endpoint}/deploys`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: formData
+  });
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error(`Deploy failed (${res.status}): Invalid response from server`);
+  }
+  if (!res.ok) {
+    const errorMsg = formatDeployError(body);
+    throw new Error(`Deploy failed (${res.status}): ${errorMsg}`);
+  }
+  return body;
+}
+async function deploy(options) {
+  console.log("");
+  logger.info(`${chalk.bold("Standard Agents Deploy")}
+`);
+  if (!detectProject()) {
+    logger.error("This does not appear to be a Standard Agents project.");
+    logger.info("Run this command from a directory with wrangler.jsonc and agents/agents/.");
+    process.exit(1);
+  }
+  let apiKey;
+  let endpoint;
+  try {
+    ({ apiKey, endpoint } = loadConfig(options));
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+  logger.success("Configuration loaded");
+  const agents = discoverAgents();
+  if (agents.length === 0) {
+    logger.error("No agents found in agents/agents/.");
+    logger.info("Create at least one agent with defineAgent() before deploying.");
+    process.exit(1);
+  }
+  logger.success(`Found ${agents.length} agent${agents.length === 1 ? "" : "s"}: ${agents.join(", ")}`);
+  let builderVersion;
+  try {
+    builderVersion = getBuilderVersion();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+  logger.info(`Builder version: ${builderVersion}`);
+  try {
+    const platformManifest = await checkPlatformVersion(endpoint, builderVersion);
+    if (compareVersions(builderVersion, platformManifest.latest_builder_version) < 0) {
+      logger.warning(
+        `A newer builder version is available (${platformManifest.latest_builder_version}). Consider upgrading.`
+      );
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+  logger.info("Building project...\n");
+  try {
+    buildProject(endpoint);
+  } catch {
+    console.log("");
+    logger.error("Build failed. See output above for details.");
+    process.exit(1);
+  }
+  console.log("");
+  logger.success("Build complete");
+  let bundlePath;
+  let bundleContent;
+  try {
+    ({ bundlePath, bundleContent } = findWorkerBundle());
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+  const manifest = createManifest(agents, builderVersion);
+  logger.success(`Bundle: ${bundlePath} (${formatBytes(bundleContent.length)})`);
+  const sizeWarning = validateBundleSize(bundleContent.length);
+  if (sizeWarning) {
+    logger.warning(sizeWarning);
+  }
+  logger.info("Uploading...");
+  try {
+    const result = await uploadDeploy(endpoint, apiKey, bundleContent, manifest, builderVersion);
+    console.log("");
+    logger.success(chalk.bold("Deploy successful!"));
+    console.log(`  Deploy ID: ${result.deploy.id}`);
+    console.log(`  Status:    ${result.deploy.status}`);
+    if (result.deploy.account_id) {
+      console.log(`  URL:       https://${result.deploy.account_id}.standardagents.ai`);
+    }
+    console.log("");
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+}
 
 // src/index.ts
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.12.9");
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.13.0");
 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.command("pack [agent-name]").description("Pack an agent with all its dependencies").option("--output <dir>", "Output directory (default: agents/packed)").option("--npm", "Generate npm-ready package structure").option("--version <version>", "Package version (default: 1.0.0)").option("--no-remove", "Keep original files after packing").option("--no-interactive", "Skip interactive item mode selector").action(pack);
 program.command("unpack [package]").description("Unpack a packed agent to the local agents directory").option("--no-signatures", "Remove package signatures (fully editable)").action(unpack);
 program.command("list-packed").description("List all discovered packed agents").action(listPacked);
+program.command("deploy").description("Build and deploy your project to the Standard Agents platform").option("--api-key <key>", "Platform API key (overrides PLATFORM_API_KEY env var)").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").action(deploy);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map