@agentforge-ai/cli 0.5.0 → 0.5.2

package/dist/index.js

@@ -181,11 +181,271 @@ async function runProject(options) {
 }
 
 // src/commands/deploy.ts
-import path3 from "path";
+import path4 from "path";
 import { execSync as execSync2 } from "child_process";
+import fs4 from "fs-extra";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/lib/credentials.ts
 import fs3 from "fs-extra";
+import path3 from "path";
+import os from "os";
+var CREDENTIALS_DIR = path3.join(os.homedir(), ".agentforge");
+var CREDENTIALS_FILE = path3.join(CREDENTIALS_DIR, "credentials.json");
+var DEFAULT_CLOUD_URL = "https://cloud.agentforge.ai";
+async function ensureCredentialsDir() {
+  await fs3.ensureDir(CREDENTIALS_DIR);
+  try {
+    await fs3.chmod(CREDENTIALS_DIR, 448);
+  } catch {
+  }
+}
+async function readCredentials() {
+  try {
+    if (!await fs3.pathExists(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const content = await fs3.readFile(CREDENTIALS_FILE, "utf-8");
+    const creds = JSON.parse(content);
+    if (!creds.cloudUrl) {
+      creds.cloudUrl = DEFAULT_CLOUD_URL;
+    }
+    return creds;
+  } catch (error2) {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  await ensureCredentialsDir();
+  const data = {
+    ...credentials,
+    cloudUrl: credentials.cloudUrl || DEFAULT_CLOUD_URL,
+    refreshedAt: Date.now()
+  };
+  await fs3.writeFile(CREDENTIALS_FILE, JSON.stringify(data, null, 2), "utf-8");
+  try {
+    await fs3.chmod(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+async function deleteCredentials() {
+  try {
+    if (await fs3.pathExists(CREDENTIALS_FILE)) {
+      await fs3.remove(CREDENTIALS_FILE);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function isAuthenticated() {
+  const creds = await readCredentials();
+  return creds !== null && creds.apiKey !== void 0;
+}
+async function getCloudUrl() {
+  const creds = await readCredentials();
+  return creds?.cloudUrl || process.env.AGENTFORGE_CLOUD_URL || DEFAULT_CLOUD_URL;
+}
+async function getApiKey() {
+  const creds = await readCredentials();
+  return creds?.apiKey || null;
+}
+function getCredentialsPath() {
+  return CREDENTIALS_FILE;
+}
+
+// src/lib/cloud-client.ts
+var CloudClientError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "CloudClientError";
+  }
+};
+var CloudClient = class {
+  baseUrl;
+  apiKey = null;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl || "https://cloud.agentforge.ai";
+    this.apiKey = apiKey || null;
+  }
+  /**
+   * Initialize the client with stored credentials
+   */
+  async initialize() {
+    this.baseUrl = await getCloudUrl();
+    this.apiKey = await getApiKey();
+  }
+  /**
+   * Set the API key directly
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Set the base URL directly
+   */
+  setBaseUrl(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Get the full API URL for an endpoint
+   */
+  getUrl(endpoint) {
+    const base = this.baseUrl.replace(/\/$/, "");
+    const path10 = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+    return `${base}${path10}`;
+  }
+  /**
+   * Get request headers with authentication
+   */
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "X-Client-Version": "0.5.1"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Make an HTTP request to the Cloud API
+   */
+  async request(method, endpoint, body) {
+    const url = this.getUrl(endpoint);
+    const options = {
+      method,
+      headers: this.getHeaders()
+    };
+    if (body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      options.body = JSON.stringify(body);
+    }
+    let response;
+    try {
+      response = await fetch(url, options);
+    } catch (error2) {
+      throw new CloudClientError(
+        `Network error: ${error2.message || "Failed to connect to AgentForge Cloud"}`,
+        "NETWORK_ERROR"
+      );
+    }
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    if (!response.ok) {
+      const errorBody = isJson ? await response.json() : null;
+      const message = errorBody?.message || errorBody?.error || `HTTP ${response.status}: ${response.statusText}`;
+      throw new CloudClientError(
+        message,
+        errorBody?.code || `HTTP_${response.status}`,
+        response.status
+      );
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    if (!isJson) {
+      const text = await response.text();
+      return { text };
+    }
+    return response.json();
+  }
+  /**
+   * Check if credentials are valid
+   */
+  async authenticate() {
+    if (!this.apiKey) {
+      throw new CloudClientError(
+        'No API key configured. Run "agentforge login" to authenticate.',
+        "NO_CREDENTIALS",
+        401
+      );
+    }
+    try {
+      const user = await this.request("GET", "/api/auth/me");
+      return user;
+    } catch (error2) {
+      if (error2.status === 401) {
+        throw new CloudClientError(
+          'Invalid API key. Run "agentforge login" to re-authenticate.',
+          "UNAUTHORIZED",
+          401
+        );
+      }
+      throw error2;
+    }
+  }
+  /**
+   * List all projects for the authenticated user
+   */
+  async listProjects() {
+    return this.request("GET", "/api/projects");
+  }
+  /**
+   * Get a specific project by ID
+   */
+  async getProject(projectId) {
+    return this.request("GET", `/api/projects/${projectId}`);
+  }
+  /**
+   * Upload agent configuration to Cloud
+   */
+  async uploadAgentConfig(projectId, agentConfig) {
+    return this.request(
+      "POST",
+      `/api/projects/${projectId}/agents`,
+      agentConfig
+    );
+  }
+  /**
+   * Create a new deployment
+   */
+  async createDeployment(request) {
+    return this.request(
+      "POST",
+      "/api/deployments/create",
+      request
+    );
+  }
+  /**
+   * Get deployment status
+   */
+  async getDeploymentStatus(deploymentId) {
+    return this.request(
+      "GET",
+      `/api/deployments/${deploymentId}/status`
+    );
+  }
+  /**
+   * Get deployment details
+   */
+  async getDeployment(deploymentId) {
+    return this.request("GET", `/api/deployments/${deploymentId}`);
+  }
+  /**
+   * Rollback a deployment
+   */
+  async rollbackDeployment(deploymentId) {
+    return this.request(
+      "POST",
+      `/api/deployments/${deploymentId}/rollback`
+    );
+  }
+  /**
+   * List deployments for a project
+   */
+  async listDeployments(projectId) {
+    return this.request("GET", `/api/projects/${projectId}/deployments`);
+  }
+};
+
+// src/commands/deploy.ts
 function parseEnvFile(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   const vars = {};
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -203,17 +463,217 @@ function parseEnvFile(filePath) {
   }
   return vars;
 }
-async function deployProject(options) {
+async function readAgentForgeConfig(projectDir) {
+  const tsConfigPath = path4.join(projectDir, "agentforge.config.ts");
+  if (await fs4.pathExists(tsConfigPath)) {
+    try {
+      const content = await fs4.readFile(tsConfigPath, "utf-8");
+      return parseConfigFromContent(content, projectDir);
+    } catch {
+    }
+  }
+  const jsonConfigPath = path4.join(projectDir, "agentforge.json");
+  if (await fs4.pathExists(jsonConfigPath)) {
+    try {
+      const content = await fs4.readFile(jsonConfigPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseConfigFromContent(content, projectDir) {
+  const config = {};
+  const projectIdMatch = content.match(/projectId\s*:\s*["']([^"']+)["']/);
+  if (projectIdMatch) {
+    config.projectId = projectIdMatch[1];
+  }
+  const agentsPath = path4.join(projectDir, "convex", "agents.ts");
+  if (fs4.existsSync(agentsPath)) {
+    try {
+      const agentsContent = fs4.readFileSync(agentsPath, "utf-8");
+      config.agents = parseAgentsFromConvex(agentsContent);
+    } catch {
+    }
+  }
+  const cloudUrlMatch = content.match(/cloudUrl\s*:\s*["']([^"']+)["']/);
+  if (cloudUrlMatch) {
+    config.cloudUrl = cloudUrlMatch[1];
+  }
+  return Object.keys(config).length > 0 ? config : null;
+}
+function parseAgentsFromConvex(content) {
+  const agents = [];
+  const agentPattern = /\{\s*id:\s*["']([^"']+)["']\s*,\s*name:\s*["']([^"']+)["']([\s\S]*?)\}/g;
+  let match;
+  while ((match = agentPattern.exec(content)) !== null) {
+    const id = match[1];
+    const name = match[2];
+    const rest = match[3];
+    const agent = { id, name, instructions: "", model: "gpt-4o-mini" };
+    const instructionsMatch = rest.match(/instructions:\s*["']([^"']+)["']/);
+    if (instructionsMatch) agent.instructions = instructionsMatch[1];
+    const modelMatch = rest.match(/model:\s*["']([^"']+)["']/);
+    if (modelMatch) agent.model = modelMatch[1];
+    const providerMatch = rest.match(/provider:\s*["']([^"']+)["']/);
+    if (providerMatch) agent.provider = providerMatch[1];
+    const descriptionMatch = rest.match(/description:\s*["']([^"']+)["']/);
+    if (descriptionMatch) agent.description = descriptionMatch[1];
+    agents.push(agent);
+  }
+  return agents;
+}
+async function deployToCloud(options, projectDir) {
+  console.log("\n\u2601\uFE0F  Deploying to AgentForge Cloud...\n");
+  const credentials = await readCredentials();
+  if (!credentials?.apiKey) {
+    console.error(chalk.red("\u2716"), "Not authenticated with AgentForge Cloud.");
+    console.error('   Run "agentforge login" to authenticate.\n');
+    process.exit(1);
+  }
+  const spinner = ora("Reading agent configuration...").start();
+  const config = await readAgentForgeConfig(projectDir);
+  let projectId = options.project || config?.projectId;
+  if (!projectId) {
+    spinner.stop();
+    console.error(chalk.red("\u2716"), "No project ID specified.");
+    console.error("   Use --project flag or set projectId in agentforge.config.ts\n");
+    process.exit(1);
+  }
+  let agents = config?.agents || [];
+  if (agents.length === 0) {
+    spinner.stop();
+    console.error(chalk.red("\u2716"), "No agents found in configuration.");
+    console.error("   Define agents in agentforge.config.ts or convex/agents.ts\n");
+    process.exit(1);
+  }
+  spinner.succeed(`Found ${agents.length} agent(s) to deploy`);
+  if (options.dryRun) {
+    console.log("\n" + chalk.blue("\u2139"), "Dry run - no changes will be made\n");
+    console.log("  Project ID:", chalk.cyan(projectId));
+    console.log("  Cloud URL:", chalk.cyan(credentials.cloudUrl || "https://cloud.agentforge.ai"));
+    console.log("  Agents:");
+    for (const agent of agents) {
+      console.log(`    \u2022 ${chalk.bold(agent.name)} (${agent.model})`);
+    }
+    console.log();
+    return;
+  }
+  const cloudSpinner = ora("Connecting to AgentForge Cloud...").start();
+  const client = new CloudClient(
+    credentials.cloudUrl || process.env.AGENTFORGE_CLOUD_URL,
+    credentials.apiKey
+  );
+  try {
+    await client.authenticate();
+    cloudSpinner.succeed("Connected to AgentForge Cloud");
+  } catch (err) {
+    cloudSpinner.fail("Failed to connect to AgentForge Cloud");
+    if (err instanceof CloudClientError) {
+      console.error(chalk.red("\u2716"), err.message);
+    } else {
+      console.error(chalk.red("\u2716"), err.message || err);
+    }
+    process.exit(1);
+  }
+  const projectSpinner = ora("Verifying project...").start();
+  try {
+    await client.getProject(projectId);
+    projectSpinner.succeed(`Project verified: ${chalk.cyan(projectId)}`);
+  } catch (err) {
+    projectSpinner.fail("Project verification failed");
+    if (err.status === 404) {
+      console.error(chalk.red("\u2716"), `Project "${projectId}" not found.`);
+      console.error("   Check the project ID or create the project in the dashboard.\n");
+    } else {
+      console.error(chalk.red("\u2716"), err.message || err);
+    }
+    process.exit(1);
+  }
+  const version = options.version || `v${Date.now()}`;
+  const deploySpinner = ora("Creating deployment...").start();
+  let deploymentId;
+  try {
+    const response = await client.createDeployment({
+      projectId,
+      agents,
+      version
+    });
+    deploymentId = response.deploymentId;
+    deploySpinner.succeed(`Deployment created: ${chalk.cyan(deploymentId)}`);
+  } catch (err) {
+    deploySpinner.fail("Failed to create deployment");
+    if (err instanceof CloudClientError) {
+      console.error(chalk.red("\u2716"), err.message);
+    } else {
+      console.error(chalk.red("\u2716"), err.message || err);
+    }
+    process.exit(1);
+  }
+  console.log("\n\u{1F4E6} Deploying agents...\n");
+  const pollSpinner = ora("Waiting for deployment to complete...").start();
+  const maxAttempts = 60;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    let status;
+    try {
+      status = await client.getDeploymentStatus(deploymentId);
+      attempts++;
+    } catch (err) {
+      attempts++;
+      if (attempts >= maxAttempts) {
+        pollSpinner.fail("Deployment status check timed out");
+        console.error();
+        console.error(chalk.yellow("\u26A0"), "The deployment may still be in progress.");
+        console.error(`   Check status at: https://cloud.agentforge.ai/projects/${projectId}/deployments/${deploymentId}`);
+        console.error();
+        process.exit(1);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+      continue;
+    }
+    if (status.status === "completed") {
+      pollSpinner.succeed("Deployment completed successfully!");
+      console.log();
+      console.log(chalk.green("\u2714"), `Deployed to ${chalk.bold(`https://cloud.agentforge.ai/projects/${projectId}`)}`);
+      if (status.url) {
+        console.log(chalk.green("\u2714"), `Deployment URL: ${chalk.cyan(status.url)}`);
+      }
+      console.log();
+      return;
+    } else if (status.status === "failed") {
+      pollSpinner.fail("Deployment failed");
+      console.error();
+      console.error(chalk.red("\u2716"), "Error:", status.errorMessage || "Unknown error");
+      console.error();
+      process.exit(1);
+    } else if (status.progress !== void 0) {
+      pollSpinner.text = `Deploying... ${status.progress}%`;
+    } else {
+      const statuses = {
+        pending: "Waiting to start...",
+        building: "Building...",
+        deploying: "Deploying..."
+      };
+      pollSpinner.text = statuses[status.status] || `Status: ${status.status}`;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+  }
+  pollSpinner.fail("Deployment timed out");
+  process.exit(1);
+}
+async function deployToConvex(options) {
   const projectDir = process.cwd();
-  const pkgPath = path3.join(projectDir, "package.json");
-  if (!await fs3.pathExists(pkgPath)) {
+  const pkgPath = path4.join(projectDir, "package.json");
+  if (!await fs4.pathExists(pkgPath)) {
     console.error(
       "Error: No package.json found. Are you in an AgentForge project directory?"
     );
     process.exit(1);
   }
-  const convexDir = path3.join(projectDir, "convex");
-  if (!await fs3.pathExists(convexDir)) {
+  const convexDir = path4.join(projectDir, "convex");
+  if (!await fs4.pathExists(convexDir)) {
     console.error(
       "Error: No convex/ directory found. Are you in an AgentForge project directory?"
     );
@@ -233,8 +693,8 @@ async function deployProject(options) {
     }
     return;
   }
-  const envPath = path3.resolve(projectDir, options.env);
-  const envExists = await fs3.pathExists(envPath);
+  const envPath = path4.resolve(projectDir, options.env);
+  const envExists = await fs4.pathExists(envPath);
   let envVars = {};
   if (envExists) {
     envVars = parseEnvFile(envPath);
@@ -299,10 +759,18 @@ async function deployProject(options) {
     process.exit(1);
   }
 }
+async function deployProject(options) {
+  const projectDir = process.cwd();
+  if (options.provider === "cloud") {
+    await deployToCloud(options, projectDir);
+  } else {
+    await deployToConvex(options);
+  }
+}
 
 // src/lib/convex-client.ts
-import fs4 from "fs-extra";
-import path4 from "path";
+import fs5 from "fs-extra";
+import path5 from "path";
 function safeCwd() {
   try {
     return process.cwd();
@@ -319,19 +787,19 @@ function getConvexUrl() {
   }
   const envFiles = [".env.local", ".env", ".env.production"];
   for (const envFile of envFiles) {
-    const envPath = path4.join(cwd, envFile);
-    if (fs4.existsSync(envPath)) {
-      const content = fs4.readFileSync(envPath, "utf-8");
+    const envPath = path5.join(cwd, envFile);
+    if (fs5.existsSync(envPath)) {
+      const content = fs5.readFileSync(envPath, "utf-8");
       const match = content.match(/CONVEX_URL\s*=\s*(.+)/);
       if (match) {
         return match[1].trim().replace(/["']/g, "");
       }
     }
   }
-  const convexEnv = path4.join(cwd, ".convex", "deployment.json");
-  if (fs4.existsSync(convexEnv)) {
+  const convexEnv = path5.join(cwd, ".convex", "deployment.json");
+  if (fs5.existsSync(convexEnv)) {
     try {
-      const data = JSON.parse(fs4.readFileSync(convexEnv, "utf-8"));
+      const data = JSON.parse(fs5.readFileSync(convexEnv, "utf-8"));
       if (data.url) return data.url;
     } catch {
     }
@@ -791,8 +1259,8 @@ function registerThreadsCommand(program2) {
 }
 
 // src/commands/skills.ts
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 import readline3 from "readline";
 function prompt2(q) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
@@ -812,9 +1280,9 @@ function registerSkillsCommand(program2) {
     }
     header("Skills");
     const localSkills = [];
-    const skillsDir = path5.join(process.cwd(), "skills");
-    if (fs5.existsSync(skillsDir)) {
-      const dirs = fs5.readdirSync(skillsDir).filter((d) => fs5.statSync(path5.join(skillsDir, d)).isDirectory());
+    const skillsDir = path6.join(process.cwd(), "skills");
+    if (fs6.existsSync(skillsDir)) {
+      const dirs = fs6.readdirSync(skillsDir).filter((d) => fs6.statSync(path6.join(skillsDir, d)).isDirectory());
       localSkills.push(...dirs);
     }
     const items = result || [];
@@ -826,11 +1294,11 @@ function registerSkillsCommand(program2) {
     if (localSkills.length > 0) {
       dim("  Local Skills:");
       localSkills.forEach((s) => {
-        const configPath = path5.join(skillsDir, s, "config.json");
+        const configPath = path6.join(skillsDir, s, "config.json");
         let desc = "";
-        if (fs5.existsSync(configPath)) {
+        if (fs6.existsSync(configPath)) {
           try {
-            desc = JSON.parse(fs5.readFileSync(configPath, "utf-8")).description || "";
+            desc = JSON.parse(fs6.readFileSync(configPath, "utf-8")).description || "";
           } catch {
           }
         }
@@ -857,13 +1325,13 @@ function registerSkillsCommand(program2) {
       error("Skill name is required.");
       process.exit(1);
     }
-    const skillDir = path5.join(process.cwd(), "skills", name);
-    if (fs5.existsSync(skillDir)) {
+    const skillDir = path6.join(process.cwd(), "skills", name);
+    if (fs6.existsSync(skillDir)) {
       error(`Skill "${name}" already exists at ${skillDir}`);
       process.exit(1);
     }
-    fs5.mkdirSync(skillDir, { recursive: true });
-    fs5.writeFileSync(path5.join(skillDir, "config.json"), JSON.stringify({
+    fs6.mkdirSync(skillDir, { recursive: true });
+    fs6.writeFileSync(path6.join(skillDir, "config.json"), JSON.stringify({
       name,
       version: "1.0.0",
       description,
@@ -873,7 +1341,7 @@ function registerSkillsCommand(program2) {
       dependencies: [],
       agentInstructions: `You have access to the ${name} skill. ${description}`
     }, null, 2));
-    fs5.writeFileSync(path5.join(skillDir, "index.ts"), `import { z } from 'zod';
+    fs6.writeFileSync(path6.join(skillDir, "index.ts"), `import { z } from 'zod';
 
 /**
  * ${name} \u2014 AgentForge Skill
@@ -899,7 +1367,7 @@ export const tools = [
 
 export default { tools };
 `);
-    fs5.writeFileSync(path5.join(skillDir, "SKILL.md"), `# ${name}
+    fs6.writeFileSync(path6.join(skillDir, "SKILL.md"), `# ${name}
 
 ${description}
 
@@ -929,11 +1397,11 @@ Edit \`skills/${name}/config.json\` to customize.
     success(`Skill "${name}" installed.`);
   });
   skills.command("remove").argument("<name>", "Skill name to remove").description("Remove a skill").action(async (name) => {
-    const skillDir = path5.join(process.cwd(), "skills", name);
-    if (fs5.existsSync(skillDir)) {
+    const skillDir = path6.join(process.cwd(), "skills", name);
+    if (fs6.existsSync(skillDir)) {
       const confirm = await prompt2(`Remove skill "${name}" and delete files? (y/N): `);
       if (confirm.toLowerCase() === "y") {
-        fs5.removeSync(skillDir);
+        fs6.removeSync(skillDir);
         success(`Skill "${name}" removed from disk.`);
       }
     }
@@ -1136,8 +1604,8 @@ function registerMcpCommand(program2) {
 }
 
 // src/commands/files.ts
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path7 from "path";
 function registerFilesCommand(program2) {
   const files = program2.command("files").description("Manage files");
   files.command("list").argument("[folder]", "Folder ID to list files from").option("--json", "Output as JSON").description("List files").action(async (folder, opts) => {
@@ -1164,14 +1632,14 @@ function registerFilesCommand(program2) {
     })));
   });
   files.command("upload").argument("<filepath>", "Path to file to upload").option("--folder <id>", "Folder ID to upload to").option("--project <id>", "Project ID to associate with").description("Upload a file").action(async (filepath, opts) => {
-    const absPath = path6.resolve(filepath);
-    if (!fs6.existsSync(absPath)) {
+    const absPath = path7.resolve(filepath);
+    if (!fs7.existsSync(absPath)) {
       error(`File not found: ${absPath}`);
       process.exit(1);
     }
-    const stat = fs6.statSync(absPath);
-    const name = path6.basename(absPath);
-    const ext = path6.extname(absPath).toLowerCase();
+    const stat = fs7.statSync(absPath);
+    const name = path7.basename(absPath);
+    const ext = path7.extname(absPath).toLowerCase();
     const mimeTypes = {
       ".txt": "text/plain",
       ".md": "text/markdown",
@@ -1335,8 +1803,8 @@ function registerProjectsCommand(program2) {
 }
 
 // src/commands/config.ts
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs8 from "fs-extra";
+import path8 from "path";
 import readline7 from "readline";
 function prompt6(q) {
   const rl = readline7.createInterface({ input: process.stdin, output: process.stdout });
@@ -1352,10 +1820,10 @@ function registerConfigCommand(program2) {
     const cwd = process.cwd();
     const envFiles = [".env", ".env.local", ".env.production"];
     for (const envFile of envFiles) {
-      const envPath = path7.join(cwd, envFile);
-      if (fs7.existsSync(envPath)) {
+      const envPath = path8.join(cwd, envFile);
+      if (fs8.existsSync(envPath)) {
         console.log(`  ${colors.cyan}${envFile}${colors.reset}`);
-        const content = fs7.readFileSync(envPath, "utf-8");
+        const content = fs8.readFileSync(envPath, "utf-8");
         content.split("\n").forEach((line) => {
           if (line.trim() && !line.startsWith("#")) {
             const [key, ...rest] = line.split("=");
@@ -1367,25 +1835,25 @@ function registerConfigCommand(program2) {
         console.log();
       }
     }
-    const convexDir = path7.join(cwd, ".convex");
-    if (fs7.existsSync(convexDir)) {
+    const convexDir = path8.join(cwd, ".convex");
+    if (fs8.existsSync(convexDir)) {
       info("Convex: Configured");
     } else {
       info("Convex: Not configured (run `npx convex dev`)");
     }
-    const skillsDir = path7.join(cwd, "skills");
-    if (fs7.existsSync(skillsDir)) {
-      const skills = fs7.readdirSync(skillsDir).filter((d) => fs7.statSync(path7.join(skillsDir, d)).isDirectory());
+    const skillsDir = path8.join(cwd, "skills");
+    if (fs8.existsSync(skillsDir)) {
+      const skills = fs8.readdirSync(skillsDir).filter((d) => fs8.statSync(path8.join(skillsDir, d)).isDirectory());
       info(`Skills: ${skills.length} installed (${skills.join(", ")})`);
     } else {
       info("Skills: None installed");
     }
   });
   config.command("set").argument("<key>", "Configuration key").argument("<value>", "Configuration value").option("--env <file>", "Environment file to update", ".env.local").description("Set a configuration value").action(async (key, value, opts) => {
-    const envPath = path7.join(process.cwd(), opts.env);
+    const envPath = path8.join(process.cwd(), opts.env);
     let content = "";
-    if (fs7.existsSync(envPath)) {
-      content = fs7.readFileSync(envPath, "utf-8");
+    if (fs8.existsSync(envPath)) {
+      content = fs8.readFileSync(envPath, "utf-8");
     }
     const lines = content.split("\n");
     const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
@@ -1394,16 +1862,16 @@ function registerConfigCommand(program2) {
     } else {
       lines.push(`${key}=${value}`);
     }
-    fs7.writeFileSync(envPath, lines.join("\n"));
+    fs8.writeFileSync(envPath, lines.join("\n"));
     success(`Set ${key} in ${opts.env}`);
   });
   config.command("get").argument("<key>", "Configuration key").description("Get a configuration value").action(async (key) => {
     const cwd = process.cwd();
     const envFiles = [".env.local", ".env", ".env.production"];
     for (const envFile of envFiles) {
-      const envPath = path7.join(cwd, envFile);
-      if (fs7.existsSync(envPath)) {
-        const content = fs7.readFileSync(envPath, "utf-8");
+      const envPath = path8.join(cwd, envFile);
+      if (fs8.existsSync(envPath)) {
+        const content = fs8.readFileSync(envPath, "utf-8");
         const match = content.match(new RegExp(`^${key}=(.+)$`, "m"));
         if (match) {
           console.log(match[1].trim());
@@ -1429,7 +1897,7 @@ function registerConfigCommand(program2) {
     else if (provider === "openrouter") envContent.push(`OPENROUTER_API_KEY=${apiKey}`);
     else if (provider === "anthropic") envContent.push(`ANTHROPIC_API_KEY=${apiKey}`);
     else if (provider === "google") envContent.push(`GOOGLE_API_KEY=${apiKey}`);
-    fs7.writeFileSync(path7.join(process.cwd(), ".env.local"), envContent.join("\n") + "\n");
+    fs8.writeFileSync(path8.join(process.cwd(), ".env.local"), envContent.join("\n") + "\n");
     success("Configuration saved to .env.local");
     info("Run `npx convex dev` to start the Convex backend.");
   });
@@ -1451,9 +1919,9 @@ function registerConfigCommand(program2) {
       error("API key is required.");
       process.exit(1);
     }
-    const envPath = path7.join(process.cwd(), ".env.local");
+    const envPath = path8.join(process.cwd(), ".env.local");
     let content = "";
-    if (fs7.existsSync(envPath)) content = fs7.readFileSync(envPath, "utf-8");
+    if (fs8.existsSync(envPath)) content = fs8.readFileSync(envPath, "utf-8");
     const lines = content.split("\n");
     const idx = lines.findIndex((l) => l.startsWith(`${keyName}=`));
     if (idx >= 0) lines[idx] = `${keyName}=${apiKey}`;
@@ -1461,7 +1929,7 @@ function registerConfigCommand(program2) {
     const provIdx = lines.findIndex((l) => l.startsWith("LLM_PROVIDER="));
     if (provIdx >= 0) lines[provIdx] = `LLM_PROVIDER=${provider}`;
     else lines.push(`LLM_PROVIDER=${provider}`);
-    fs7.writeFileSync(envPath, lines.join("\n"));
+    fs8.writeFileSync(envPath, lines.join("\n"));
     success(`Provider "${provider}" configured.`);
   });
 }
@@ -1824,19 +2292,19 @@ function registerKeysCommand(program2) {
 
 // src/commands/status.ts
 import { spawn as spawn2 } from "child_process";
-import path8 from "path";
-import fs8 from "fs-extra";
+import path9 from "path";
+import fs9 from "fs-extra";
 import readline9 from "readline";
 function registerStatusCommand(program2) {
   program2.command("status").description("Show system health and connection status").action(async () => {
     header("AgentForge Status");
     const cwd = process.cwd();
     const checks = {};
-    checks["Project Root"] = fs8.existsSync(path8.join(cwd, "package.json")) ? "\u2714 Found" : "\u2716 Not found";
-    checks["Convex Dir"] = fs8.existsSync(path8.join(cwd, "convex")) ? "\u2714 Found" : "\u2716 Not found";
-    checks["Skills Dir"] = fs8.existsSync(path8.join(cwd, "skills")) ? "\u2714 Found" : "\u2716 Not configured";
-    checks["Dashboard Dir"] = fs8.existsSync(path8.join(cwd, "dashboard")) ? "\u2714 Found" : "\u2716 Not found";
-    checks["Env Config"] = fs8.existsSync(path8.join(cwd, ".env.local")) || fs8.existsSync(path8.join(cwd, ".env")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Project Root"] = fs9.existsSync(path9.join(cwd, "package.json")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Convex Dir"] = fs9.existsSync(path9.join(cwd, "convex")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Skills Dir"] = fs9.existsSync(path9.join(cwd, "skills")) ? "\u2714 Found" : "\u2716 Not configured";
+    checks["Dashboard Dir"] = fs9.existsSync(path9.join(cwd, "dashboard")) ? "\u2714 Found" : "\u2716 Not found";
+    checks["Env Config"] = fs9.existsSync(path9.join(cwd, ".env.local")) || fs9.existsSync(path9.join(cwd, ".env")) ? "\u2714 Found" : "\u2716 Not found";
     try {
       const client = await createClient();
       const agents = await client.query("agents:list", {});
@@ -1847,9 +2315,9 @@ function registerStatusCommand(program2) {
     const envFiles = [".env.local", ".env"];
     let provider = "Not configured";
     for (const envFile of envFiles) {
-      const envPath = path8.join(cwd, envFile);
-      if (fs8.existsSync(envPath)) {
-        const content = fs8.readFileSync(envPath, "utf-8");
+      const envPath = path9.join(cwd, envFile);
+      if (fs9.existsSync(envPath)) {
+        const content = fs9.readFileSync(envPath, "utf-8");
         const match = content.match(/LLM_PROVIDER=(.+)/);
         if (match) {
           provider = match[1].trim();
@@ -1871,16 +2339,16 @@ function registerStatusCommand(program2) {
   program2.command("dashboard").description("Launch the web dashboard").option("-p, --port <port>", "Port for the dashboard", "3000").option("--install", "Install dashboard dependencies before starting").action(async (opts) => {
     const cwd = process.cwd();
     const searchPaths = [
-      path8.join(cwd, "dashboard"),
+      path9.join(cwd, "dashboard"),
       // 1. Bundled in project (agentforge create)
-      path8.join(cwd, "packages", "web"),
+      path9.join(cwd, "packages", "web"),
       // 2. Monorepo structure
-      path8.join(cwd, "node_modules", "@agentforge-ai", "web")
+      path9.join(cwd, "node_modules", "@agentforge-ai", "web")
       // 3. Installed as dependency
     ];
     let dashDir = "";
     for (const p of searchPaths) {
-      if (fs8.existsSync(path8.join(p, "package.json"))) {
+      if (fs9.existsSync(path9.join(p, "package.json"))) {
         dashDir = p;
         break;
       }
@@ -1902,10 +2370,10 @@ function registerStatusCommand(program2) {
       console.log();
       return;
     }
-    const nodeModulesExists = fs8.existsSync(path8.join(dashDir, "node_modules"));
+    const nodeModulesExists = fs9.existsSync(path9.join(dashDir, "node_modules"));
     if (!nodeModulesExists || opts.install) {
       header("AgentForge Dashboard \u2014 Installing Dependencies");
-      info(`Installing in ${path8.relative(cwd, dashDir) || "."}...`);
+      info(`Installing in ${path9.relative(cwd, dashDir) || "."}...`);
       console.log();
       const installChild = spawn2("pnpm", ["install"], {
         cwd: dashDir,
@@ -1923,15 +2391,15 @@ function registerStatusCommand(program2) {
       success("Dependencies installed.");
       console.log();
     }
-    const envPath = path8.join(cwd, ".env.local");
-    if (fs8.existsSync(envPath)) {
-      const envContent = fs8.readFileSync(envPath, "utf-8");
+    const envPath = path9.join(cwd, ".env.local");
+    if (fs9.existsSync(envPath)) {
+      const envContent = fs9.readFileSync(envPath, "utf-8");
       const convexUrlMatch = envContent.match(/CONVEX_URL=(.+)/);
       if (convexUrlMatch) {
-        const dashEnvPath = path8.join(dashDir, ".env.local");
+        const dashEnvPath = path9.join(dashDir, ".env.local");
         const dashEnvContent = `VITE_CONVEX_URL=${convexUrlMatch[1].trim()}
 `;
-        fs8.writeFileSync(dashEnvPath, dashEnvContent);
+        fs9.writeFileSync(dashEnvPath, dashEnvContent);
       }
     }
     header("AgentForge Dashboard");
@@ -2012,6 +2480,144 @@ function registerStatusCommand(program2) {
   });
 }
 
+// src/commands/login.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import prompts from "prompts";
+function registerLoginCommand(program2) {
+  program2.command("login").description("Authenticate with AgentForge Cloud").option("--api-key <key>", "API key for authentication (skips browser flow)").option("--cloud-url <url>", "Custom AgentForge Cloud URL").action(async (options) => {
+    header("AgentForge Cloud Login");
+    const existingCreds = await readCredentials();
+    if (existingCreds?.apiKey) {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: "You are already logged in. Overwrite existing credentials?",
+        initial: false
+      });
+      if (!overwrite) {
+        info("Login cancelled.");
+        return;
+      }
+    }
+    let apiKey;
+    let cloudUrl;
+    if (options.apiKey) {
+      apiKey = options.apiKey;
+      cloudUrl = options.cloudUrl || process.env.AGENTFORGE_CLOUD_URL || "https://cloud.agentforge.ai";
+    } else {
+      const { method } = await prompts({
+        type: "select",
+        name: "method",
+        message: "How would you like to authenticate?",
+        choices: [
+          { title: "Enter API key manually", value: "api-key" },
+          { title: "Browser (OAuth - coming soon)", value: "browser", disabled: true }
+        ]
+      });
+      if (method === "api-key") {
+        const response = await prompts({
+          type: "password",
+          name: "key",
+          message: "Enter your AgentForge API key:",
+          validate: (value) => value.length > 0 ? true : "API key is required"
+        });
+        apiKey = response.key;
+      } else {
+        error("Browser authentication not yet implemented. Use --api-key flag.");
+        process.exit(1);
+      }
+      cloudUrl = options.cloudUrl || process.env.AGENTFORGE_CLOUD_URL || "https://cloud.agentforge.ai";
+    }
+    const spinner = ora2("Authenticating with AgentForge Cloud...").start();
+    try {
+      const client = new CloudClient(cloudUrl, apiKey);
+      const user = await client.authenticate();
+      await writeCredentials({
+        apiKey,
+        cloudUrl,
+        userEmail: user.email,
+        userName: user.name
+      });
+      spinner.succeed("Authentication successful!");
+      success(`Logged in as ${chalk2.bold(user.email)}`);
+      info(`Cloud URL: ${cloudUrl}`);
+      info(`Credentials stored at: ${getCredentialsPath()}`);
+    } catch (err) {
+      spinner.fail("Authentication failed");
+      if (err instanceof CloudClientError) {
+        error(err.message);
+        if (err.code === "NETWORK_ERROR") {
+          info("Check your internet connection and try again.");
+        } else if (err.status === 401) {
+          info("Your API key appears to be invalid. Please check and try again.");
+        }
+      } else {
+        error(`Unexpected error: ${err.message || err}`);
+      }
+      process.exit(1);
+    }
+  });
+  program2.command("logout").description("Clear AgentForge Cloud credentials").action(async () => {
+    header("AgentForge Cloud Logout");
+    const wasLoggedIn = await isAuthenticated();
+    if (!wasLoggedIn) {
+      info("You are not currently logged in.");
+      return;
+    }
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: "Are you sure you want to log out?",
+      initial: true
+    });
+    if (!confirm) {
+      info("Logout cancelled.");
+      return;
+    }
+    const deleted = await deleteCredentials();
+    if (deleted) {
+      success("Logged out successfully.");
+      info("Your credentials have been removed.");
+    } else {
+      error("Failed to remove credentials.");
+      process.exit(1);
+    }
+  });
+  program2.command("whoami").description("Show current user information").action(async () => {
+    header("Current User");
+    const creds = await readCredentials();
+    const cloudUrl = await getCloudUrl();
+    if (!creds?.apiKey) {
+      info("You are not logged in.");
+      info('Run "agentforge login" to authenticate.');
+      return;
+    }
+    details({
+      "Cloud URL": cloudUrl,
+      "Email": creds.userEmail || "Unknown",
+      "Name": creds.userName || "Unknown",
+      "Credentials File": getCredentialsPath()
+    });
+    const spinner = ora2("Validating session...").start();
+    try {
+      const client = new CloudClient(creds.cloudUrl, creds.apiKey);
+      const user = await client.authenticate();
+      spinner.succeed("Session is valid");
+      success(`Authenticated as ${chalk2.bold(user.email)}`);
+    } catch (err) {
+      spinner.fail("Session validation failed");
+      if (err instanceof CloudClientError && err.status === 401) {
+        error("Your session has expired or the API key is invalid.");
+        info('Run "agentforge login" to re-authenticate.');
+      } else {
+        error(`Error: ${err.message || err}`);
+        info("Your credentials are stored but the server could not be reached.");
+      }
+    }
+  });
+}
+
 // src/index.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -2027,9 +2633,10 @@ program.command("create").argument("<project-name>", "Name of the project to cre
 program.command("run").description("Start the local development environment").option("-p, --port <port>", "Port for the dev server", "3000").action(async (options) => {
   await runProject(options);
 });
-program.command("deploy").description("Deploy the Convex backend to production").option("--env <path>", "Path to environment file", ".env.production").option("--dry-run", "Preview deployment without executing", false).option("--rollback", "Rollback to previous deployment", false).option("--force", "Skip confirmation prompts", false).action(async (options) => {
+program.command("deploy").description("Deploy the project to production").option("--env <path>", "Path to environment file", ".env.production").option("--dry-run", "Preview deployment without executing", false).option("--rollback", "Rollback to previous deployment", false).option("--force", "Skip confirmation prompts", false).option("--provider <provider>", "Deployment provider (convex or cloud)", "convex").option("--project <projectId>", "Project ID for cloud deployments").option("--version <tag>", "Version tag for the deployment").action(async (options) => {
   await deployProject(options);
 });
+registerLoginCommand(program);
 registerAgentsCommand(program);
 registerChatCommand(program);
 registerSessionsCommand(program);