@struere/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1703 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/dev.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import chokidar from "chokidar";
+import { join as join4 } from "path";
+
+// src/utils/config.ts
+import { join } from "path";
+var defaultConfig = {
+  port: 3000,
+  host: "localhost",
+  cors: {
+    origins: ["http://localhost:3000"],
+    credentials: true
+  },
+  logging: {
+    level: "info",
+    format: "pretty"
+  },
+  auth: {
+    type: "none"
+  }
+};
+async function loadConfig(cwd) {
+  const configPath = join(cwd, "af.config.ts");
+  try {
+    const module = await import(configPath);
+    const config = module.default || module;
+    return {
+      ...defaultConfig,
+      ...config,
+      cors: {
+        ...defaultConfig.cors,
+        ...config.cors
+      },
+      logging: {
+        ...defaultConfig.logging,
+        ...config.logging
+      },
+      auth: {
+        ...defaultConfig.auth,
+        ...config.auth
+      }
+    };
+  } catch {
+    return defaultConfig;
+  }
+}
+
+// src/utils/agent.ts
+import { join as join2 } from "path";
+async function loadAgent(cwd) {
+  const agentPath = join2(cwd, "src/agent.ts");
+  try {
+    const module = await import(agentPath);
+    const agent = module.default || module;
+    if (!agent.name) {
+      throw new Error("Agent must have a name");
+    }
+    if (!agent.version) {
+      throw new Error("Agent must have a version");
+    }
+    if (!agent.systemPrompt) {
+      throw new Error("Agent must have a systemPrompt");
+    }
+    return agent;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(`Agent not found at ${agentPath}`);
+    }
+    throw error;
+  }
+}
+
+// src/commands/dev.ts
+import { AgentExecutor } from "@struere/runtime";
+
+// src/utils/credentials.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+var CONFIG_DIR = join3(homedir(), ".struere");
+var CREDENTIALS_FILE = join3(CONFIG_DIR, "credentials.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function saveCredentials(credentials) {
+  ensureConfigDir();
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+function loadCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(CREDENTIALS_FILE, "utf-8");
+    const credentials = JSON.parse(data);
+    if (new Date(credentials.expiresAt) < new Date) {
+      clearCredentials();
+      return null;
+    }
+    return credentials;
+  } catch {
+    return null;
+  }
+}
+function clearCredentials() {
+  if (existsSync(CREDENTIALS_FILE)) {
+    unlinkSync(CREDENTIALS_FILE);
+  }
+}
+function getApiKey() {
+  const credentials = loadCredentials();
+  if (credentials?.apiKey) {
+    return credentials.apiKey;
+  }
+  return process.env.STRUERE_API_KEY || null;
+}
+function getToken() {
+  const credentials = loadCredentials();
+  return credentials?.token || null;
+}
+function isLoggedIn() {
+  return loadCredentials() !== null;
+}
+
+// src/utils/api.ts
+var DEFAULT_API_URL = "https://api.struere.dev";
+var DEFAULT_SYNC_URL = "wss://sync.struere.dev";
+function getApiUrl() {
+  return process.env.STRUERE_API_URL || DEFAULT_API_URL;
+}
+function getSyncUrl() {
+  return process.env.STRUERE_SYNC_URL || DEFAULT_SYNC_URL;
+}
+
+class ApiClient {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl || getApiUrl();
+  }
+  async request(path, options = {}) {
+    const token = getToken();
+    const apiKey = getApiKey();
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    } else if (apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = data;
+      throw new ApiError(error.error?.message || `HTTP ${response.status}`, error.error?.code || "UNKNOWN_ERROR", response.status);
+    }
+    return data;
+  }
+  async login(email, password) {
+    return this.request("/v1/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password })
+    });
+  }
+  async signup(email, name, password) {
+    return this.request("/v1/auth/signup", {
+      method: "POST",
+      body: JSON.stringify({ email, name, password })
+    });
+  }
+  async getMe() {
+    return this.request("/v1/auth/me");
+  }
+  async refreshToken() {
+    return this.request("/v1/auth/refresh", { method: "POST" });
+  }
+  async listAgents() {
+    return this.request("/v1/agents");
+  }
+  async createAgent(data) {
+    return this.request("/v1/agents", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getAgent(agentId) {
+    return this.request(`/v1/agents/${agentId}`);
+  }
+  async deployAgent(agentId, data) {
+    return this.request(`/v1/deployments/agents/${agentId}/deploy`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async createApiKey(data) {
+    return this.request("/v1/api-keys", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async listApiKeys() {
+    return this.request("/v1/api-keys");
+  }
+  async getUsage(period = "day") {
+    return this.request(`/v1/usage?period=${period}`);
+  }
+}
+
+class ApiError extends Error {
+  code;
+  status;
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "ApiError";
+  }
+}
+
+// src/commands/dev.ts
+var devCommand = new Command("dev").description("Start development server with hot reload").option("-p, --port <port>", "Port to run on", "3000").option("-c, --channel <channel>", "Channel to open (web, api)", "web").option("--no-open", "Do not open browser").option("--local", "Run locally without cloud sync").option("--cloud", "Force cloud-connected mode").action(async (options) => {
+  const spinner = ora();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk.bold("Struere Dev Server"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  const port = parseInt(options.port) || config.port || 3000;
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  let agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  const useCloud = options.cloud || !options.local && isLoggedIn();
+  if (useCloud) {
+    await runCloudDev(agent, cwd, port, options, spinner);
+  } else {
+    await runLocalDev(agent, cwd, port, options, spinner);
+  }
+});
+async function runLocalDev(agent, cwd, port, options, spinner) {
+  let executor = new AgentExecutor(agent);
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health") {
+        return Response.json({ status: "ok", agent: agent.name, mode: "local" });
+      }
+      if (url.pathname === "/api/chat" && req.method === "POST") {
+        const body = await req.json();
+        const conversationId = body.conversationId || crypto.randomUUID();
+        if (body.stream) {
+          const stream = new ReadableStream({
+            async start(controller) {
+              const encoder = new TextEncoder;
+              const sendEvent = (event, data) => {
+                controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+              };
+              sendEvent("start", { conversationId });
+              for await (const chunk of executor.stream({ conversationId, message: body.message })) {
+                sendEvent(chunk.type, chunk);
+              }
+              controller.close();
+            }
+          });
+          return new Response(stream, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            }
+          });
+        }
+        const response = await executor.execute({ conversationId, message: body.message });
+        return Response.json({
+          response: response.message,
+          conversationId: response.conversationId,
+          toolCalls: response.toolCalls,
+          usage: response.usage
+        });
+      }
+      if (url.pathname === "/" && options.channel === "web") {
+        return new Response(getDevHtml(agent.name, "local"), {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+  });
+  console.log();
+  console.log(chalk.gray("Mode:"), chalk.yellow("Local"));
+  console.log(chalk.green("Server running at"), chalk.cyan(`http://localhost:${port}`));
+  console.log();
+  if (options.channel === "web" && options.open) {
+    const openUrl = `http://localhost:${port}`;
+    if (process.platform === "darwin") {
+      Bun.spawn(["open", openUrl]);
+    } else if (process.platform === "linux") {
+      Bun.spawn(["xdg-open", openUrl]);
+    }
+  }
+  spinner.start("Watching for changes");
+  const watcher = chokidar.watch([join4(cwd, "src"), join4(cwd, "af.config.ts")], {
+    ignoreInitial: true,
+    ignored: /node_modules/
+  });
+  watcher.on("change", async (path) => {
+    spinner.text = `Reloading (${path.replace(cwd, ".")})`;
+    try {
+      agent = await loadAgent(cwd);
+      executor = new AgentExecutor(agent);
+      spinner.succeed(`Reloaded "${agent.name}"`);
+      spinner.start("Watching for changes");
+    } catch (error) {
+      spinner.fail(`Reload failed: ${error}`);
+      spinner.start("Watching for changes");
+    }
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    spinner.stop();
+    watcher.close();
+    server.stop();
+    console.log(chalk.gray("Server stopped"));
+    process.exit(0);
+  });
+}
+async function runCloudDev(agent, cwd, port, options, spinner) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    spinner.fail("Not logged in");
+    console.log();
+    console.log(chalk.gray("Run"), chalk.cyan("af login"), chalk.gray("to connect to Struere Cloud"));
+    console.log(chalk.gray("Or use"), chalk.cyan("af dev --local"), chalk.gray("for local development"));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Connecting to Struere Cloud");
+  const syncUrl = getSyncUrl();
+  const ws = new WebSocket(`${syncUrl}/v1/dev/sync`);
+  let cloudUrl = null;
+  let sessionId = null;
+  let isConnected = false;
+  ws.onopen = () => {
+    ws.send(JSON.stringify({
+      type: "auth",
+      apiKey: apiKey || credentials?.token
+    }));
+  };
+  ws.onmessage = async (event) => {
+    const data = JSON.parse(event.data);
+    switch (data.type) {
+      case "authenticated":
+        spinner.text = "Syncing agent";
+        const bundle = await bundleAgent(cwd);
+        const configHash = hashString(bundle);
+        ws.send(JSON.stringify({
+          type: "sync",
+          agentSlug: agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+          bundle,
+          configHash
+        }));
+        break;
+      case "synced":
+        isConnected = true;
+        cloudUrl = data.url || null;
+        sessionId = data.agentId || null;
+        spinner.succeed("Connected to Struere Cloud");
+        console.log();
+        console.log(chalk.gray("Mode:"), chalk.green("Cloud"));
+        console.log(chalk.green("Agent running at"), chalk.cyan(cloudUrl));
+        console.log(chalk.green("Local server at"), chalk.cyan(`http://localhost:${port}`));
+        console.log();
+        spinner.start("Watching for changes");
+        break;
+      case "log":
+        const logColor = data.level === "error" ? chalk.red : data.level === "warn" ? chalk.yellow : data.level === "debug" ? chalk.gray : chalk.blue;
+        spinner.stop();
+        console.log(logColor(`[${data.level}]`), data.message);
+        spinner.start("Watching for changes");
+        break;
+      case "error":
+        spinner.fail(`Cloud error: ${data.message}`);
+        if (data.code === "INVALID_API_KEY" || data.code === "NOT_AUTHENTICATED") {
+          console.log();
+          console.log(chalk.gray("Run"), chalk.cyan("af login"), chalk.gray("to authenticate"));
+        }
+        break;
+    }
+  };
+  ws.onerror = (error) => {
+    spinner.fail("WebSocket error");
+    console.log(chalk.red("Connection error. Falling back to local mode."));
+  };
+  ws.onclose = () => {
+    if (isConnected) {
+      spinner.stop();
+      console.log(chalk.yellow("Disconnected from cloud"));
+    }
+  };
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/health") {
+        return Response.json({
+          status: "ok",
+          agent: agent.name,
+          mode: "cloud",
+          cloudUrl
+        });
+      }
+      if (url.pathname === "/api/chat" && req.method === "POST") {
+        if (!cloudUrl || !sessionId) {
+          return Response.json({ error: "Not connected to cloud" }, { status: 503 });
+        }
+        const body = await req.json();
+        const gatewayUrl = cloudUrl.replace("https://", "https://gateway.").replace(/-dev\.struere\.dev.*/, ".struere.dev");
+        const response = await fetch(`${process.env.STRUERE_GATEWAY_URL || "https://gateway.struere.dev"}/v1/dev/${sessionId}/chat`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey || credentials?.token}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (body.stream) {
+          return new Response(response.body, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive"
+            }
+          });
+        }
+        const data = await response.json();
+        return Response.json(data);
+      }
+      if (url.pathname === "/" && options.channel === "web") {
+        return new Response(getDevHtml(agent.name, "cloud", cloudUrl), {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+  });
+  if (options.channel === "web" && options.open) {
+    const openUrl = `http://localhost:${port}`;
+    if (process.platform === "darwin") {
+      Bun.spawn(["open", openUrl]);
+    } else if (process.platform === "linux") {
+      Bun.spawn(["xdg-open", openUrl]);
+    }
+  }
+  const watcher = chokidar.watch([join4(cwd, "src"), join4(cwd, "af.config.ts")], {
+    ignoreInitial: true,
+    ignored: /node_modules/
+  });
+  watcher.on("change", async (path) => {
+    spinner.text = `Syncing (${path.replace(cwd, ".")})`;
+    try {
+      agent = await loadAgent(cwd);
+      const bundle = await bundleAgent(cwd);
+      const configHash = hashString(bundle);
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({
+          type: "sync",
+          agentSlug: agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+          bundle,
+          configHash
+        }));
+      }
+    } catch (error) {
+      spinner.fail(`Sync failed: ${error}`);
+      spinner.start("Watching for changes");
+    }
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    spinner.stop();
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "unsync" }));
+      ws.close();
+    }
+    watcher.close();
+    server.stop();
+    console.log(chalk.gray("Server stopped"));
+    process.exit(0);
+  });
+}
+async function bundleAgent(cwd) {
+  const result = await Bun.build({
+    entrypoints: [join4(cwd, "src", "agent.ts")],
+    target: "browser",
+    minify: true
+  });
+  if (!result.success) {
+    throw new Error("Bundle failed: " + result.logs.join(`
+`));
+  }
+  return await result.outputs[0].text();
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+}
+function getDevHtml(agentName, mode, cloudUrl) {
+  const modeLabel = mode === "cloud" ? `<span style="color: #22c55e;">Cloud</span>${cloudUrl ? ` - <a href="${cloudUrl}" target="_blank" style="color: #60a5fa;">${cloudUrl}</a>` : ""}` : '<span style="color: #eab308;">Local</span>';
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${agentName} - Dev</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, -apple-system, sans-serif; background: #0a0a0a; color: #fafafa; height: 100vh; display: flex; flex-direction: column; }
+    header { padding: 1rem; border-bottom: 1px solid #333; display: flex; justify-content: space-between; align-items: center; }
+    header h1 { font-size: 1rem; font-weight: 500; }
+    header .mode { font-size: 0.875rem; }
+    header a { text-decoration: none; }
+    #messages { flex: 1; overflow-y: auto; padding: 1rem; display: flex; flex-direction: column; gap: 0.75rem; }
+    .message { max-width: 80%; padding: 0.75rem 1rem; border-radius: 0.75rem; line-height: 1.5; white-space: pre-wrap; }
+    .message.user { align-self: flex-end; background: #2563eb; }
+    .message.assistant { align-self: flex-start; background: #27272a; }
+    .message.tool { align-self: flex-start; background: #1e3a5f; font-family: monospace; font-size: 0.875rem; border-left: 3px solid #3b82f6; }
+    .message.streaming { opacity: 0.9; }
+    form { padding: 1rem; border-top: 1px solid #333; display: flex; gap: 0.5rem; }
+    input { flex: 1; padding: 0.75rem 1rem; background: #18181b; border: 1px solid #333; border-radius: 0.5rem; color: #fafafa; font-size: 1rem; outline: none; }
+    input:focus { border-color: #2563eb; }
+    input:disabled { opacity: 0.5; }
+    button { padding: 0.75rem 1.5rem; background: #2563eb; border: none; border-radius: 0.5rem; color: white; font-size: 1rem; cursor: pointer; }
+    button:hover { background: #1d4ed8; }
+    button:disabled { opacity: 0.5; cursor: not-allowed; }
+    .toggle-container { padding: 0.5rem 1rem; display: flex; align-items: center; gap: 0.5rem; border-top: 1px solid #333; }
+    .toggle-container label { font-size: 0.875rem; color: #888; }
+    .toggle-container input[type="checkbox"] { width: 1rem; height: 1rem; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>${agentName}</h1>
+    <span class="mode">${modeLabel}</span>
+  </header>
+  <div id="messages"></div>
+  <div class="toggle-container">
+    <input type="checkbox" id="stream-toggle" checked />
+    <label for="stream-toggle">Enable streaming</label>
+  </div>
+  <form id="chat-form">
+    <input type="text" id="input" placeholder="Type a message..." autocomplete="off" />
+    <button type="submit">Send</button>
+  </form>
+  <script>
+    const messages = document.getElementById('messages');
+    const form = document.getElementById('chat-form');
+    const input = document.getElementById('input');
+    const button = form.querySelector('button');
+    const streamToggle = document.getElementById('stream-toggle');
+    let conversationId = null;
+    let isProcessing = false;
+
+    function addMessage(role, content, isStreaming = false) {
+      const div = document.createElement('div');
+      div.className = 'message ' + role + (isStreaming ? ' streaming' : '');
+      div.textContent = content;
+      messages.appendChild(div);
+      messages.scrollTop = messages.scrollHeight;
+      return div;
+    }
+
+    function setProcessing(processing) {
+      isProcessing = processing;
+      input.disabled = processing;
+      button.disabled = processing;
+    }
+
+    async function sendWithStreaming(message) {
+      const assistantDiv = addMessage('assistant', '', true);
+
+      const response = await fetch('/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message, conversationId, stream: true }),
+      });
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let fullText = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            try {
+              const data = JSON.parse(line.slice(6));
+
+              if (data.conversationId) {
+                conversationId = data.conversationId;
+              }
+
+              if (data.type === 'text-delta' && (data.textDelta || data.content)) {
+                fullText += data.textDelta || data.content;
+                assistantDiv.textContent = fullText;
+                messages.scrollTop = messages.scrollHeight;
+              } else if (data.type === 'tool-call-start') {
+                addMessage('tool', '\uD83D\uDD27 Calling tool: ' + (data.toolName || data.toolCall?.name));
+              } else if (data.type === 'tool-result') {
+                const resultText = typeof data.toolResult === 'string'
+                  ? data.toolResult
+                  : JSON.stringify(data.toolResult || data.toolCall?.result, null, 2);
+                addMessage('tool', '✓ Result: ' + resultText);
+              } else if (data.type === 'finish') {
+                assistantDiv.classList.remove('streaming');
+              } else if (data.type === 'error') {
+                assistantDiv.textContent = 'Error: ' + (data.error || data.message);
+                assistantDiv.classList.remove('streaming');
+              }
+            } catch (e) {}
+          }
+        }
+      }
+
+      if (!fullText) {
+        assistantDiv.remove();
+      }
+    }
+
+    async function sendWithoutStreaming(message) {
+      const res = await fetch('/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message, conversationId }),
+      });
+      const data = await res.json();
+      conversationId = data.conversationId;
+
+      if (data.toolCalls && data.toolCalls.length > 0) {
+        for (const tc of data.toolCalls) {
+          const resultText = typeof tc.result === 'string'
+            ? tc.result
+            : JSON.stringify(tc.result, null, 2);
+          addMessage('tool', '\uD83D\uDD27 ' + tc.name + ': ' + resultText);
+        }
+      }
+
+      addMessage('assistant', data.response || data.content);
+    }
+
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      if (isProcessing) return;
+
+      const message = input.value.trim();
+      if (!message) return;
+
+      addMessage('user', message);
+      input.value = '';
+      setProcessing(true);
+
+      try {
+        if (streamToggle.checked) {
+          await sendWithStreaming(message);
+        } else {
+          await sendWithoutStreaming(message);
+        }
+      } catch (err) {
+        addMessage('assistant', 'Error: ' + err.message);
+      } finally {
+        setProcessing(false);
+      }
+    });
+
+    input.focus();
+  </script>
+</body>
+</html>`;
+}
+
+// src/commands/build.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { join as join5 } from "path";
+
+// src/utils/validate.ts
+function validateAgent(agent) {
+  const errors = [];
+  if (!agent.name) {
+    errors.push("Agent name is required");
+  } else if (!/^[a-z0-9-]+$/.test(agent.name)) {
+    errors.push("Agent name must be lowercase alphanumeric with hyphens only");
+  }
+  if (!agent.version) {
+    errors.push("Agent version is required");
+  } else if (!/^\d+\.\d+\.\d+/.test(agent.version)) {
+    errors.push("Agent version must follow semver format (e.g., 1.0.0)");
+  }
+  if (!agent.systemPrompt) {
+    errors.push("System prompt is required");
+  } else if (typeof agent.systemPrompt === "string" && agent.systemPrompt.trim().length === 0) {
+    errors.push("System prompt cannot be empty");
+  }
+  if (agent.model) {
+    const validProviders = ["anthropic", "openai", "google", "custom"];
+    if (!validProviders.includes(agent.model.provider)) {
+      errors.push(`Invalid model provider: ${agent.model.provider}`);
+    }
+    if (!agent.model.name) {
+      errors.push("Model name is required when model is specified");
+    }
+    if (agent.model.temperature !== undefined) {
+      if (agent.model.temperature < 0 || agent.model.temperature > 2) {
+        errors.push("Model temperature must be between 0 and 2");
+      }
+    }
+    if (agent.model.maxTokens !== undefined) {
+      if (agent.model.maxTokens < 1) {
+        errors.push("Model maxTokens must be at least 1");
+      }
+    }
+  }
+  if (agent.tools) {
+    for (const tool of agent.tools) {
+      const toolErrors = validateTool(tool);
+      errors.push(...toolErrors);
+    }
+  }
+  if (agent.state) {
+    const validStorage = ["memory", "redis", "postgres", "custom"];
+    if (!validStorage.includes(agent.state.storage)) {
+      errors.push(`Invalid state storage: ${agent.state.storage}`);
+    }
+    if (agent.state.ttl !== undefined && agent.state.ttl < 0) {
+      errors.push("State TTL must be non-negative");
+    }
+  }
+  return errors;
+}
+function validateTool(tool) {
+  const errors = [];
+  if (!tool.name) {
+    errors.push("Tool name is required");
+  } else if (!/^[a-z_][a-z0-9_]*$/.test(tool.name)) {
+    errors.push(`Tool name "${tool.name}" must be snake_case`);
+  }
+  if (!tool.description) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a description`);
+  }
+  if (!tool.parameters) {
+    errors.push(`Tool "${tool.name || "unknown"}" requires parameters definition`);
+  } else if (tool.parameters.type !== "object") {
+    errors.push(`Tool "${tool.name || "unknown"}" parameters type must be "object"`);
+  }
+  if (typeof tool.handler !== "function") {
+    errors.push(`Tool "${tool.name || "unknown"}" requires a handler function`);
+  }
+  return errors;
+}
+
+// src/commands/build.ts
+var buildCommand = new Command2("build").description("Build and validate agent for production").option("-o, --outdir <dir>", "Output directory", "dist").action(async (options) => {
+  const spinner = ora2();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk2.bold("Building Agent"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk2.red("  ✗"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  spinner.start("Building");
+  const outdir = join5(cwd, options.outdir);
+  const result = await Bun.build({
+    entrypoints: [join5(cwd, "src/agent.ts")],
+    outdir,
+    target: "node",
+    minify: true
+  });
+  if (!result.success) {
+    spinner.fail("Build failed");
+    console.log();
+    for (const log of result.logs) {
+      console.log(chalk2.red("  ✗"), log.message);
+    }
+    process.exit(1);
+  }
+  spinner.succeed("Build completed");
+  console.log();
+  console.log(chalk2.green("Success!"), `Built to ${chalk2.cyan(options.outdir)}`);
+  console.log();
+  console.log("Output files:");
+  for (const output of result.outputs) {
+    console.log(chalk2.gray("  •"), output.path.replace(cwd, "."));
+  }
+  console.log();
+});
+
+// src/commands/test.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { join as join6 } from "path";
+import { readdir, readFile } from "fs/promises";
+import YAML from "yaml";
+import { AgentExecutor as AgentExecutor2 } from "@struere/runtime";
+var testCommand = new Command3("test").description("Run test conversations").argument("[pattern]", "Test file pattern", "*.test.yaml").option("-v, --verbose", "Show detailed output").option("--dry-run", "Parse tests without executing (no API calls)").action(async (pattern, options) => {
+  const spinner = ora3();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk3.bold("Running Tests"));
+  console.log();
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Finding test files");
+  const testsDir = join6(cwd, "tests");
+  let testFiles = [];
+  try {
+    const files = await readdir(testsDir);
+    testFiles = files.filter((f) => f.endsWith(".test.yaml") || f.endsWith(".test.yml"));
+  } catch {
+    spinner.warn("No tests directory found");
+    console.log();
+    console.log(chalk3.gray("Create tests in"), chalk3.cyan("tests/*.test.yaml"));
+    console.log();
+    return;
+  }
+  if (testFiles.length === 0) {
+    spinner.warn("No test files found");
+    console.log();
+    return;
+  }
+  spinner.succeed(`Found ${testFiles.length} test file(s)`);
+  if (options.dryRun) {
+    console.log();
+    console.log(chalk3.yellow("Dry run mode - skipping execution"));
+    console.log();
+  }
+  const results = [];
+  for (const file of testFiles) {
+    const filePath = join6(testsDir, file);
+    const content = await readFile(filePath, "utf-8");
+    const testCase = YAML.parse(content);
+    if (options.verbose) {
+      console.log();
+      console.log(chalk3.gray("Running:"), testCase.name);
+    }
+    const result = options.dryRun ? await runDryTest(testCase) : await runTest(testCase, agent, options.verbose);
+    results.push(result);
+    if (result.passed) {
+      console.log(chalk3.green("  ✓"), result.name);
+    } else {
+      console.log(chalk3.red("  ✗"), result.name);
+      for (const error of result.errors) {
+        console.log(chalk3.red("    →"), error);
+      }
+    }
+  }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  console.log();
+  if (failed === 0) {
+    console.log(chalk3.green("All tests passed!"), chalk3.gray(`(${passed}/${results.length})`));
+  } else {
+    console.log(chalk3.red("Tests failed:"), chalk3.gray(`${passed}/${results.length} passed`));
+  }
+  console.log();
+  if (failed > 0) {
+    process.exit(1);
+  }
+});
+async function runDryTest(testCase) {
+  return {
+    name: testCase.name,
+    passed: true,
+    errors: []
+  };
+}
+async function runTest(testCase, agent, verbose) {
+  const errors = [];
+  const executor = new AgentExecutor2(agent);
+  const conversationId = `test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const context = {
+    lastResponse: "",
+    toolCalls: [],
+    state: {}
+  };
+  try {
+    for (const message of testCase.conversation || []) {
+      if (message.role === "user") {
+        if (verbose) {
+          console.log(chalk3.cyan("    User:"), message.content.slice(0, 50) + (message.content.length > 50 ? "..." : ""));
+        }
+        const result = await executor.execute({
+          conversationId,
+          message: message.content
+        });
+        context.lastResponse = result.message;
+        context.toolCalls = result.toolCalls || [];
+        if (verbose) {
+          console.log(chalk3.green("    Assistant:"), result.message.slice(0, 50) + (result.message.length > 50 ? "..." : ""));
+          if (result.toolCalls && result.toolCalls.length > 0) {
+            console.log(chalk3.yellow("    Tools:"), result.toolCalls.map((t) => t.name).join(", "));
+          }
+        }
+      }
+      if (message.assertions) {
+        for (const assertion of message.assertions) {
+          const passed = checkAssertion(assertion, context);
+          if (!passed) {
+            errors.push(formatAssertionError(assertion, context));
+          }
+        }
+      }
+    }
+    if (testCase.assertions) {
+      for (const assertion of testCase.assertions) {
+        const passed = checkAssertion(assertion, context);
+        if (!passed) {
+          errors.push(formatAssertionError(assertion, context));
+        }
+      }
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    errors.push(`Execution error: ${errorMsg}`);
+  }
+  return {
+    name: testCase.name,
+    passed: errors.length === 0,
+    errors
+  };
+}
+function checkAssertion(assertion, context) {
+  switch (assertion.type) {
+    case "contains":
+      return typeof assertion.value === "string" && context.lastResponse.toLowerCase().includes(assertion.value.toLowerCase());
+    case "matches":
+      return typeof assertion.value === "string" && new RegExp(assertion.value, "i").test(context.lastResponse);
+    case "toolCalled":
+      if (typeof assertion.value === "string") {
+        return context.toolCalls.some((tc) => tc.name === assertion.value);
+      }
+      return false;
+    case "stateEquals":
+      if (typeof assertion.value === "object" && assertion.value !== null) {
+        for (const [key, expected] of Object.entries(assertion.value)) {
+          if (context.state[key] !== expected) {
+            return false;
+          }
+        }
+        return true;
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function formatAssertionError(assertion, context) {
+  switch (assertion.type) {
+    case "contains":
+      return `Expected response to contain "${assertion.value}", got: "${context.lastResponse.slice(0, 100)}..."`;
+    case "matches":
+      return `Expected response to match /${assertion.value}/, got: "${context.lastResponse.slice(0, 100)}..."`;
+    case "toolCalled":
+      const calledTools = context.toolCalls.map((tc) => tc.name).join(", ") || "none";
+      return `Expected tool "${assertion.value}" to be called, called: [${calledTools}]`;
+    case "stateEquals":
+      return `State mismatch: expected ${JSON.stringify(assertion.value)}, got ${JSON.stringify(context.state)}`;
+    default:
+      return `Assertion failed: ${assertion.type} - ${JSON.stringify(assertion.value)}`;
+  }
+}
+
+// src/commands/deploy.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { join as join7 } from "path";
+var deployCommand = new Command4("deploy").description("Deploy agent to Agent Factory cloud").option("-e, --env <environment>", "Target environment (preview, staging, production)", "preview").option("--dry-run", "Show what would be deployed without deploying").action(async (options) => {
+  const spinner = ora4();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk4.bold("Deploying Agent"));
+  console.log();
+  spinner.start("Loading configuration");
+  const config = await loadConfig(cwd);
+  spinner.succeed("Configuration loaded");
+  spinner.start("Loading agent");
+  const agent = await loadAgent(cwd);
+  spinner.succeed(`Agent "${agent.name}" loaded`);
+  spinner.start("Validating agent");
+  const errors = validateAgent(agent);
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    for (const error of errors) {
+      console.log(chalk4.red("  ✗"), error);
+    }
+    console.log();
+    process.exit(1);
+  }
+  spinner.succeed("Agent validated");
+  if (options.dryRun) {
+    console.log();
+    console.log(chalk4.yellow("Dry run mode - no changes will be made"));
+    console.log();
+    console.log("Would deploy:");
+    console.log(chalk4.gray("  •"), `Agent: ${chalk4.cyan(agent.name)}`);
+    console.log(chalk4.gray("  •"), `Version: ${chalk4.cyan(agent.version)}`);
+    console.log(chalk4.gray("  •"), `Environment: ${chalk4.cyan(options.env)}`);
+    console.log();
+    return;
+  }
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
+  if (!credentials && !apiKey) {
+    spinner.fail("Not authenticated");
+    console.log();
+    console.log(chalk4.gray("Run"), chalk4.cyan("af login"), chalk4.gray("to authenticate"));
+    console.log(chalk4.gray("Or set"), chalk4.cyan("AGENT_FACTORY_API_KEY"), chalk4.gray("environment variable"));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Building agent bundle");
+  const result = await Bun.build({
+    entrypoints: [join7(cwd, "src", "agent.ts")],
+    target: "browser",
+    minify: true
+  });
+  if (!result.success) {
+    spinner.fail("Build failed");
+    console.log();
+    for (const log of result.logs) {
+      console.log(chalk4.red("  •"), log);
+    }
+    console.log();
+    process.exit(1);
+  }
+  const bundle = await result.outputs[0].text();
+  spinner.succeed(`Bundle created (${formatBytes(bundle.length)})`);
+  spinner.start(`Deploying to ${options.env}`);
+  try {
+    const api = new ApiClient;
+    const agentSlug = agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    let agentRecord = null;
+    try {
+      const { agents } = await api.listAgents();
+      agentRecord = agents.find((a) => a.slug === agentSlug) || null;
+    } catch {}
+    if (!agentRecord) {
+      spinner.text = "Creating agent";
+      const { agent: newAgent } = await api.createAgent({
+        name: agent.name,
+        slug: agentSlug,
+        description: agent.description
+      });
+      agentRecord = newAgent;
+    }
+    spinner.text = `Deploying to ${options.env}`;
+    const { deployment } = await api.deployAgent(agentRecord.id, {
+      bundle,
+      version: agent.version,
+      environment: options.env,
+      metadata: {
+        modelProvider: agent.model?.provider || "anthropic",
+        modelName: agent.model?.name || "claude-sonnet-4-20250514",
+        toolCount: agent.tools?.length || 0,
+        bundleSize: bundle.length
+      }
+    });
+    spinner.succeed(`Deployed to ${options.env}`);
+    console.log();
+    console.log(chalk4.green("Success!"), "Agent deployed");
+    console.log();
+    console.log("Deployment details:");
+    console.log(chalk4.gray("  •"), `ID: ${chalk4.cyan(deployment.id)}`);
+    console.log(chalk4.gray("  •"), `Version: ${chalk4.cyan(deployment.version)}`);
+    console.log(chalk4.gray("  •"), `Environment: ${chalk4.cyan(deployment.environment)}`);
+    console.log(chalk4.gray("  •"), `URL: ${chalk4.cyan(deployment.url)}`);
+    console.log();
+    console.log(chalk4.gray("Test your agent:"));
+    console.log(chalk4.gray("  $"), chalk4.cyan(`curl -X POST ${deployment.url}/chat -H "Authorization: Bearer YOUR_API_KEY" -d '{"message": "Hello"}'`));
+    console.log();
+  } catch (error) {
+    spinner.fail("Deployment failed");
+    console.log();
+    if (error instanceof ApiError) {
+      console.log(chalk4.red("Error:"), error.message);
+      if (error.status === 401) {
+        console.log();
+        console.log(chalk4.gray("Try running"), chalk4.cyan("af login"), chalk4.gray("to re-authenticate"));
+      }
+    } else {
+      console.log(chalk4.red("Error:"), error instanceof Error ? error.message : String(error));
+    }
+    console.log();
+    process.exit(1);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/commands/validate.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora5 from "ora";
+var validateCommand = new Command5("validate").description("Validate agent configuration").option("--strict", "Enable strict validation").action(async (options) => {
+  const spinner = ora5();
+  const cwd = process.cwd();
+  console.log();
+  console.log(chalk5.bold("Validating Agent"));
+  console.log();
+  spinner.start("Loading agent");
+  let agent;
+  try {
+    agent = await loadAgent(cwd);
+    spinner.succeed(`Agent "${agent.name}" loaded`);
+  } catch (error) {
+    spinner.fail("Failed to load agent");
+    console.log();
+    console.log(chalk5.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+  spinner.start("Validating configuration");
+  const errors = validateAgent(agent);
+  const warnings = options.strict ? getStrictWarnings(agent) : [];
+  if (errors.length === 0 && warnings.length === 0) {
+    spinner.succeed("Agent is valid");
+    console.log();
+    console.log(chalk5.green("✓"), "No issues found");
+    console.log();
+    return;
+  }
+  if (errors.length > 0) {
+    spinner.fail("Validation failed");
+    console.log();
+    console.log(chalk5.red("Errors:"));
+    for (const error of errors) {
+      console.log(chalk5.red("  ✗"), error);
+    }
+  } else {
+    spinner.succeed("Validation passed with warnings");
+  }
+  if (warnings.length > 0) {
+    console.log();
+    console.log(chalk5.yellow("Warnings:"));
+    for (const warning of warnings) {
+      console.log(chalk5.yellow("  ⚠"), warning);
+    }
+  }
+  console.log();
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+});
+function getStrictWarnings(agent) {
+  const warnings = [];
+  if (!agent.description) {
+    warnings.push("Agent is missing a description");
+  }
+  if (!agent.tools || agent.tools.length === 0) {
+    warnings.push("Agent has no tools defined");
+  }
+  return warnings;
+}
+
+// src/commands/logs.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora6 from "ora";
+var logsCommand = new Command6("logs").description("Stream production logs").option("-e, --env <environment>", "Environment to stream from", "production").option("-f, --follow", "Follow log output").option("-n, --lines <number>", "Number of lines to show", "100").action(async (options) => {
+  const spinner = ora6();
+  console.log();
+  console.log(chalk6.bold("Streaming Logs"));
+  console.log();
+  const apiKey = process.env.STRUERE_API_KEY;
+  if (!apiKey) {
+    console.log(chalk6.red("Error:"), "Missing STRUERE_API_KEY environment variable");
+    console.log();
+    console.log("Set your API key:");
+    console.log(chalk6.gray("  $"), chalk6.cyan("export STRUERE_API_KEY=your_api_key"));
+    console.log();
+    process.exit(1);
+  }
+  const apiUrl = process.env.STRUERE_API_URL || "https://api.struere.dev";
+  if (options.follow) {
+    spinner.start(`Connecting to ${options.env} logs`);
+    try {
+      const wsUrl = apiUrl.replace("https://", "wss://").replace("http://", "ws://");
+      const ws = new WebSocket(`${wsUrl}/v1/logs/stream?env=${options.env}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      ws.onopen = () => {
+        spinner.succeed(`Connected to ${options.env}`);
+        console.log();
+        console.log(chalk6.gray("Streaming logs... (Ctrl+C to stop)"));
+        console.log();
+      };
+      ws.onmessage = (event) => {
+        const log = JSON.parse(event.data);
+        const levelColor = log.level === "error" ? chalk6.red : log.level === "warn" ? chalk6.yellow : chalk6.gray;
+        console.log(chalk6.gray(new Date(log.timestamp).toISOString()), levelColor(`[${log.level}]`), log.message);
+      };
+      ws.onerror = () => {
+        spinner.fail("Connection error");
+        process.exit(1);
+      };
+      ws.onclose = () => {
+        console.log();
+        console.log(chalk6.gray("Connection closed"));
+        process.exit(0);
+      };
+      process.on("SIGINT", () => {
+        console.log();
+        ws.close();
+      });
+    } catch (error) {
+      spinner.fail("Failed to connect");
+      console.log();
+      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log();
+      process.exit(1);
+    }
+  } else {
+    spinner.start("Fetching logs");
+    try {
+      const response = await fetch(`${apiUrl}/v1/logs?env=${options.env}&lines=${options.lines}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const logs = await response.json();
+      spinner.succeed(`Fetched ${logs.length} log entries`);
+      console.log();
+      for (const log of logs) {
+        const levelColor = log.level === "error" ? chalk6.red : log.level === "warn" ? chalk6.yellow : chalk6.gray;
+        console.log(chalk6.gray(new Date(log.timestamp).toISOString()), levelColor(`[${log.level}]`), log.message);
+      }
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to fetch logs");
+      console.log();
+      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log();
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/state.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora7 from "ora";
+var stateCommand = new Command7("state").description("Inspect conversation state").argument("<id>", "Conversation ID").option("-e, --env <environment>", "Environment", "production").option("--json", "Output as JSON").action(async (id, options) => {
+  const spinner = ora7();
+  console.log();
+  console.log(chalk7.bold("Conversation State"));
+  console.log();
+  const apiKey = process.env.STRUERE_API_KEY;
+  if (!apiKey) {
+    console.log(chalk7.red("Error:"), "Missing STRUERE_API_KEY environment variable");
+    console.log();
+    console.log("Set your API key:");
+    console.log(chalk7.gray("  $"), chalk7.cyan("export STRUERE_API_KEY=your_api_key"));
+    console.log();
+    process.exit(1);
+  }
+  const apiUrl = process.env.STRUERE_API_URL || "https://api.struere.dev";
+  spinner.start("Fetching conversation state");
+  try {
+    const response = await fetch(`${apiUrl}/v1/conversations/${id}/state?env=${options.env}`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error("Conversation not found");
+      }
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const state = await response.json();
+    spinner.succeed("State retrieved");
+    if (options.json) {
+      console.log();
+      console.log(JSON.stringify(state, null, 2));
+      console.log();
+      return;
+    }
+    console.log();
+    console.log(chalk7.gray("Conversation:"), chalk7.cyan(state.conversationId));
+    console.log(chalk7.gray("Created:"), new Date(state.createdAt).toLocaleString());
+    console.log(chalk7.gray("Updated:"), new Date(state.updatedAt).toLocaleString());
+    console.log(chalk7.gray("Messages:"), state.messageCount);
+    console.log();
+    console.log(chalk7.bold("State:"));
+    if (Object.keys(state.state).length === 0) {
+      console.log(chalk7.gray("  (empty)"));
+    } else {
+      for (const [key, value] of Object.entries(state.state)) {
+        const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+        console.log(chalk7.gray("  •"), `${key}:`, chalk7.cyan(displayValue));
+      }
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to fetch state");
+    console.log();
+    console.log(chalk7.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    process.exit(1);
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora8 from "ora";
+var CLERK_PUBLISHABLE_KEY = process.env.CLERK_PUBLISHABLE_KEY || "pk_test_placeholder";
+var AUTH_CALLBACK_PORT = 9876;
+var loginCommand = new Command8("login").description("Log in to Agent Factory").option("--headless", "Login with email/password (no browser)").action(async (options) => {
+  const spinner = ora8();
+  console.log();
+  console.log(chalk8.bold("Struere Login"));
+  console.log();
+  const existing = loadCredentials();
+  if (existing) {
+    console.log(chalk8.yellow("Already logged in as"), chalk8.cyan(existing.user.email));
+    console.log(chalk8.gray("Run"), chalk8.cyan("af logout"), chalk8.gray("to log out first"));
+    console.log();
+    return;
+  }
+  if (options.headless) {
+    await headlessLogin(spinner);
+  } else {
+    await browserLogin(spinner);
+  }
+});
+async function browserLogin(spinner) {
+  spinner.start("Starting authentication server");
+  const authPromise = new Promise((resolve, reject) => {
+    const server = Bun.serve({
+      port: AUTH_CALLBACK_PORT,
+      async fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/callback") {
+          const token = url.searchParams.get("token");
+          const sessionId = url.searchParams.get("session_id");
+          if (token && sessionId) {
+            resolve({ token, sessionId });
+            return new Response(getSuccessHtml(), {
+              headers: { "Content-Type": "text/html" }
+            });
+          }
+          return new Response(getErrorHtml("Missing token"), {
+            status: 400,
+            headers: { "Content-Type": "text/html" }
+          });
+        }
+        if (url.pathname === "/") {
+          const authUrl = getAuthUrl();
+          return Response.redirect(authUrl, 302);
+        }
+        return new Response("Not Found", { status: 404 });
+      }
+    });
+    setTimeout(() => {
+      server.stop();
+      reject(new Error("Authentication timed out"));
+    }, 5 * 60 * 1000);
+  });
+  spinner.succeed("Authentication server started");
+  const loginUrl = `http://localhost:${AUTH_CALLBACK_PORT}`;
+  console.log();
+  console.log(chalk8.gray("Opening browser to log in..."));
+  console.log(chalk8.gray("If browser does not open, visit:"), chalk8.cyan(loginUrl));
+  console.log();
+  if (process.platform === "darwin") {
+    Bun.spawn(["open", loginUrl]);
+  } else if (process.platform === "linux") {
+    Bun.spawn(["xdg-open", loginUrl]);
+  } else if (process.platform === "win32") {
+    Bun.spawn(["cmd", "/c", "start", loginUrl]);
+  }
+  spinner.start("Waiting for authentication");
+  try {
+    const { token, sessionId } = await authPromise;
+    spinner.text = "Fetching user info";
+    const api = new ApiClient;
+    const { user, organization } = await api.getMe();
+    saveCredentials({
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        organizationId: user.organizationId
+      },
+      organization: {
+        id: organization.id,
+        name: organization.name,
+        slug: organization.slug
+      },
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString()
+    });
+    spinner.succeed("Logged in successfully");
+    console.log();
+    console.log(chalk8.green("Welcome,"), chalk8.cyan(user.name));
+    console.log(chalk8.gray("Organization:"), organization.name);
+    console.log();
+    printNextSteps();
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.log();
+    console.log(chalk8.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    console.log(chalk8.gray("Try"), chalk8.cyan("af login --headless"), chalk8.gray("for email/password login"));
+    console.log();
+    process.exit(1);
+  }
+}
+async function headlessLogin(spinner) {
+  const email = await prompt("Email: ");
+  const password = await prompt("Password: ", true);
+  if (!email || !password) {
+    console.log(chalk8.red("Email and password are required"));
+    process.exit(1);
+  }
+  spinner.start("Logging in");
+  try {
+    const api = new ApiClient;
+    const { token, user } = await api.login(email, password);
+    const { organization } = await api.getMe();
+    saveCredentials({
+      token,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        organizationId: user.organizationId
+      },
+      organization: {
+        id: organization.id,
+        name: organization.name,
+        slug: organization.slug
+      },
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString()
+    });
+    spinner.succeed("Logged in successfully");
+    console.log();
+    console.log(chalk8.green("Welcome,"), chalk8.cyan(user.name));
+    console.log(chalk8.gray("Organization:"), organization.name);
+    console.log();
+    printNextSteps();
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.log();
+    if (error instanceof ApiError) {
+      console.log(chalk8.red("Error:"), error.message);
+    } else {
+      console.log(chalk8.red("Error:"), error instanceof Error ? error.message : String(error));
+    }
+    console.log();
+    process.exit(1);
+  }
+}
+function printNextSteps() {
+  console.log(chalk8.gray("You can now use:"));
+  console.log(chalk8.gray("  •"), chalk8.cyan("af dev"), chalk8.gray("- Start cloud-connected dev server"));
+  console.log(chalk8.gray("  •"), chalk8.cyan("af deploy"), chalk8.gray("- Deploy your agent"));
+  console.log(chalk8.gray("  •"), chalk8.cyan("af logs"), chalk8.gray("- View agent logs"));
+  console.log();
+}
+function getAuthUrl() {
+  const baseUrl = process.env.STRUERE_AUTH_URL || "https://struere.dev";
+  const callbackUrl = `http://localhost:${AUTH_CALLBACK_PORT}/callback`;
+  return `${baseUrl}/cli-auth?callback=${encodeURIComponent(callbackUrl)}`;
+}
+function getSuccessHtml() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Login Successful</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+    .container { text-align: center; }
+    h1 { color: #22c55e; }
+    p { color: #888; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Login Successful</h1>
+    <p>You can close this window and return to the terminal.</p>
+  </div>
+  <script>setTimeout(() => window.close(), 3000)</script>
+</body>
+</html>`;
+}
+function getErrorHtml(message) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Login Failed</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+    .container { text-align: center; }
+    h1 { color: #ef4444; }
+    p { color: #888; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Login Failed</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+}
+async function prompt(message, hidden = false) {
+  process.stdout.write(chalk8.gray(message));
+  return new Promise((resolve) => {
+    let input = "";
+    if (hidden) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (char) => {
+      if (char === `
+` || char === "\r") {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        if (hidden) {
+          process.stdin.setRawMode(false);
+          console.log();
+        }
+        resolve(input);
+      } else if (char === "\x03") {
+        process.exit();
+      } else if (char === "") {
+        input = input.slice(0, -1);
+      } else {
+        input += char;
+        if (!hidden) {
+          process.stdout.write(char);
+        }
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/commands/logout.ts
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+var logoutCommand = new Command9("logout").description("Log out of Agent Factory").action(async () => {
+  console.log();
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk9.yellow("Not currently logged in"));
+    console.log();
+    return;
+  }
+  clearCredentials();
+  console.log(chalk9.green("Logged out successfully"));
+  console.log(chalk9.gray("Goodbye,"), chalk9.cyan(credentials.user.name));
+  console.log();
+});
+
+// src/commands/whoami.ts
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+import ora9 from "ora";
+var whoamiCommand = new Command10("whoami").description("Show current logged in user").option("--refresh", "Refresh user info from server").action(async (options) => {
+  console.log();
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk10.yellow("Not logged in"));
+    console.log();
+    console.log(chalk10.gray("Run"), chalk10.cyan("af login"), chalk10.gray("to log in"));
+    console.log();
+    return;
+  }
+  if (options.refresh) {
+    const spinner = ora9("Fetching user info").start();
+    try {
+      const api = new ApiClient;
+      const { user, organization } = await api.getMe();
+      spinner.stop();
+      console.log(chalk10.bold("Logged in as:"));
+      console.log();
+      console.log(chalk10.gray("  User:        "), chalk10.cyan(user.name), chalk10.gray(`<${user.email}>`));
+      console.log(chalk10.gray("  User ID:     "), chalk10.gray(user.id));
+      console.log(chalk10.gray("  Role:        "), chalk10.cyan(user.role));
+      console.log();
+      console.log(chalk10.gray("  Organization:"), chalk10.cyan(organization.name));
+      console.log(chalk10.gray("  Org ID:      "), chalk10.gray(organization.id));
+      console.log(chalk10.gray("  Slug:        "), chalk10.cyan(organization.slug));
+      console.log(chalk10.gray("  Plan:        "), chalk10.cyan(organization.plan));
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to fetch user info");
+      console.log();
+      if (error instanceof ApiError) {
+        if (error.status === 401) {
+          console.log(chalk10.red("Session expired. Please log in again."));
+        } else {
+          console.log(chalk10.red("Error:"), error.message);
+        }
+      } else {
+        console.log(chalk10.red("Error:"), error instanceof Error ? error.message : String(error));
+      }
+      console.log();
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk10.bold("Logged in as:"));
+    console.log();
+    console.log(chalk10.gray("  User:        "), chalk10.cyan(credentials.user.name), chalk10.gray(`<${credentials.user.email}>`));
+    console.log(chalk10.gray("  User ID:     "), chalk10.gray(credentials.user.id));
+    console.log();
+    console.log(chalk10.gray("  Organization:"), chalk10.cyan(credentials.organization.name));
+    console.log(chalk10.gray("  Org ID:      "), chalk10.gray(credentials.organization.id));
+    console.log(chalk10.gray("  Slug:        "), chalk10.cyan(credentials.organization.slug));
+    console.log();
+    console.log(chalk10.gray("Use"), chalk10.cyan("af whoami --refresh"), chalk10.gray("to fetch latest info"));
+    console.log();
+  }
+});
+
+// src/index.ts
+program.name("struere").description("Struere CLI - Build, test, and deploy AI agents").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(testCommand);
+program.addCommand(deployCommand);
+program.addCommand(validateCommand);
+program.addCommand(logsCommand);
+program.addCommand(stateCommand);
+program.parse();