@struere/cli 0.1.1 → 0.2.0

package/dist/index.js

@@ -4,90 +4,19 @@
 // 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/commands/init.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4, basename } from "path";
 
 // src/utils/credentials.ts
 import { homedir } from "os";
-import { join as join3 } from "path";
+import { join } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
-var CONFIG_DIR = join3(homedir(), ".struere");
-var CREDENTIALS_FILE = join3(CONFIG_DIR, "credentials.json");
+var CONFIG_DIR = join(homedir(), ".struere");
+var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
 function ensureConfigDir() {
   if (!existsSync(CONFIG_DIR)) {
     mkdirSync(CONFIG_DIR, { recursive: true });
@@ -129,9 +58,11 @@ function getToken() {
   const credentials = loadCredentials();
   return credentials?.token || null;
 }
-function isLoggedIn() {
-  return loadCredentials() !== null;
-}
+
+// src/commands/login.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
 
 // src/utils/api.ts
 var DEFAULT_API_URL = "https://api.struere.dev";
@@ -192,52 +123,973 @@ class ApiClient {
   async listAgents() {
     return this.request("/v1/agents");
   }
-  async createAgent(data) {
-    return this.request("/v1/agents", {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
+  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/login.ts
+var AUTH_CALLBACK_PORT = 9876;
+var loginCommand = new Command("login").description("Log in to Struere").option("--headless", "Login with email/password (no browser)").action(async (options) => {
+  const spinner = ora();
+  console.log();
+  console.log(chalk.bold("Struere Login"));
+  console.log();
+  const existing = loadCredentials();
+  if (existing) {
+    console.log(chalk.yellow("Already logged in as"), chalk.cyan(existing.user.email));
+    console.log(chalk.gray("Run"), chalk.cyan("struere logout"), chalk.gray("to log out first"));
+    console.log();
+    return;
+  }
+  if (options.headless) {
+    await headlessLogin(spinner);
+  } else {
+    await browserLogin(spinner);
+  }
+});
+async function performLogin(options = {}) {
+  const spinner = ora();
+  console.log();
+  console.log(chalk.bold("Struere Login"));
+  console.log();
+  if (options.headless) {
+    return headlessLoginInternal(spinner);
+  } else {
+    return browserLoginInternal(spinner);
+  }
+}
+async function browserLogin(spinner) {
+  const result = await browserLoginInternal(spinner);
+  if (result) {
+    printNextSteps();
+  }
+}
+async function browserLoginInternal(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(chalk.gray("Opening browser to log in..."));
+  console.log(chalk.gray("If browser does not open, visit:"), chalk.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 } = await authPromise;
+    spinner.text = "Fetching user info";
+    const api = new ApiClient;
+    const { user, organization } = await api.getMe();
+    const credentials = {
+      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()
+    };
+    saveCredentials(credentials);
+    spinner.succeed("Logged in successfully");
+    console.log();
+    console.log(chalk.green("Welcome,"), chalk.cyan(user.name));
+    console.log(chalk.gray("Organization:"), organization.name);
+    console.log();
+    return credentials;
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.log();
+    console.log(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log();
+    console.log(chalk.gray("Try"), chalk.cyan("struere login --headless"), chalk.gray("for email/password login"));
+    console.log();
+    return null;
+  }
+}
+async function headlessLogin(spinner) {
+  const result = await headlessLoginInternal(spinner);
+  if (result) {
+    printNextSteps();
+  }
+}
+async function headlessLoginInternal(spinner) {
+  const email = await prompt("Email: ");
+  const password = await prompt("Password: ", true);
+  if (!email || !password) {
+    console.log(chalk.red("Email and password are required"));
+    return null;
+  }
+  spinner.start("Logging in");
+  try {
+    const api = new ApiClient;
+    const { token, user } = await api.login(email, password);
+    const { organization } = await api.getMe();
+    const credentials = {
+      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()
+    };
+    saveCredentials(credentials);
+    spinner.succeed("Logged in successfully");
+    console.log();
+    console.log(chalk.green("Welcome,"), chalk.cyan(user.name));
+    console.log(chalk.gray("Organization:"), organization.name);
+    console.log();
+    return credentials;
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.log();
+    if (error instanceof ApiError) {
+      console.log(chalk.red("Error:"), error.message);
+    } else {
+      console.log(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+    }
+    console.log();
+    return null;
+  }
+}
+function printNextSteps() {
+  console.log(chalk.gray("You can now use:"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere dev"), chalk.gray("- Start cloud-connected dev server"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere deploy"), chalk.gray("- Deploy your agent"));
+  console.log(chalk.gray("  \u2022"), chalk.cyan("struere logs"), chalk.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(chalk.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 === "\x7F") {
+        input = input.slice(0, -1);
+      } else {
+        input += char;
+        if (!hidden) {
+          process.stdout.write(char);
+        }
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/utils/project.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var PROJECT_FILE = "struere.json";
+function loadProject(cwd) {
+  const projectPath = join2(cwd, PROJECT_FILE);
+  if (!existsSync2(projectPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync2(projectPath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveProject(cwd, project) {
+  const projectPath = join2(cwd, PROJECT_FILE);
+  writeFileSync2(projectPath, JSON.stringify(project, null, 2) + `
+`);
+}
+function hasProject(cwd) {
+  return existsSync2(join2(cwd, PROJECT_FILE));
+}
+
+// src/utils/scaffold.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { join as join3, dirname } from "path";
+
+// src/templates/index.ts
+function getPackageJson(name) {
+  return JSON.stringify({
+    name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "struere dev",
+      build: "struere build",
+      test: "struere test",
+      deploy: "struere deploy"
+    },
+    dependencies: {
+      "@struere/core": "^0.1.0",
+      "@struere/runtime": "^0.1.0"
+    },
+    devDependencies: {
+      "@struere/cli": "^0.1.0",
+      "bun-types": "^1.0.0",
+      typescript: "^5.3.0"
+    }
+  }, null, 2);
+}
+function getTsConfig() {
+  return JSON.stringify({
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      lib: ["ES2022"],
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      outDir: "dist",
+      rootDir: "src",
+      types: ["bun-types"]
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  }, null, 2);
+}
+function getStruereConfig() {
+  return `import { defineConfig } from '@struere/core'
+
+export default defineConfig({
+  port: 3000,
+  host: 'localhost',
+  cors: {
+    origins: ['http://localhost:3000'],
+    credentials: true,
+  },
+  logging: {
+    level: 'info',
+    format: 'pretty',
+  },
+})
+`;
+}
+function getAgentTs(name) {
+  const displayName = name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return `import { defineAgent } from '@struere/core'
+import { context } from './context'
+import { tools } from './tools'
+
+export default defineAgent({
+  name: '${name}',
+  version: '0.1.0',
+  description: '${displayName} Agent',
+  model: {
+    provider: 'anthropic',
+    name: 'claude-sonnet-4-20250514',
+    temperature: 0.7,
+    maxTokens: 4096,
+  },
+  systemPrompt: \`You are ${displayName}, a helpful AI assistant.
+
+Your capabilities:
+- Answer questions accurately and helpfully
+- Use available tools when appropriate
+- Maintain conversation context
+
+Always be concise, accurate, and helpful.\`,
+  tools,
+  context,
+  state: {
+    storage: 'memory',
+    ttl: 3600,
+  },
+})
+`;
+}
+function getContextTs() {
+  return `import { defineContext } from '@struere/core'
+
+export const context = defineContext(async (request) => {
+  const { conversationId, userId, channel, state } = request
+
+  return {
+    additionalContext: \`
+Current conversation: \${conversationId}
+Channel: \${channel}
+\`,
+    variables: {
+      userId,
+      timestamp: new Date().toISOString(),
+    },
+  }
+})
+`;
+}
+function getToolsTs() {
+  return `import { defineTools } from '@struere/core'
+
+export const tools = defineTools([
+  {
+    name: 'get_current_time',
+    description: 'Get the current date and time',
+    parameters: {
+      type: 'object',
+      properties: {
+        timezone: {
+          type: 'string',
+          description: 'Timezone (e.g., "America/New_York", "UTC")',
+        },
+      },
+    },
+    handler: async (params) => {
+      const timezone = (params.timezone as string) || 'UTC'
+      const now = new Date()
+      return {
+        timestamp: now.toISOString(),
+        formatted: now.toLocaleString('en-US', { timeZone: timezone }),
+        timezone,
+      }
+    },
+  },
+  {
+    name: 'calculate',
+    description: 'Perform a mathematical calculation',
+    parameters: {
+      type: 'object',
+      properties: {
+        expression: {
+          type: 'string',
+          description: 'Mathematical expression to evaluate (e.g., "2 + 2")',
+        },
+      },
+      required: ['expression'],
+    },
+    handler: async (params) => {
+      const expression = params.expression as string
+      const sanitized = expression.replace(/[^0-9+*/().\\s-]/g, '')
+      try {
+        const result = new Function(\`return \${sanitized}\`)()
+        return { expression, result }
+      } catch {
+        return { expression, error: 'Invalid expression' }
+      }
+    },
+  },
+])
+`;
+}
+function getBasicTestYaml() {
+  return `name: Basic conversation test
+description: Verify the agent responds correctly to basic queries
+
+conversation:
+  - role: user
+    content: Hello, what can you do?
+  - role: assistant
+    assertions:
+      - type: contains
+        value: help
+
+  - role: user
+    content: What time is it?
+  - role: assistant
+    assertions:
+      - type: toolCalled
+        value: get_current_time
+`;
+}
+function getEnvExample() {
+  return `# Anthropic API Key (default provider)
+ANTHROPIC_API_KEY=your_api_key_here
+
+# Optional: OpenAI API Key (if using OpenAI models)
+# OPENAI_API_KEY=your_openai_api_key
+
+# Optional: Google AI API Key (if using Gemini models)
+# GOOGLE_GENERATIVE_AI_API_KEY=your_google_api_key
+
+# Optional: Custom API endpoint
+# STRUERE_API_URL=https://api.struere.dev
+`;
+}
+function getGitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+.env.*.local
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+*.log
+logs/
+.vercel/
+`;
+}
+function getVercelApiHandler() {
+  return `import agent from '../src/agent'
+import { createVercelHandler } from '@struere/runtime/serverless/vercel'
+
+export default createVercelHandler(agent, {
+  streaming: true,
+  corsOrigins: ['*'],
+})
+
+export const config = {
+  runtime: 'edge',
+}
+`;
+}
+function getStruereJson(agentId, team, slug, name) {
+  return JSON.stringify({
+    agentId,
+    team,
+    agent: {
+      slug,
+      name
+    }
+  }, null, 2);
+}
+function getEnvLocal(deploymentUrl) {
+  return `STRUERE_DEPLOYMENT_URL=${deploymentUrl}
+`;
+}
+
+// src/utils/scaffold.ts
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function writeFile(cwd, relativePath, content) {
+  const fullPath = join3(cwd, relativePath);
+  ensureDir(fullPath);
+  writeFileSync3(fullPath, content);
+}
+function writeProjectConfig(cwd, options) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  writeFile(cwd, "struere.json", getStruereJson(options.agentId, options.team, options.agentSlug, options.agentName));
+  result.createdFiles.push("struere.json");
+  writeFile(cwd, ".env.local", getEnvLocal(options.deploymentUrl));
+  result.createdFiles.push(".env.local");
+  updateGitignore(cwd, result);
+  return result;
+}
+function scaffoldAgentFiles(cwd, projectName) {
+  const result = {
+    createdFiles: [],
+    updatedFiles: []
+  };
+  const files = {
+    "package.json": getPackageJson(projectName),
+    "tsconfig.json": getTsConfig(),
+    "struere.config.ts": getStruereConfig(),
+    "src/agent.ts": getAgentTs(projectName),
+    "src/context.ts": getContextTs(),
+    "src/tools.ts": getToolsTs(),
+    "src/workflows/.gitkeep": "",
+    "api/chat.ts": getVercelApiHandler(),
+    "tests/basic.test.yaml": getBasicTestYaml(),
+    ".env.example": getEnvExample()
+  };
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = join3(cwd, relativePath);
+    if (existsSync3(fullPath)) {
+      continue;
+    }
+    writeFile(cwd, relativePath, content);
+    result.createdFiles.push(relativePath);
+  }
+  updateGitignore(cwd, result);
+  return result;
+}
+function updateGitignore(cwd, result) {
+  const gitignorePath = join3(cwd, ".gitignore");
+  const linesToAdd = [".env.local"];
+  if (existsSync3(gitignorePath)) {
+    const content = readFileSync3(gitignorePath, "utf-8");
+    const lines = content.split(`
+`);
+    const missingLines = linesToAdd.filter((line) => !lines.some((l) => l.trim() === line));
+    if (missingLines.length > 0) {
+      const toAppend = `
+` + missingLines.join(`
+`) + `
+`;
+      appendFileSync(gitignorePath, toAppend);
+      result.updatedFiles.push(".gitignore");
+    }
+  } else {
+    writeFile(cwd, ".gitignore", getGitignore());
+    result.createdFiles.push(".gitignore");
+  }
+}
+function hasAgentFiles(cwd) {
+  return existsSync3(join3(cwd, "src", "agent.ts"));
+}
+
+// src/commands/init.ts
+var initCommand = new Command2("init").description("Initialize a new Struere project").argument("[project-name]", "Project name").option("-y, --yes", "Skip prompts and use defaults").option("--headless", "Use headless login if authentication is needed").action(async (projectNameArg, options) => {
+  const cwd = process.cwd();
+  const spinner = ora2();
+  console.log();
+  console.log(chalk2.bold("Struere CLI"));
+  console.log();
+  if (hasProject(cwd)) {
+    const existingProject = loadProject(cwd);
+    if (existingProject) {
+      console.log(chalk2.yellow("This project is already initialized."));
+      console.log();
+      console.log(chalk2.gray("  Agent:"), chalk2.cyan(existingProject.agent.name));
+      console.log(chalk2.gray("  ID:"), chalk2.gray(existingProject.agentId));
+      console.log(chalk2.gray("  Team:"), chalk2.cyan(existingProject.team));
+      console.log();
+      const shouldRelink = await promptYesNo("Would you like to relink to a different agent?");
+      if (!shouldRelink) {
+        console.log();
+        console.log(chalk2.gray("Run"), chalk2.cyan("struere dev"), chalk2.gray("to start development"));
+        console.log();
+        return;
+      }
+    }
+  }
+  let credentials = loadCredentials();
+  if (!credentials) {
+    console.log(chalk2.gray("Authentication required"));
+    console.log();
+    credentials = await performLogin({ headless: options.headless });
+    if (!credentials) {
+      console.log(chalk2.red("Authentication failed"));
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk2.green("\u2713"), "Logged in as", chalk2.cyan(credentials.user.name));
+    console.log();
+  }
+  let projectName = projectNameArg;
+  if (!projectName) {
+    projectName = await deriveProjectName(cwd);
+    if (!options.yes) {
+      const confirmed = await promptText("Agent name:", projectName);
+      projectName = confirmed || projectName;
+    }
+  }
+  projectName = slugify(projectName);
+  spinner.start("Fetching agents");
+  const api = new ApiClient;
+  let agents = [];
+  try {
+    const { agents: existingAgents } = await api.listAgents();
+    agents = existingAgents;
+    spinner.succeed(`Found ${agents.length} existing agent(s)`);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 401) {
+      spinner.fail("Session expired");
+      console.log();
+      console.log(chalk2.gray("Run"), chalk2.cyan("struere login"), chalk2.gray("to re-authenticate"));
+      process.exit(1);
+    }
+    spinner.succeed("Ready to create agent");
+  }
+  let selectedAgent = null;
+  let deploymentUrl = "";
+  if (agents.length > 0 && !options.yes) {
+    console.log();
+    const choice = await promptChoice("Create new agent or link existing?", [
+      { value: "new", label: "Create new agent" },
+      ...agents.map((a) => ({ value: a.id, label: `${a.name} (${a.slug})` }))
+    ]);
+    if (choice !== "new") {
+      selectedAgent = agents.find((a) => a.id === choice) || null;
+    }
+  }
+  if (!selectedAgent) {
+    const displayName = projectName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    spinner.start("Creating agent");
+    try {
+      const { agent } = await api.createAgent({
+        name: displayName,
+        slug: projectName,
+        description: `${displayName} Agent`
+      });
+      selectedAgent = { id: agent.id, name: displayName, slug: projectName };
+      deploymentUrl = `https://${projectName}-dev.struere.dev`;
+      spinner.succeed(`Created agent "${projectName}"`);
+    } catch (error) {
+      spinner.fail("Failed to create agent");
+      console.log();
+      if (error instanceof ApiError) {
+        console.log(chalk2.red("Error:"), error.message);
+      } else {
+        console.log(chalk2.red("Error:"), error instanceof Error ? error.message : String(error));
+      }
+      process.exit(1);
+    }
+  } else {
+    deploymentUrl = `https://${selectedAgent.slug}-dev.struere.dev`;
+    console.log();
+    console.log(chalk2.green("\u2713"), `Linked to "${selectedAgent.name}"`);
+  }
+  saveProject(cwd, {
+    agentId: selectedAgent.id,
+    team: credentials.organization.slug,
+    agent: {
+      slug: selectedAgent.slug,
+      name: selectedAgent.name
+    }
+  });
+  console.log(chalk2.green("\u2713"), "Created struere.json");
+  const configResult = writeProjectConfig(cwd, {
+    projectName,
+    agentId: selectedAgent.id,
+    team: credentials.organization.slug,
+    agentSlug: selectedAgent.slug,
+    agentName: selectedAgent.name,
+    deploymentUrl
+  });
+  for (const file of configResult.createdFiles) {
+    if (file !== "struere.json") {
+      console.log(chalk2.green("\u2713"), `Created ${file}`);
+    }
+  }
+  for (const file of configResult.updatedFiles) {
+    console.log(chalk2.green("\u2713"), `Updated ${file}`);
   }
-  async getAgent(agentId) {
-    return this.request(`/v1/agents/${agentId}`);
+  if (!hasAgentFiles(cwd)) {
+    let shouldScaffold = options.yes;
+    if (!options.yes) {
+      console.log();
+      shouldScaffold = await promptYesNo("Scaffold starter files?");
+    }
+    if (shouldScaffold) {
+      const scaffoldResult = scaffoldAgentFiles(cwd, projectName);
+      console.log();
+      for (const file of scaffoldResult.createdFiles) {
+        console.log(chalk2.green("\u2713"), `Created ${file}`);
+      }
+      for (const file of scaffoldResult.updatedFiles) {
+        console.log(chalk2.green("\u2713"), `Updated ${file}`);
+      }
+    }
   }
-  async deployAgent(agentId, data) {
-    return this.request(`/v1/deployments/agents/${agentId}/deploy`, {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
+  console.log();
+  console.log(chalk2.green("Success!"), "Project initialized");
+  console.log();
+  console.log(chalk2.gray("Next steps:"));
+  console.log(chalk2.gray("  $"), chalk2.cyan("bun install"));
+  console.log(chalk2.gray("  $"), chalk2.cyan("struere dev"));
+  console.log();
+});
+async function deriveProjectName(cwd) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (existsSync4(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+      if (pkg.name && typeof pkg.name === "string") {
+        return slugify(pkg.name);
+      }
+    } catch {}
   }
-  async createApiKey(data) {
-    return this.request("/v1/api-keys", {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
+  return slugify(basename(cwd));
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function promptYesNo(message) {
+  process.stdout.write(chalk2.gray(`${message} (Y/n) `));
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (data) => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      const answer = data.trim().toLowerCase();
+      resolve(answer === "" || answer === "y" || answer === "yes");
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function promptText(message, defaultValue) {
+  process.stdout.write(chalk2.gray(`${message} `));
+  process.stdout.write(chalk2.cyan(`(${defaultValue}) `));
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (data) => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      const answer = data.trim();
+      resolve(answer || defaultValue);
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function promptChoice(message, choices) {
+  console.log(chalk2.gray(message));
+  console.log();
+  for (let i = 0;i < choices.length; i++) {
+    const prefix = i === 0 ? chalk2.cyan("\u276F") : chalk2.gray(" ");
+    console.log(`${prefix} ${choices[i].label}`);
   }
-  async listApiKeys() {
-    return this.request("/v1/api-keys");
+  console.log();
+  process.stdout.write(chalk2.gray("Enter choice (1-" + choices.length + "): "));
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (data) => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      const num = parseInt(data.trim(), 10);
+      if (num >= 1 && num <= choices.length) {
+        resolve(choices[num - 1].value);
+      } else {
+        resolve(choices[0].value);
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/commands/dev.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import chokidar from "chokidar";
+import { join as join7 } from "path";
+
+// src/utils/config.ts
+import { join as join5 } from "path";
+var defaultConfig = {
+  port: 3000,
+  host: "localhost",
+  cors: {
+    origins: ["http://localhost:3000"],
+    credentials: true
+  },
+  logging: {
+    level: "info",
+    format: "pretty"
+  },
+  auth: {
+    type: "none"
   }
-  async getUsage(period = "day") {
-    return this.request(`/v1/usage?period=${period}`);
+};
+async function loadConfig(cwd) {
+  const configPath = join5(cwd, "struere.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;
   }
 }
 
-class ApiError extends Error {
-  code;
-  status;
-  constructor(message, code, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "ApiError";
+// src/utils/agent.ts
+import { join as join6 } from "path";
+async function loadAgent(cwd) {
+  const agentPath = join6(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
-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();
+var devCommand = new Command3("dev").description("Start development server with cloud sync").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").action(async (options) => {
+  const spinner = ora3();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk.bold("Struere Dev Server"));
+  console.log(chalk3.bold("Struere Dev Server"));
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk3.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk3.gray("Run"), chalk3.cyan("struere init"), chalk3.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProject(cwd);
+  if (!project) {
+    console.log(chalk3.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  console.log(chalk3.gray("Agent:"), chalk3.cyan(project.agent.name));
   console.log();
   spinner.start("Loading configuration");
   const config = await loadConfig(cwd);
@@ -246,115 +1098,20 @@ var devCommand = new Command("dev").description("Start development server with h
   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(chalk3.gray("Run"), chalk3.cyan("struere login"), chalk3.gray("to authenticate"));
     console.log();
     process.exit(1);
   }
+  await runCloudDev(agent, project, cwd, port, options, spinner);
+});
+async function runCloudDev(agent, project, cwd, port, options, spinner) {
+  const credentials = loadCredentials();
+  const apiKey = getApiKey();
   spinner.start("Connecting to Struere Cloud");
   const syncUrl = getSyncUrl();
   const ws = new WebSocket(`${syncUrl}/v1/dev/sync`);
@@ -376,7 +1133,8 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
         const configHash = hashString(bundle);
         ws.send(JSON.stringify({
           type: "sync",
-          agentSlug: agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+          agentId: project.agentId,
+          agentSlug: project.agent.slug,
           bundle,
           configHash
         }));
@@ -387,14 +1145,14 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
         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(chalk3.gray("Mode:"), chalk3.green("Cloud"));
+        console.log(chalk3.green("Agent running at"), chalk3.cyan(cloudUrl));
+        console.log(chalk3.green("Local server at"), chalk3.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;
+        const logColor = data.level === "error" ? chalk3.red : data.level === "warn" ? chalk3.yellow : data.level === "debug" ? chalk3.gray : chalk3.blue;
         spinner.stop();
         console.log(logColor(`[${data.level}]`), data.message);
         spinner.start("Watching for changes");
@@ -403,19 +1161,19 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
         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"));
+          console.log(chalk3.gray("Run"), chalk3.cyan("struere login"), chalk3.gray("to authenticate"));
         }
         break;
     }
   };
-  ws.onerror = (error) => {
+  ws.onerror = () => {
     spinner.fail("WebSocket error");
-    console.log(chalk.red("Connection error. Falling back to local mode."));
+    console.log(chalk3.red("Connection error"));
   };
   ws.onclose = () => {
     if (isConnected) {
       spinner.stop();
-      console.log(chalk.yellow("Disconnected from cloud"));
+      console.log(chalk3.yellow("Disconnected from cloud"));
     }
   };
   const server = Bun.serve({
@@ -435,7 +1193,6 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
           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: {
@@ -453,8 +1210,8 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
             }
           });
         }
-        const data = await response.json();
-        return Response.json(data);
+        const responseData = await response.json();
+        return Response.json(responseData);
       }
       if (url.pathname === "/" && options.channel === "web") {
         return new Response(getDevHtml(agent.name, "cloud", cloudUrl), {
@@ -472,7 +1229,7 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
       Bun.spawn(["xdg-open", openUrl]);
     }
   }
-  const watcher = chokidar.watch([join4(cwd, "src"), join4(cwd, "af.config.ts")], {
+  const watcher = chokidar.watch([join7(cwd, "src"), join7(cwd, "struere.config.ts")], {
     ignoreInitial: true,
     ignored: /node_modules/
   });
@@ -485,7 +1242,8 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
       if (ws.readyState === WebSocket.OPEN) {
         ws.send(JSON.stringify({
           type: "sync",
-          agentSlug: agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+          agentId: project.agentId,
+          agentSlug: project.agent.slug,
           bundle,
           configHash
         }));
@@ -504,13 +1262,13 @@ async function runCloudDev(agent, cwd, port, options, spinner) {
     }
     watcher.close();
     server.stop();
-    console.log(chalk.gray("Server stopped"));
+    console.log(chalk3.gray("Server stopped"));
     process.exit(0);
   });
 }
 async function bundleAgent(cwd) {
   const result = await Bun.build({
-    entrypoints: [join4(cwd, "src", "agent.ts")],
+    entrypoints: [join7(cwd, "src", "agent.ts")],
     target: "browser",
     minify: true
   });
@@ -636,12 +1394,12 @@ function getDevHtml(agentName, mode, cloudUrl) {
                 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));
+                addMessage('tool', '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);
+                addMessage('tool', 'Result: ' + resultText);
               } else if (data.type === 'finish') {
                 assistantDiv.classList.remove('streaming');
               } else if (data.type === 'error') {
@@ -672,7 +1430,7 @@ function getDevHtml(agentName, mode, cloudUrl) {
           const resultText = typeof tc.result === 'string'
             ? tc.result
             : JSON.stringify(tc.result, null, 2);
-          addMessage('tool', '\uD83D\uDD27 ' + tc.name + ': ' + resultText);
+          addMessage('tool', tc.name + ': ' + resultText);
         }
       }
 
@@ -710,10 +1468,10 @@ function getDevHtml(agentName, mode, cloudUrl) {
 }
 
 // src/commands/build.ts
-import { Command as Command2 } from "commander";
-import chalk2 from "chalk";
-import ora2 from "ora";
-import { join as join5 } from "path";
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { join as join8 } from "path";
 
 // src/utils/validate.ts
 function validateAgent(agent) {
@@ -791,11 +1549,11 @@ function validateTool(tool) {
 }
 
 // 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();
+var buildCommand = new Command4("build").description("Build and validate agent for production").option("-o, --outdir <dir>", "Output directory", "dist").action(async (options) => {
+  const spinner = ora4();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk2.bold("Building Agent"));
+  console.log(chalk4.bold("Building Agent"));
   console.log();
   spinner.start("Loading configuration");
   const config = await loadConfig(cwd);
@@ -809,16 +1567,16 @@ var buildCommand = new Command2("build").description("Build and validate agent f
     spinner.fail("Validation failed");
     console.log();
     for (const error of errors) {
-      console.log(chalk2.red("  ✗"), error);
+      console.log(chalk4.red("  \u2717"), error);
     }
     console.log();
     process.exit(1);
   }
   spinner.succeed("Agent validated");
   spinner.start("Building");
-  const outdir = join5(cwd, options.outdir);
+  const outdir = join8(cwd, options.outdir);
   const result = await Bun.build({
-    entrypoints: [join5(cwd, "src/agent.ts")],
+    entrypoints: [join8(cwd, "src/agent.ts")],
     outdir,
     target: "node",
     minify: true
@@ -827,40 +1585,40 @@ var buildCommand = new Command2("build").description("Build and validate agent f
     spinner.fail("Build failed");
     console.log();
     for (const log of result.logs) {
-      console.log(chalk2.red("  ✗"), log.message);
+      console.log(chalk4.red("  \u2717"), log.message);
     }
     process.exit(1);
   }
   spinner.succeed("Build completed");
   console.log();
-  console.log(chalk2.green("Success!"), `Built to ${chalk2.cyan(options.outdir)}`);
+  console.log(chalk4.green("Success!"), `Built to ${chalk4.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(chalk4.gray("  \u2022"), 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 { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora5 from "ora";
+import { join as join9 } 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();
+import { AgentExecutor } from "@struere/runtime";
+var testCommand = new Command5("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 = ora5();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk3.bold("Running Tests"));
+  console.log(chalk5.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");
+  const testsDir = join9(cwd, "tests");
   let testFiles = [];
   try {
     const files = await readdir(testsDir);
@@ -868,7 +1626,7 @@ var testCommand = new Command3("test").description("Run test conversations").arg
   } catch {
     spinner.warn("No tests directory found");
     console.log();
-    console.log(chalk3.gray("Create tests in"), chalk3.cyan("tests/*.test.yaml"));
+    console.log(chalk5.gray("Create tests in"), chalk5.cyan("tests/*.test.yaml"));
     console.log();
     return;
   }
@@ -880,26 +1638,26 @@ var testCommand = new Command3("test").description("Run test conversations").arg
   spinner.succeed(`Found ${testFiles.length} test file(s)`);
   if (options.dryRun) {
     console.log();
-    console.log(chalk3.yellow("Dry run mode - skipping execution"));
+    console.log(chalk5.yellow("Dry run mode - skipping execution"));
     console.log();
   }
   const results = [];
   for (const file of testFiles) {
-    const filePath = join6(testsDir, file);
+    const filePath = join9(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);
+      console.log(chalk5.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);
+      console.log(chalk5.green("  \u2713"), result.name);
     } else {
-      console.log(chalk3.red("  ✗"), result.name);
+      console.log(chalk5.red("  \u2717"), result.name);
       for (const error of result.errors) {
-        console.log(chalk3.red("    →"), error);
+        console.log(chalk5.red("    \u2192"), error);
       }
     }
   }
@@ -907,9 +1665,9 @@ var testCommand = new Command3("test").description("Run test conversations").arg
   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})`));
+    console.log(chalk5.green("All tests passed!"), chalk5.gray(`(${passed}/${results.length})`));
   } else {
-    console.log(chalk3.red("Tests failed:"), chalk3.gray(`${passed}/${results.length} passed`));
+    console.log(chalk5.red("Tests failed:"), chalk5.gray(`${passed}/${results.length} passed`));
   }
   console.log();
   if (failed > 0) {
@@ -925,7 +1683,7 @@ async function runDryTest(testCase) {
 }
 async function runTest(testCase, agent, verbose) {
   const errors = [];
-  const executor = new AgentExecutor2(agent);
+  const executor = new AgentExecutor(agent);
   const conversationId = `test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const context = {
     lastResponse: "",
@@ -936,7 +1694,7 @@ async function runTest(testCase, agent, verbose) {
     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 ? "..." : ""));
+          console.log(chalk5.cyan("    User:"), message.content.slice(0, 50) + (message.content.length > 50 ? "..." : ""));
         }
         const result = await executor.execute({
           conversationId,
@@ -945,9 +1703,9 @@ async function runTest(testCase, agent, verbose) {
         context.lastResponse = result.message;
         context.toolCalls = result.toolCalls || [];
         if (verbose) {
-          console.log(chalk3.green("    Assistant:"), result.message.slice(0, 50) + (result.message.length > 50 ? "..." : ""));
+          console.log(chalk5.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(", "));
+            console.log(chalk5.yellow("    Tools:"), result.toolCalls.map((t) => t.name).join(", "));
           }
         }
       }
@@ -1020,18 +1778,32 @@ function formatAssertionError(assertion, context) {
 }
 
 // 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();
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora6 from "ora";
+import { join as join10 } from "path";
+var deployCommand = new Command6("deploy").description("Deploy agent to Struere 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 = ora6();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk4.bold("Deploying Agent"));
+  console.log(chalk6.bold("Deploying Agent"));
+  console.log();
+  if (!hasProject(cwd)) {
+    console.log(chalk6.yellow("No struere.json found"));
+    console.log();
+    console.log(chalk6.gray("Run"), chalk6.cyan("struere init"), chalk6.gray("to initialize this project"));
+    console.log();
+    process.exit(1);
+  }
+  const project = loadProject(cwd);
+  if (!project) {
+    console.log(chalk6.red("Failed to load struere.json"));
+    process.exit(1);
+  }
+  console.log(chalk6.gray("Agent:"), chalk6.cyan(project.agent.name));
   console.log();
   spinner.start("Loading configuration");
-  const config = await loadConfig(cwd);
+  await loadConfig(cwd);
   spinner.succeed("Configuration loaded");
   spinner.start("Loading agent");
   const agent = await loadAgent(cwd);
@@ -1042,7 +1814,7 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
     spinner.fail("Validation failed");
     console.log();
     for (const error of errors) {
-      console.log(chalk4.red("  ✗"), error);
+      console.log(chalk6.red("  x"), error);
     }
     console.log();
     process.exit(1);
@@ -1050,12 +1822,13 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
   spinner.succeed("Agent validated");
   if (options.dryRun) {
     console.log();
-    console.log(chalk4.yellow("Dry run mode - no changes will be made"));
+    console.log(chalk6.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(chalk6.gray("  -"), `Agent: ${chalk6.cyan(agent.name)}`);
+    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(agent.version)}`);
+    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(options.env)}`);
+    console.log(chalk6.gray("  -"), `Agent ID: ${chalk6.cyan(project.agentId)}`);
     console.log();
     return;
   }
@@ -1064,14 +1837,14 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
   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(chalk6.gray("Run"), chalk6.cyan("struere login"), chalk6.gray("to authenticate"));
+    console.log(chalk6.gray("Or set"), chalk6.cyan("STRUERE_API_KEY"), chalk6.gray("environment variable"));
     console.log();
     process.exit(1);
   }
   spinner.start("Building agent bundle");
   const result = await Bun.build({
-    entrypoints: [join7(cwd, "src", "agent.ts")],
+    entrypoints: [join10(cwd, "src", "agent.ts")],
     target: "browser",
     minify: true
   });
@@ -1079,7 +1852,7 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
     spinner.fail("Build failed");
     console.log();
     for (const log of result.logs) {
-      console.log(chalk4.red("  •"), log);
+      console.log(chalk6.red("  -"), log);
     }
     console.log();
     process.exit(1);
@@ -1089,23 +1862,7 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
   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, {
+    const { deployment } = await api.deployAgent(project.agentId, {
       bundle,
       version: agent.version,
       environment: options.env,
@@ -1118,28 +1875,28 @@ var deployCommand = new Command4("deploy").description("Deploy agent to Agent Fa
     });
     spinner.succeed(`Deployed to ${options.env}`);
     console.log();
-    console.log(chalk4.green("Success!"), "Agent deployed");
+    console.log(chalk6.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(chalk6.gray("  -"), `ID: ${chalk6.cyan(deployment.id)}`);
+    console.log(chalk6.gray("  -"), `Version: ${chalk6.cyan(deployment.version)}`);
+    console.log(chalk6.gray("  -"), `Environment: ${chalk6.cyan(deployment.environment)}`);
+    console.log(chalk6.gray("  -"), `URL: ${chalk6.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(chalk6.gray("Test your agent:"));
+    console.log(chalk6.gray("  $"), chalk6.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);
+      console.log(chalk6.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"));
+        console.log(chalk6.gray("Try running"), chalk6.cyan("struere login"), chalk6.gray("to re-authenticate"));
       }
     } else {
-      console.log(chalk4.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
     }
     console.log();
     process.exit(1);
@@ -1155,14 +1912,14 @@ function formatBytes(bytes) {
 }
 
 // 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();
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora7 from "ora";
+var validateCommand = new Command7("validate").description("Validate agent configuration").option("--strict", "Enable strict validation").action(async (options) => {
+  const spinner = ora7();
   const cwd = process.cwd();
   console.log();
-  console.log(chalk5.bold("Validating Agent"));
+  console.log(chalk7.bold("Validating Agent"));
   console.log();
   spinner.start("Loading agent");
   let agent;
@@ -1172,7 +1929,7 @@ var validateCommand = new Command5("validate").description("Validate agent confi
   } catch (error) {
     spinner.fail("Failed to load agent");
     console.log();
-    console.log(chalk5.red("Error:"), error instanceof Error ? error.message : String(error));
+    console.log(chalk7.red("Error:"), error instanceof Error ? error.message : String(error));
     console.log();
     process.exit(1);
   }
@@ -1182,25 +1939,25 @@ var validateCommand = new Command5("validate").description("Validate agent confi
   if (errors.length === 0 && warnings.length === 0) {
     spinner.succeed("Agent is valid");
     console.log();
-    console.log(chalk5.green("✓"), "No issues found");
+    console.log(chalk7.green("\u2713"), "No issues found");
     console.log();
     return;
   }
   if (errors.length > 0) {
     spinner.fail("Validation failed");
     console.log();
-    console.log(chalk5.red("Errors:"));
+    console.log(chalk7.red("Errors:"));
     for (const error of errors) {
-      console.log(chalk5.red("  ✗"), error);
+      console.log(chalk7.red("  \u2717"), error);
     }
   } else {
     spinner.succeed("Validation passed with warnings");
   }
   if (warnings.length > 0) {
     console.log();
-    console.log(chalk5.yellow("Warnings:"));
+    console.log(chalk7.yellow("Warnings:"));
     for (const warning of warnings) {
-      console.log(chalk5.yellow("  ⚠"), warning);
+      console.log(chalk7.yellow("  \u26A0"), warning);
     }
   }
   console.log();
@@ -1220,20 +1977,20 @@ function getStrictWarnings(agent) {
 }
 
 // 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();
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora8 from "ora";
+var logsCommand = new Command8("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 = ora8();
   console.log();
-  console.log(chalk6.bold("Streaming Logs"));
+  console.log(chalk8.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(chalk8.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(chalk8.gray("  $"), chalk8.cyan("export STRUERE_API_KEY=your_api_key"));
     console.log();
     process.exit(1);
   }
@@ -1250,13 +2007,13 @@ var logsCommand = new Command6("logs").description("Stream production logs").opt
       ws.onopen = () => {
         spinner.succeed(`Connected to ${options.env}`);
         console.log();
-        console.log(chalk6.gray("Streaming logs... (Ctrl+C to stop)"));
+        console.log(chalk8.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);
+        const levelColor = log.level === "error" ? chalk8.red : log.level === "warn" ? chalk8.yellow : chalk8.gray;
+        console.log(chalk8.gray(new Date(log.timestamp).toISOString()), levelColor(`[${log.level}]`), log.message);
       };
       ws.onerror = () => {
         spinner.fail("Connection error");
@@ -1264,7 +2021,7 @@ var logsCommand = new Command6("logs").description("Stream production logs").opt
       };
       ws.onclose = () => {
         console.log();
-        console.log(chalk6.gray("Connection closed"));
+        console.log(chalk8.gray("Connection closed"));
         process.exit(0);
       };
       process.on("SIGINT", () => {
@@ -1274,7 +2031,7 @@ var logsCommand = new Command6("logs").description("Stream production logs").opt
     } catch (error) {
       spinner.fail("Failed to connect");
       console.log();
-      console.log(chalk6.red("Error:"), error instanceof Error ? error.message : String(error));
+      console.log(chalk8.red("Error:"), error instanceof Error ? error.message : String(error));
       console.log();
       process.exit(1);
     }
@@ -1293,14 +2050,14 @@ var logsCommand = new Command6("logs").description("Stream production logs").opt
       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);
+        const levelColor = log.level === "error" ? chalk8.red : log.level === "warn" ? chalk8.yellow : chalk8.gray;
+        console.log(chalk8.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(chalk8.red("Error:"), error instanceof Error ? error.message : String(error));
       console.log();
       process.exit(1);
     }
@@ -1308,20 +2065,20 @@ var logsCommand = new Command6("logs").description("Stream production logs").opt
 });
 
 // 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();
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+import ora9 from "ora";
+var stateCommand = new Command9("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 = ora9();
   console.log();
-  console.log(chalk7.bold("Conversation State"));
+  console.log(chalk9.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(chalk9.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(chalk9.gray("  $"), chalk9.cyan("export STRUERE_API_KEY=your_api_key"));
     console.log();
     process.exit(1);
   }
@@ -1348,349 +2105,111 @@ var stateCommand = new Command7("state").description("Inspect conversation state
       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(chalk9.gray("Conversation:"), chalk9.cyan(state.conversationId));
+    console.log(chalk9.gray("Created:"), new Date(state.createdAt).toLocaleString());
+    console.log(chalk9.gray("Updated:"), new Date(state.updatedAt).toLocaleString());
+    console.log(chalk9.gray("Messages:"), state.messageCount);
     console.log();
-    console.log(chalk7.bold("State:"));
+    console.log(chalk9.bold("State:"));
     if (Object.keys(state.state).length === 0) {
-      console.log(chalk7.gray("  (empty)"));
+      console.log(chalk9.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(chalk9.gray("  \u2022"), `${key}:`, chalk9.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(chalk9.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 () => {
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+var logoutCommand = new Command10("logout").description("Log out of Struere").action(async () => {
   console.log();
   const credentials = loadCredentials();
   if (!credentials) {
-    console.log(chalk9.yellow("Not currently logged in"));
+    console.log(chalk10.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(chalk10.green("Logged out successfully"));
+  console.log(chalk10.gray("Goodbye,"), chalk10.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) => {
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+import ora10 from "ora";
+var whoamiCommand = new Command11("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(chalk11.yellow("Not logged in"));
     console.log();
-    console.log(chalk10.gray("Run"), chalk10.cyan("af login"), chalk10.gray("to log in"));
+    console.log(chalk11.gray("Run"), chalk11.cyan("struere login"), chalk11.gray("to log in"));
     console.log();
     return;
   }
   if (options.refresh) {
-    const spinner = ora9("Fetching user info").start();
+    const spinner = ora10("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(chalk11.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(chalk11.gray("  User:        "), chalk11.cyan(user.name), chalk11.gray(`<${user.email}>`));
+      console.log(chalk11.gray("  User ID:     "), chalk11.gray(user.id));
+      console.log(chalk11.gray("  Role:        "), chalk11.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(chalk11.gray("  Organization:"), chalk11.cyan(organization.name));
+      console.log(chalk11.gray("  Org ID:      "), chalk11.gray(organization.id));
+      console.log(chalk11.gray("  Slug:        "), chalk11.cyan(organization.slug));
+      console.log(chalk11.gray("  Plan:        "), chalk11.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."));
+          console.log(chalk11.red("Session expired. Please log in again."));
         } else {
-          console.log(chalk10.red("Error:"), error.message);
+          console.log(chalk11.red("Error:"), error.message);
         }
       } else {
-        console.log(chalk10.red("Error:"), error instanceof Error ? error.message : String(error));
+        console.log(chalk11.red("Error:"), error instanceof Error ? error.message : String(error));
       }
       console.log();
       process.exit(1);
     }
   } else {
-    console.log(chalk10.bold("Logged in as:"));
+    console.log(chalk11.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(chalk11.gray("  User:        "), chalk11.cyan(credentials.user.name), chalk11.gray(`<${credentials.user.email}>`));
+    console.log(chalk11.gray("  User ID:     "), chalk11.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(chalk11.gray("  Organization:"), chalk11.cyan(credentials.organization.name));
+    console.log(chalk11.gray("  Org ID:      "), chalk11.gray(credentials.organization.id));
+    console.log(chalk11.gray("  Slug:        "), chalk11.cyan(credentials.organization.slug));
     console.log();
-    console.log(chalk10.gray("Use"), chalk10.cyan("af whoami --refresh"), chalk10.gray("to fetch latest info"));
+    console.log(chalk11.gray("Use"), chalk11.cyan("struere whoami --refresh"), chalk11.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.name("struere").description("Struere CLI - Build, test, and deploy AI agents").version("0.2.0");
+program.addCommand(initCommand);
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);