microfox 1.0.11

package/dist/cli.js

@@ -0,0 +1,1154 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander8 = require("commander");
+
+// src/commands/kickstart.ts
+var import_commander = require("commander");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_readline_sync = __toESM(require("readline-sync"));
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/utils/getProjectRoot.ts
+var getWorkingDirectory = () => {
+  return process.cwd();
+};
+
+// src/utils/npmChecker.ts
+async function isPackageNameAvailable(packageName) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return false;
+    }
+    if (response.status === 404) {
+      return true;
+    }
+    console.warn(
+      `Warning: Unexpected status ${response.status} when checking npm availability for ${packageName}. Proceeding with caution.`
+    );
+    return false;
+  } catch (error) {
+    if (error.name === "AbortError") {
+      console.warn(
+        `Warning: Timeout when checking npm availability for ${packageName}. Proceeding with caution.`
+      );
+    } else {
+      console.warn(
+        `Warning: Could not check npm availability for ${packageName}. Proceeding with caution.`
+      );
+    }
+    return false;
+  }
+}
+async function checkPackageNameAndPrompt(packageName) {
+  const readlineSync3 = require("readline-sync");
+  let currentName = (packageName == null ? void 0 : packageName.startsWith("@microfox/")) ? packageName : `@microfox/${packageName}`;
+  while (true) {
+    console.log(`\u{1F50D} Checking npm availability for "${currentName}"...`);
+    const isAvailable = await isPackageNameAvailable(currentName);
+    if (isAvailable) {
+      console.log(`\u2705 Package name "${currentName}" is available on npm!`);
+      return currentName;
+    } else {
+      console.log(`\u274C Package name "${currentName}" is already taken on npm.`);
+      const newName = readlineSync3.question(
+        "Please enter a new package name: "
+      );
+      if (!newName || newName.trim() === "") {
+        console.log("\u274C Invalid package name. Please try again.");
+        continue;
+      }
+      currentName = newName.trim();
+    }
+  }
+}
+
+// src/commands/kickstart.ts
+async function createAgentProject(agentName) {
+  const workingDir = getWorkingDirectory();
+  const agentDir = import_path.default.join(workingDir, agentName);
+  if (import_fs.default.existsSync(agentDir)) {
+    throw new Error(`Directory already exists at ${agentDir}`);
+  }
+  console.log(
+    import_chalk.default.blue(
+      `\u{1F680} Creating agent ${import_chalk.default.bold(agentName)} at ${agentDir}
+`
+    )
+  );
+  import_fs.default.mkdirSync(agentDir, { recursive: true });
+  const templatePath = import_path.default.resolve(__dirname, "agent-template.txt");
+  const templateContent = import_fs.default.readFileSync(templatePath, "utf-8");
+  const fileSections = templateContent.split("--- filename: ").slice(1);
+  for (const section of fileSections) {
+    const lines = section.split("\n");
+    const filePath = lines.shift().trim();
+    const content = lines.join("\n").replace(/<%= agentName %>/g, agentName);
+    const destPath = import_path.default.join(agentDir, filePath);
+    const destDir = import_path.default.dirname(destPath);
+    if (!import_fs.default.existsSync(destDir)) {
+      import_fs.default.mkdirSync(destDir, { recursive: true });
+    }
+    import_fs.default.writeFileSync(destPath, content);
+    console.log(import_chalk.default.green(`\u2705 Created ${filePath}`));
+  }
+}
+async function createPackageProject(packageName) {
+  const simpleName = packageName.includes("/") ? packageName.split("/")[1] : packageName;
+  const titleName = simpleName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const description = `A TypeScript SDK for ${titleName}.`;
+  const className = simpleName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("") + "Sdk";
+  const workingDir = getWorkingDirectory();
+  const packageDir = import_path.default.join(workingDir, simpleName);
+  if (import_fs.default.existsSync(packageDir)) {
+    throw new Error(`Directory already exists at ${packageDir}`);
+  }
+  console.log(
+    import_chalk.default.blue(
+      `\u{1F680} Creating package ${import_chalk.default.bold(packageName)} at ${packageDir}
+`
+    )
+  );
+  import_fs.default.mkdirSync(packageDir, { recursive: true });
+  const templatePath = import_path.default.resolve(__dirname, "package-template.txt");
+  const templateContent = import_fs.default.readFileSync(templatePath, "utf-8");
+  const fileSections = templateContent.split("--- filename: ").slice(1);
+  for (const section of fileSections) {
+    const lines = section.split("\n");
+    const filePath = lines.shift().trim().replace(/<%= simpleName %>/g, simpleName);
+    let content = lines.join("\n");
+    content = content.replace(/<%= packageName %>/g, packageName);
+    content = content.replace(/<%= simpleName %>/g, simpleName);
+    content = content.replace(/<%= titleName %>/g, titleName);
+    content = content.replace(/<%= description %>/g, description);
+    content = content.replace(/<%= className %>/g, className);
+    const destPath = import_path.default.join(packageDir, filePath);
+    const destDir = import_path.default.dirname(destPath);
+    if (!import_fs.default.existsSync(destDir)) {
+      import_fs.default.mkdirSync(destDir, { recursive: true });
+    }
+    import_fs.default.writeFileSync(destPath, content);
+    console.log(import_chalk.default.green(`\u2705 Created ${filePath}`));
+  }
+  const docsDir = import_path.default.join(packageDir, "docs");
+  const docsConstructors = import_path.default.join(docsDir, "constructors");
+  const docsFunctions = import_path.default.join(docsDir, "functions");
+  import_fs.default.mkdirSync(docsDir, { recursive: true });
+  import_fs.default.mkdirSync(docsConstructors, { recursive: true });
+  import_fs.default.mkdirSync(docsFunctions, { recursive: true });
+}
+async function createBackgroundAgentProject(agentName) {
+  const workingDir = getWorkingDirectory();
+  const agentDir = import_path.default.join(workingDir, agentName);
+  if (import_fs.default.existsSync(agentDir)) {
+    throw new Error(`Directory already exists at ${agentDir}`);
+  }
+  console.log(
+    import_chalk.default.blue(
+      `\u{1F680} Creating background agent ${import_chalk.default.bold(agentName)} at ${agentDir}
+`
+    )
+  );
+  import_fs.default.mkdirSync(agentDir, { recursive: true });
+  const templateDir = import_path.default.resolve(__dirname, "background-agent");
+  const copyTemplates = (src, dest) => {
+    const entries = import_fs.default.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = import_path.default.join(src, entry.name);
+      const destPath = import_path.default.join(dest, entry.name.replace(/\.txt$/, ""));
+      if (entry.isDirectory()) {
+        import_fs.default.mkdirSync(destPath, { recursive: true });
+        copyTemplates(srcPath, destPath);
+      } else if (entry.name.endsWith(".txt")) {
+        const templateContent = import_fs.default.readFileSync(srcPath, "utf-8");
+        const content = templateContent.replace(/<%= agentName %>/g, agentName);
+        import_fs.default.writeFileSync(destPath, content);
+        console.log(import_chalk.default.green(`\u2705 Created ${import_path.default.relative(agentDir, destPath)}`));
+      }
+    }
+  };
+  copyTemplates(templateDir, agentDir);
+}
+async function kickstartAction() {
+  console.log(import_chalk.default.cyan("\u{1F680} Let's kickstart your new project!\n"));
+  const { boilerplateType } = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "boilerplateType",
+      message: "Select boilerplate type:",
+      choices: ["package", "agent"]
+    }
+  ]);
+  if (!boilerplateType) {
+    console.log(import_chalk.default.yellow("Operation cancelled."));
+    return;
+  }
+  if (boilerplateType === "agent") {
+    const { agentType } = await import_inquirer.default.prompt([
+      {
+        type: "list",
+        name: "agentType",
+        message: "Select agent type:",
+        choices: ["plain", "background"]
+      }
+    ]);
+    if (agentType === "plain") {
+      const agentName = import_readline_sync.default.question(
+        import_chalk.default.yellow("\u{1F4E6} Enter agent name: ")
+      );
+      if (!agentName.trim()) {
+        throw new Error("Agent name cannot be empty");
+      }
+      await createAgentProject(agentName.trim());
+      console.log(
+        import_chalk.default.green(
+          `
+\u{1F389} Successfully created agent ${import_chalk.default.bold(agentName)}!`
+        )
+      );
+      console.log(import_chalk.default.gray(`\u{1F4CD} Located at ${import_path.default.join(getWorkingDirectory(), agentName)}`));
+      console.log(import_chalk.default.yellow("\n\u{1F4A1} Next steps:"));
+      console.log(import_chalk.default.yellow(`   1. cd ${agentName}`));
+      console.log(import_chalk.default.yellow("   2. npm install"));
+      console.log(import_chalk.default.yellow("   3. Configure your env.json"));
+      console.log(import_chalk.default.yellow("   4. npm run dev"));
+      console.log(import_chalk.default.yellow("   5. Start developing your agent!"));
+    } else if (agentType === "background") {
+      const agentName = import_readline_sync.default.question(
+        import_chalk.default.yellow("\u{1F4E6} Enter agent name: ")
+      );
+      if (!agentName.trim()) {
+        throw new Error("Agent name cannot be empty");
+      }
+      await createBackgroundAgentProject(agentName.trim());
+      console.log(
+        import_chalk.default.green(
+          `
+\u{1F389} Successfully created background agent ${import_chalk.default.bold(agentName)}!`
+        )
+      );
+      console.log(import_chalk.default.gray(`\u{1F4CD} Located at ${import_path.default.join(getWorkingDirectory(), agentName)}`));
+      console.log(import_chalk.default.yellow("\n\u{1F4A1} Next steps:"));
+      console.log(import_chalk.default.yellow(`   1. cd ${agentName}`));
+      console.log(import_chalk.default.yellow("   2. npm install"));
+      console.log(import_chalk.default.yellow("   3. Configure your env.json"));
+      console.log(import_chalk.default.yellow("   4. npm run dev"));
+      console.log(import_chalk.default.yellow("   5. Start developing your agent!"));
+    }
+  } else if (boilerplateType === "package") {
+    const packageName = import_readline_sync.default.question(
+      import_chalk.default.yellow("\u{1F4E6} Enter package name: ")
+    );
+    if (!packageName.trim()) {
+      throw new Error("Package name cannot be empty");
+    }
+    const finalPackageName = await checkPackageNameAndPrompt(`@microfox/${packageName.trim()}`);
+    await createPackageProject(finalPackageName);
+    const simpleName = finalPackageName.includes("/") ? finalPackageName.split("/")[1] : finalPackageName;
+    console.log(
+      import_chalk.default.green(
+        `
+\u{1F389} Successfully created package ${import_chalk.default.bold(finalPackageName)}!`
+      )
+    );
+    console.log(import_chalk.default.gray(`\u{1F4CD} Located at ${import_path.default.join(getWorkingDirectory(), simpleName)}`));
+    console.log(import_chalk.default.yellow("\n\u{1F4A1} Next steps:"));
+    console.log(import_chalk.default.yellow(`   1. cd ${simpleName}`));
+    console.log(import_chalk.default.yellow("   2. npm install"));
+    console.log(import_chalk.default.yellow("   3. npm run build"));
+    console.log(import_chalk.default.yellow("   4. npm test"));
+    console.log(import_chalk.default.yellow("   5. Start developing your SDK!"));
+    console.log(
+      import_chalk.default.gray(
+        `
+\u{1F4DA} Your package is ready to be published to npm as "${finalPackageName}"`
+      )
+    );
+  } else {
+    console.log(import_chalk.default.red('Invalid boilerplate type selected. Please choose "package" or "agent".'));
+  }
+}
+var kickstartCommand = new import_commander.Command("kickstart").description("Kickstart a new TypeScript SDK or agent package").action(async () => {
+  try {
+    console.log(import_chalk.default.blue("\u{1F680} Package Kickstarter\n"));
+    await kickstartAction();
+  } catch (error) {
+    console.error(import_chalk.default.red("\u274C Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/add.ts
+var import_commander2 = require("commander");
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_readline_sync2 = __toESM(require("readline-sync"));
+async function addBackgroundAgentFunctions(name) {
+  const workingDir = getWorkingDirectory();
+  const functionsDir = import_path2.default.join(workingDir, "src", "functions", name);
+  console.log(
+    import_chalk2.default.blue(
+      `\u{1F680} Adding background agent functions ${import_chalk2.default.bold(name)} at ${functionsDir}
+`
+    )
+  );
+  import_fs2.default.mkdirSync(functionsDir, { recursive: true });
+  const templateDir = import_path2.default.resolve(__dirname, "background-agent", "src", "functions");
+  const entries = import_fs2.default.readdirSync(templateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_path2.default.join(templateDir, entry.name);
+    const destPath = import_path2.default.join(functionsDir, entry.name.replace(/\.txt$/, ""));
+    if (!entry.isDirectory() && entry.name.endsWith(".txt")) {
+      const templateContent = import_fs2.default.readFileSync(srcPath, "utf-8");
+      const content = templateContent.replace(/<%= agentName %>/g, name);
+      import_fs2.default.writeFileSync(destPath, content);
+      console.log(import_chalk2.default.green(`\u2705 Created ${import_path2.default.relative(workingDir, destPath)}`));
+    }
+  }
+}
+async function addAction() {
+  console.log(import_chalk2.default.cyan("\u2728 Add new features to your project!\n"));
+  const workingDir = getWorkingDirectory();
+  const microfoxConfigPath = import_path2.default.join(workingDir, "microfox.json");
+  if (!import_fs2.default.existsSync(microfoxConfigPath)) {
+    console.log(import_chalk2.default.red("Error: `microfox.json` not found in the current directory."));
+    console.log(import_chalk2.default.red("Please run this command from the root of a Microfox project."));
+    return;
+  }
+  const { featureType } = await import_inquirer2.default.prompt([
+    {
+      type: "list",
+      name: "featureType",
+      message: "Select what you want to add:",
+      choices: ["background_agent_functions"]
+    }
+  ]);
+  if (!featureType) {
+    console.log(import_chalk2.default.yellow("Operation cancelled."));
+    return;
+  }
+  if (featureType === "background_agent_functions") {
+    const functionName = import_readline_sync2.default.question(
+      import_chalk2.default.yellow("\u{1F4E6} Enter a name for the new functions: ")
+    );
+    if (!functionName.trim()) {
+      throw new Error("Function name cannot be empty");
+    }
+    await addBackgroundAgentFunctions(functionName.trim());
+    console.log(
+      import_chalk2.default.green(
+        `
+\u{1F389} Successfully added background agent functions ${import_chalk2.default.bold(functionName)}!`
+      )
+    );
+    console.log(import_chalk2.default.gray(`\u{1F4CD} Located at src/functions/${functionName.trim()}`));
+    console.log(import_chalk2.default.yellow("\n\u{1F4A1} Next steps:"));
+    console.log(import_chalk2.default.yellow("   1. Check the new files in src/functions/"));
+    console.log(import_chalk2.default.yellow("   2. Update your agent logic to use the new functions."));
+  }
+}
+var addCommand = new import_commander2.Command("add").description("Add features to a Microfox project").action(async () => {
+  try {
+    await addAction();
+  } catch (error) {
+    console.error(import_chalk2.default.red("\u274C Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/push.ts
+var import_commander3 = require("commander");
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_axios = __toESM(require("axios"));
+var import_micromatch = __toESM(require("micromatch"));
+var API_ENDPOINT = "https://staging-cicd.microfox.app/api/deployments/new-agent-cli";
+var getDirectoryFiles = (dir, basePath = "", ignorePatterns) => {
+  const structure = [];
+  const items = import_fs3.default.readdirSync(dir, { withFileTypes: true });
+  for (const item of items) {
+    const relativePath = import_path3.default.join(basePath, item.name);
+    if (import_micromatch.default.isMatch(relativePath, ignorePatterns)) {
+      continue;
+    }
+    if (item.isDirectory()) {
+      structure.push(...getDirectoryFiles(import_path3.default.join(dir, item.name), relativePath, ignorePatterns));
+    } else {
+      structure.push({
+        type: "file",
+        name: item.name,
+        path: relativePath.replace(/\\/g, "/"),
+        content: import_fs3.default.readFileSync(import_path3.default.join(dir, item.name), "utf-8")
+      });
+    }
+  }
+  return structure;
+};
+async function pushAction() {
+  const cwd = process.cwd();
+  const microfoxConfigPath = import_path3.default.join(cwd, "microfox.json");
+  if (!import_fs3.default.existsSync(microfoxConfigPath)) {
+    console.error(import_chalk3.default.red("\u274C Error: `microfox.json` not found in the current directory."));
+    console.log(import_chalk3.default.yellow("This command must be run from the root of an agent project."));
+    process.exit(1);
+  }
+  console.log(import_chalk3.default.cyan("\u{1F680} Pushing your agent to Microfox..."));
+  const microfoxConfig = JSON.parse(import_fs3.default.readFileSync(microfoxConfigPath, "utf-8"));
+  let agentApiKey;
+  const envPath = import_path3.default.join(cwd, "env.json");
+  if (import_fs3.default.existsSync(envPath)) {
+    try {
+      const envConfig = JSON.parse(import_fs3.default.readFileSync(envPath, "utf-8"));
+      agentApiKey = envConfig.AGENT_API_KEY;
+    } catch (e) {
+      console.warn(import_chalk3.default.yellow("\u26A0\uFE0F  Could not read or parse `env.json`. The AGENT_API_KEY will not be sent."));
+    }
+  }
+  const stage = microfoxConfig.stage || "prod";
+  const ignored = microfoxConfig.ignored || [];
+  const defaultIgnore = ["node_modules/**", ".git/**", "dist/**", ".build/**", ".serverless/**", ".DS_Store", "package-lock.json", "pnpm-lock.yaml"];
+  const allIgnored = [...defaultIgnore, ...ignored];
+  const files = getDirectoryFiles(cwd, "", allIgnored);
+  try {
+    console.log(import_chalk3.default.blue("\u{1F4E6} Bundling and deploying your agent..."));
+    const response = await import_axios.default.post(
+      API_ENDPOINT,
+      {
+        stage,
+        isLocal: false,
+        dir: files
+      },
+      {
+        headers: {
+          "x-agent-api-key": agentApiKey
+        }
+      }
+    );
+    if (response.status === 200) {
+      console.log(import_chalk3.default.green("\u2705 Deployment successful!"));
+      console.log(import_chalk3.default.green(`   Run ID: ${response.data.runId}`));
+      console.log(import_chalk3.default.green(`   Message: ${response.data.message}`));
+    } else {
+      console.error(import_chalk3.default.red(`\u274C Deployment failed with status: ${response.status}`));
+      console.error(response.data);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(import_chalk3.default.red("\u274C An error occurred during deployment:"));
+    if (import_axios.default.isAxiosError(error) && error.response) {
+      console.error(import_chalk3.default.red(`   Status: ${error.response.status}`));
+      console.error(import_chalk3.default.red(`   Data: ${JSON.stringify(error.response.data, null, 2)}`));
+    } else {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+var pushCommand = new import_commander3.Command("push").description("Deploy your agent to the Microfox platform").action(async () => {
+  try {
+    await pushAction();
+  } catch (error) {
+    console.error(import_chalk3.default.red("\u274C Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/status.ts
+var import_commander4 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_axios2 = __toESM(require("axios"));
+var import_inquirer3 = __toESM(require("inquirer"));
+var API_BASE_URL = "https://staging-cicd.microfox.app/api/deployment-status/agent/status/";
+async function getRunId(runId) {
+  if (runId) {
+    return runId;
+  }
+  const { promptedRunId } = await import_inquirer3.default.prompt([
+    {
+      type: "input",
+      name: "promptedRunId",
+      message: "Please enter the deployment Run ID:",
+      validate: (input) => !!input || "Run ID cannot be empty."
+    }
+  ]);
+  return promptedRunId;
+}
+async function getDeploymentData(runId) {
+  var _a;
+  try {
+    const response = await import_axios2.default.get(`${API_BASE_URL}${runId}`);
+    return response.data;
+  } catch (error) {
+    if (import_axios2.default.isAxiosError(error) && ((_a = error.response) == null ? void 0 : _a.status) === 404) {
+      console.error(import_chalk4.default.red(`\u274C Error: Deployment with Run ID "${runId}" not found.`));
+    } else {
+      console.error(import_chalk4.default.red("\u274C An error occurred while fetching deployment status:"));
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+async function statusAction(runId) {
+  const finalRunId = await getRunId(runId);
+  const data = await getDeploymentData(finalRunId);
+  const deployment = data.data.deployment;
+  console.log(import_chalk4.default.cyan.bold("\u{1F680} Deployment Status"));
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+  console.log(`${import_chalk4.default.bold("Run ID:")}      ${deployment.sha}`);
+  console.log(`${import_chalk4.default.bold("Status:")}      ${import_chalk4.default.green(deployment.status)}`);
+  console.log(`${import_chalk4.default.bold("Description:")} ${deployment.statusDescription}`);
+  console.log(`${import_chalk4.default.bold("Stage:")}       ${deployment.stage}`);
+  console.log(`${import_chalk4.default.bold("Start Time:")}  ${deployment.startTime ? new Date(deployment.startTime).toLocaleString() : "N/A"}`);
+  console.log(`${import_chalk4.default.bold("End Time:")}    ${deployment.endTime ? new Date(deployment.endTime).toLocaleString() : "N/A"}`);
+  console.log(`${import_chalk4.default.bold("Base URL:")}    ${deployment.baseUrl ? import_chalk4.default.underline.blue(deployment.baseUrl) : "N/A"}`);
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+}
+async function logsAction(runId) {
+  const finalRunId = await getRunId(runId);
+  const data = await getDeploymentData(finalRunId);
+  const logs = data.data.deploymentLogs;
+  console.log(import_chalk4.default.cyan.bold("\u{1F4DC} Deployment Logs"));
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+  console.log(logs);
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+}
+async function metricsAction(runId) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D;
+  const finalRunId = await getRunId(runId);
+  const data = await getDeploymentData(finalRunId);
+  const metrics = data.data.deployment.metrics;
+  console.log(import_chalk4.default.cyan.bold("\u{1F4CA} Deployment Metrics"));
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+  console.log(import_chalk4.default.bold.underline("System"));
+  console.log(`  Platform:    ${metrics.system.platform}`);
+  console.log(`  Architecture:  ${metrics.system.arch}`);
+  console.log(`  Node Version:  ${metrics.system.nodeVersion}`);
+  console.log(import_chalk4.default.bold.underline("\nTiming (ms)"));
+  for (const [step, duration] of Object.entries(((_a = metrics == null ? void 0 : metrics.timing) == null ? void 0 : _a.stepDurations) || {})) {
+    console.log(`  ${step}:`.padEnd(15) + `${duration ? `${duration}ms` : "N/A"}`);
+  }
+  console.log(`  Total Duration:`.padEnd(15) + `${((_b = metrics == null ? void 0 : metrics.timing) == null ? void 0 : _b.totalDuration) ? `${metrics.timing.totalDuration}ms` : "N/A"}`);
+  console.log(import_chalk4.default.bold.underline("\nResources"));
+  console.log(import_chalk4.default.bold("  CPU:"));
+  console.log(`    Peak:        ${((_d = (_c = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _c.cpu) == null ? void 0 : _d.peak) ? `${(_f = (_e = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _e.cpu) == null ? void 0 : _f.peak}${(_h = (_g = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _g.cpu) == null ? void 0 : _h.usageUnits}` : "N/A"}`);
+  console.log(`    Average:     ${((_j = (_i = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _i.cpu) == null ? void 0 : _j.average) ? `${(_l = (_k = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _k.cpu) == null ? void 0 : _l.average}${(_n = (_m = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _m.cpu) == null ? void 0 : _n.usageUnits}` : "N/A"}`);
+  console.log(import_chalk4.default.bold("  Memory:"));
+  console.log(`    Peak:        ${((_p = (_o = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _o.memory) == null ? void 0 : _p.peak) ? `${(_r = (_q = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _q.memory) == null ? void 0 : _r.peak.toFixed(2)}${(_t = (_s = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _s.memory) == null ? void 0 : _t.usageUnits}` : "N/A"}`);
+  console.log(`    Average:     ${((_v = (_u = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _u.memory) == null ? void 0 : _v.average) ? `${(_x = (_w = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _w.memory) == null ? void 0 : _x.average.toFixed(2)}${(_z = (_y = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _y.memory) == null ? void 0 : _z.usageUnits}` : "N/A"}`);
+  console.log(import_chalk4.default.bold("  Disk:"));
+  console.log(`    Final Size:  ${((_B = (_A = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _A.diskSize) == null ? void 0 : _B.final) ? `${(((_D = (_C = metrics == null ? void 0 : metrics.resources) == null ? void 0 : _C.diskSize) == null ? void 0 : _D.final) / (1024 * 1024)).toFixed(2)} MB` : "N/A"}`);
+  console.log(import_chalk4.default.gray("----------------------------------------"));
+}
+var statusCommand = new import_commander4.Command("status").description("Check the deployment status of your agent").argument("[runId]", "The deployment Run ID").action(async (runId) => {
+  try {
+    await statusAction(runId);
+  } catch (error) {
+  }
+});
+var logsCommand = new import_commander4.Command("logs").description("View the deployment logs for your agent").argument("[runId]", "The deployment Run ID").action(async (runId) => {
+  try {
+    await logsAction(runId);
+  } catch (error) {
+  }
+});
+var metricsCommand = new import_commander4.Command("metrics").description("View the deployment metrics for your agent").argument("[runId]", "The deployment Run ID").action(async (runId) => {
+  try {
+    await metricsAction(runId);
+  } catch (error) {
+  }
+});
+
+// src/commands/code.ts
+var import_commander5 = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
+var import_axios3 = __toESM(require("axios"));
+var import_child_process = require("child_process");
+
+// src/utils/findProjectRoot.ts
+var import_path4 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
+async function findProjectRoot(startPath = process.cwd()) {
+  let currentPath = startPath;
+  let count = 0;
+  while (true) {
+    const microfoxRootPath = import_path4.default.join(currentPath, "microfox-root");
+    if (import_fs4.default.existsSync(microfoxRootPath)) {
+      return currentPath;
+    }
+    const parentPath = import_path4.default.dirname(currentPath);
+    if (parentPath === currentPath || count > 10) {
+      return null;
+    }
+    currentPath = parentPath;
+  }
+}
+
+// src/commands/code.ts
+var import_path5 = __toESM(require("path"));
+var import_readline = __toESM(require("readline"));
+var NEXTJS_PORT = 3e3;
+var API_URL = `http://localhost:${NEXTJS_PORT}/api/agent`;
+var createLogger = (rl) => {
+  return (source, message, color) => {
+    import_readline.default.cursorTo(process.stdout, 0);
+    import_readline.default.clearLine(process.stdout, 0);
+    const prefix = color(`[${source}]`);
+    const lines = message.trim().split("\n");
+    for (const line of lines) {
+      console.log(`${prefix} ${line}`);
+    }
+    rl.prompt(true);
+  };
+};
+async function codeAction() {
+  var _a, _b;
+  let childProcess = null;
+  const killProcess = () => {
+    if (childProcess && childProcess.pid) {
+      console.log(import_chalk5.default.yellow("\nGracefully shutting down..."));
+      if (process.platform === "win32") {
+        (0, import_child_process.spawn)("taskkill", ["/pid", childProcess.pid.toString(), "/f", "/t"]);
+      } else {
+        childProcess.kill("SIGINT");
+      }
+      childProcess = null;
+    }
+  };
+  process.on("SIGINT", () => {
+    killProcess();
+    process.exit(0);
+  });
+  process.on("exit", killProcess);
+  try {
+    const projectRoot = await findProjectRoot();
+    if (!projectRoot) {
+      console.error(
+        import_chalk5.default.red("Error: Could not find project root. Make sure you are inside a Microfox project.")
+      );
+      process.exit(1);
+    }
+    const codeAppPath = import_path5.default.join(projectRoot, "apps", "code");
+    console.log(import_chalk5.default.cyan(`Starting Next.js server in ${codeAppPath}...`));
+    childProcess = (0, import_child_process.spawn)("npm", ["run", "dev"], {
+      cwd: codeAppPath,
+      shell: true,
+      env: { ...process.env, FORCE_COLOR: "true" }
+    });
+    const rl = import_readline.default.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: import_chalk5.default.cyan("> ")
+    });
+    const log3 = createLogger(rl);
+    let serverReady = false;
+    const onServerData = (data) => {
+      const output = data.toString();
+      if (!serverReady) {
+        process.stdout.write(output);
+        if (output.toLowerCase().includes("ready in") || output.toLowerCase().includes("compiled successfully")) {
+          serverReady = true;
+          console.log(import_chalk5.default.green("\nServer is ready. You can now type your queries."));
+          rl.prompt();
+        }
+      } else {
+        log3("nextjs", output, import_chalk5.default.gray);
+      }
+    };
+    (_a = childProcess.stdout) == null ? void 0 : _a.on("data", onServerData);
+    (_b = childProcess.stderr) == null ? void 0 : _b.on("data", onServerData);
+    childProcess.on("exit", (code) => {
+      log3("system", `Next.js process exited with code ${code}`, import_chalk5.default.red);
+      process.exit(code != null ? code : 1);
+    });
+    rl.on("line", async (line) => {
+      const query = line.trim();
+      if (!serverReady) {
+        log3("system", "Server is not ready yet, please wait.", import_chalk5.default.yellow);
+        rl.prompt();
+        return;
+      }
+      if (query.toLowerCase() === "exit") {
+        rl.close();
+      }
+      if (query) {
+        try {
+          const response = await import_axios3.default.post(API_URL, { prompt: query });
+          const responseData = typeof response.data === "object" ? JSON.stringify(response.data, null, 2) : response.data;
+          log3("agent", responseData, import_chalk5.default.green);
+        } catch (error) {
+          if (import_axios3.default.isAxiosError(error)) {
+            log3("agent", `Error: ${error.message}`, import_chalk5.default.red);
+          } else if (error instanceof Error) {
+            log3("agent", `An unknown error occurred: ${error.message}`, import_chalk5.default.red);
+          }
+        }
+      }
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      killProcess();
+      process.exit(0);
+    });
+  } catch (error) {
+    killProcess();
+    if (error instanceof Error) {
+      console.error(import_chalk5.default.red(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+var codeCommand = new import_commander5.Command("code").description("Run the code agent for your project").action(async () => {
+  try {
+    await codeAction();
+  } catch (error) {
+    console.error(import_chalk5.default.red("\u274C Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/install.ts
+var import_commander6 = require("commander");
+
+// src/utils/experimental-installer.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var import_chalk6 = __toESM(require("chalk"));
+var CWD_PACKAGE_JSON = import_path6.default.join(process.cwd(), "package.json");
+var CWD_NODE_MODULES = import_path6.default.join(process.cwd(), "node_modules");
+var MICROFOX_NODE_MODULES;
+function log(message, isError = false, isWarning = false) {
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  let prefix;
+  if (isError) {
+    prefix = import_chalk6.default.red(`\u274C [install-microfox ${timestamp}]`);
+  } else if (isWarning) {
+    prefix = import_chalk6.default.yellow(`\u26A0\uFE0F  [install-microfox ${timestamp}]`);
+  } else {
+    prefix = import_chalk6.default.blue(`\u2139\uFE0F  [install-microfox ${timestamp}]`);
+  }
+  console.log(`${prefix} ${message}`);
+}
+function logSuccess(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  console.log(import_chalk6.default.green(`\u2705 [install-microfox ${timestamp}] ${message}`));
+}
+function logSection(title) {
+  console.log("\n" + "=".repeat(60));
+  console.log(`  ${title}`);
+  console.log("=".repeat(60));
+}
+function findSourceDir(targetDirName) {
+  let currentDir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const gitDir = import_path6.default.join(currentDir, ".git");
+    if (import_fs5.default.existsSync(gitDir)) {
+      const parentDir = import_path6.default.dirname(currentDir);
+      const microfoxDir = import_path6.default.join(parentDir, targetDirName);
+      if (import_fs5.default.existsSync(microfoxDir)) {
+        return microfoxDir;
+      }
+    }
+    const parent = import_path6.default.dirname(currentDir);
+    if (parent === currentDir) {
+      break;
+    }
+    currentDir = parent;
+  }
+  return null;
+}
+function copyDirectory(src, dest) {
+  try {
+    const normalizedSrc = import_path6.default.resolve(src);
+    const normalizedDest = import_path6.default.resolve(dest);
+    log(`Copying from: ${normalizedSrc}`);
+    log(`Copying to: ${normalizedDest}`);
+    if (!import_fs5.default.existsSync(normalizedDest)) {
+      import_fs5.default.mkdirSync(normalizedDest, { recursive: true });
+    }
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      try {
+        (0, import_child_process2.execSync)(`robocopy "${normalizedSrc}" "${normalizedDest}" /E /NFL /NDL /NJH /NJS /nc /ns /np`, { stdio: "pipe" });
+      } catch (error) {
+        if (error.status !== 1 && error.status !== 0) {
+          throw error;
+        }
+      }
+    } else {
+      (0, import_child_process2.execSync)(`cp -r "${normalizedSrc}/." "${normalizedDest}"`, { stdio: "pipe" });
+    }
+    if (import_fs5.default.existsSync(normalizedDest) && import_fs5.default.readdirSync(normalizedDest).length > 0) {
+      log(`\u2705 Copied ${normalizedSrc} -> ${normalizedDest}`);
+      return true;
+    } else {
+      log(`\u274C Copy verification failed: destination is empty`);
+      return false;
+    }
+  } catch (error) {
+    log(`\u274C Failed to copy ${src} -> ${dest}: ${error.message}`);
+    return false;
+  }
+}
+function updatePackageJson(packageName) {
+  var _a, _b, _c;
+  try {
+    log(`Updating package.json to add ${packageName} with "*" version...`);
+    if (!import_fs5.default.existsSync(CWD_PACKAGE_JSON)) {
+      log(`Package.json file not found at: ${CWD_PACKAGE_JSON}`, true);
+      return false;
+    }
+    const packageJson = JSON.parse(import_fs5.default.readFileSync(CWD_PACKAGE_JSON, "utf8"));
+    const existingVersion = ((_a = packageJson.dependencies) == null ? void 0 : _a[packageName]) || ((_b = packageJson.devDependencies) == null ? void 0 : _b[packageName]);
+    if (existingVersion && existingVersion !== "*") {
+      log(`Package ${packageName} already exists with version: ${existingVersion}`, false, true);
+      log(`Updating to "*" for local development...`, false, true);
+    }
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    packageJson.dependencies[packageName] = "*";
+    if ((_c = packageJson.devDependencies) == null ? void 0 : _c[packageName]) {
+      delete packageJson.devDependencies[packageName];
+      log(`Moved ${packageName} from devDependencies to dependencies`);
+    }
+    import_fs5.default.writeFileSync(CWD_PACKAGE_JSON, JSON.stringify(packageJson, null, 2) + "\n");
+    logSuccess(`Added ${packageName}: "*" to package.json`);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      log(`Package.json file not found at: ${CWD_PACKAGE_JSON}`, true);
+    } else if (error instanceof SyntaxError) {
+      log(`Invalid JSON in package.json: ${error.message}`, true);
+    } else if (error.code === "EACCES") {
+      log(`Permission denied writing to package.json`, true);
+    } else {
+      log(`Failed to update package.json: ${error.message}`, true);
+    }
+    return false;
+  }
+}
+function installSpecificPackage(packageName) {
+  logSection(`Installing Specific Package: ${packageName}`);
+  if (!packageName || typeof packageName !== "string" || !packageName.startsWith("@microfox/")) {
+    log(`Invalid package name format: "${packageName}". Must start with "@microfox/"`, true);
+    process.exit(1);
+  }
+  const packageShortName = packageName.replace("@microfox/", "");
+  if (!packageShortName || packageShortName.trim() === "") {
+    log(`Invalid package name: "${packageName}"`, true);
+    process.exit(1);
+  }
+  const microfoxDir = import_path6.default.join(MICROFOX_NODE_MODULES, "@microfox");
+  const srcDir = import_path6.default.join(microfoxDir, packageShortName);
+  log(`Searching for package: ${packageName}`);
+  log(`Source directory: ${srcDir}`);
+  if (!import_fs5.default.existsSync(microfoxDir)) {
+    log(`Microfox packages directory not found at: ${microfoxDir}`, true);
+    process.exit(1);
+  }
+  if (!import_fs5.default.existsSync(srcDir)) {
+    log(`Package "${packageName}" not found in source packages`, true);
+    log(`Searched in: ${srcDir}`, true);
+    process.exit(1);
+  }
+  if (!updatePackageJson(packageName)) {
+    process.exit(1);
+  }
+  const microfoxScopeDir = import_path6.default.join(CWD_NODE_MODULES, "@microfox");
+  if (!import_fs5.default.existsSync(microfoxScopeDir)) {
+    import_fs5.default.mkdirSync(microfoxScopeDir, { recursive: true });
+  }
+  const destDir = import_path6.default.join(CWD_NODE_MODULES, "@microfox", packageShortName);
+  log(`Copying package files...`);
+  if (copyDirectory(srcDir, destDir)) {
+    logSection(`\u2705 SUCCESS`);
+    logSuccess(`Package ${packageName} installed for local development!`);
+    log(`Package location: ${destDir}`);
+  } else {
+    log(`Failed to copy package files`, true);
+    process.exit(1);
+  }
+}
+function installAllPackages() {
+  log('Installing all @microfox/* packages with "*" version from package.json...');
+  const packageJson = JSON.parse(import_fs5.default.readFileSync(CWD_PACKAGE_JSON, "utf8"));
+  const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const microfoxPackages = Object.entries(dependencies).filter(([name, version2]) => name.startsWith("@microfox/") && version2 === "*").map(([name]) => name);
+  if (microfoxPackages.length === 0) {
+    log('\u2139\uFE0F  No @microfox/* packages with "*" version found in package.json');
+    return;
+  }
+  log(`Found ${microfoxPackages.length} @microfox/* packages to install:`);
+  microfoxPackages.forEach((pkg) => log(`  - ${pkg}`));
+  const microfoxScopeDir = import_path6.default.join(CWD_NODE_MODULES, "@microfox");
+  if (!import_fs5.default.existsSync(microfoxScopeDir)) {
+    import_fs5.default.mkdirSync(microfoxScopeDir, { recursive: true });
+  }
+  let successCount = 0;
+  let failureCount = 0;
+  for (const packageName of microfoxPackages) {
+    const packageShortName = packageName.replace("@microfox/", "");
+    const srcDir = import_path6.default.join(MICROFOX_NODE_MODULES, "@microfox", packageShortName);
+    const destDir = import_path6.default.join(CWD_NODE_MODULES, "@microfox", packageShortName);
+    if (!import_fs5.default.existsSync(srcDir)) {
+      log(`\u26A0\uFE0F  Package ${packageName} not found in source node_modules, skipping...`);
+      failureCount++;
+      continue;
+    }
+    if (copyDirectory(srcDir, destDir)) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+  log(`
+\u{1F4CA} Installation Summary:`);
+  log(`  \u2705 Successfully installed: ${successCount} packages`);
+  if (failureCount > 0) {
+    log(`  \u274C Failed to install: ${failureCount} packages`);
+  }
+}
+async function runExperimentalInstall(packages, targetDirName) {
+  try {
+    logSection("Microfox Local Package Installer (Experimental)");
+    log(`Started at: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+    log(`Working directory: ${process.cwd()}`);
+    const sourceDir = findSourceDir(targetDirName);
+    if (!sourceDir) {
+      log(`Could not find source directory '${targetDirName}' in any parent of a .git directory.`, true);
+      log(`Searched up to 10 levels from ${process.cwd()}`, true);
+      process.exit(1);
+    }
+    log(`Found source directory at: ${sourceDir}`);
+    MICROFOX_NODE_MODULES = import_path6.default.join(sourceDir, "node_modules");
+    if (!import_fs5.default.existsSync(MICROFOX_NODE_MODULES)) {
+      log(`Source node_modules directory not found at: ${MICROFOX_NODE_MODULES}`, true);
+      log(`Please run 'npm install' or 'pnpm install' in ${sourceDir}`, true);
+      process.exit(1);
+    }
+    if (!import_fs5.default.existsSync(CWD_PACKAGE_JSON)) {
+      log(`package.json not found in current directory: ${CWD_PACKAGE_JSON}`, true);
+      process.exit(1);
+    }
+    if (packages.length > 0) {
+      log(`Installing ${packages.length} specific package(s)...`);
+      for (let i = 0; i < packages.length; i++) {
+        const packageName = packages[i];
+        log(`
+[${i + 1}/${packages.length}] Processing: ${packageName}`);
+        installSpecificPackage(packageName);
+      }
+      logSection("\u{1F389} All Specified Packages Installed Successfully");
+    } else {
+      installAllPackages();
+    }
+  } catch (error) {
+    log("", true);
+    log(`Unexpected error occurred: ${error.message}`, true);
+    if (error.stack) {
+      log(`Stack trace: ${error.stack}`, true);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/install.ts
+var installCommand = new import_commander6.Command("install").description("Install packages for local development.").argument("[packages...]", "Specific packages to install").option("--experimental", "Enable experimental features").option("--target <name>", "Specify the target source directory name", "Microfox").action(async (packages, options) => {
+  if (options.experimental) {
+    await runExperimentalInstall(packages, options.target);
+  } else {
+    console.log("This command is only available with the --experimental flag.");
+    process.exit(1);
+  }
+});
+
+// src/commands/update.ts
+var import_commander7 = require("commander");
+
+// src/utils/experimental-updater.ts
+var import_fs6 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+var import_chalk7 = __toESM(require("chalk"));
+var CWD_PACKAGE_JSON2 = import_path7.default.join(process.cwd(), "package.json");
+function log2(message, isError = false, isWarning = false) {
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  let prefix;
+  if (isError) {
+    prefix = import_chalk7.default.red(`\u274C [update-microfox ${timestamp}]`);
+  } else if (isWarning) {
+    prefix = import_chalk7.default.yellow(`\u26A0\uFE0F  [update-microfox ${timestamp}]`);
+  } else {
+    prefix = import_chalk7.default.blue(`\u2139\uFE0F  [update-microfox ${timestamp}]`);
+  }
+  console.log(`${prefix} ${message}`);
+}
+function logSuccess2(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  console.log(import_chalk7.default.green(`\u2705 [update-microfox ${timestamp}] ${message}`));
+}
+function logSection2(title) {
+  console.log("\n" + "=".repeat(60));
+  console.log(`  ${title}`);
+  console.log("=".repeat(60));
+}
+function updatePackage(packageName, isDev) {
+  var _a;
+  log2(`Updating package to latest: ${packageName}`);
+  const saveFlag = isDev ? "--save-dev" : "--save";
+  try {
+    (0, import_child_process3.execSync)(`npm install ${packageName}@latest ${saveFlag}`, { cwd: process.cwd(), stdio: "pipe" });
+    logSuccess2(`Successfully updated ${packageName} to the latest version from npm.`);
+    return true;
+  } catch (error) {
+    log2(`Failed to update ${packageName}: ${error.message}`, true);
+    log2(`Stderr: ${(_a = error.stderr) == null ? void 0 : _a.toString()}`, true);
+    return false;
+  }
+}
+function updateSpecificPackage(packageName, isDevFlag) {
+  logSection2(`Updating Specific Package: ${packageName}`);
+  if (!packageName || typeof packageName !== "string" || !packageName.startsWith("@microfox/")) {
+    log2(`Invalid package name: "${packageName}". Must start with "@microfox/".`, true);
+    process.exit(1);
+  }
+  const packageJson = JSON.parse(import_fs6.default.readFileSync(CWD_PACKAGE_JSON2, "utf8"));
+  const dependencies = packageJson.dependencies || {};
+  const devDependencies = packageJson.devDependencies || {};
+  let isDev = !!devDependencies[packageName];
+  if (!dependencies[packageName] && !devDependencies[packageName]) {
+    log2(`Package "${packageName}" not found in dependencies.`, false, true);
+    log2(`Attempting to install it as a new package...`, false, true);
+    isDev = isDevFlag;
+  } else {
+    log2(`Package found in ${isDev ? "devDependencies" : "dependencies"}.`);
+  }
+  if (updatePackage(packageName, isDev)) {
+    logSection2(`\u2705 SUCCESS`);
+    logSuccess2(`Package ${packageName} updated successfully!`);
+  } else {
+    log2(`Failed to update ${packageName}`, true);
+    process.exit(1);
+  }
+}
+function updateAllPackages() {
+  logSection2("Updating all @microfox/* packages to latest");
+  const packageJson = JSON.parse(import_fs6.default.readFileSync(CWD_PACKAGE_JSON2, "utf8"));
+  const dependencies = packageJson.dependencies || {};
+  const devDependencies = packageJson.devDependencies || {};
+  const allDependencies = { ...dependencies, ...devDependencies };
+  const microfoxPackages = Object.entries(allDependencies).filter(([name]) => name.startsWith("@microfox/")).map(([name]) => name);
+  if (microfoxPackages.length === 0) {
+    log2("\u2139\uFE0F  No @microfox/* packages found in package.json.");
+    return;
+  }
+  log2(`Found ${microfoxPackages.length} packages to update:`);
+  microfoxPackages.forEach((pkg) => log2(`  - ${pkg}`));
+  let successCount = 0;
+  let failureCount = 0;
+  for (const packageName of microfoxPackages) {
+    const isDev = !!devDependencies[packageName];
+    if (updatePackage(packageName, isDev)) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+  log2(`
+\u{1F4CA} Update Summary:`);
+  log2(`  \u2705 Successfully updated: ${successCount} packages`);
+  if (failureCount > 0) {
+    log2(`  \u274C Failed to update: ${failureCount} packages`);
+  }
+}
+async function runUpdate(packages, options) {
+  try {
+    logSection2("Microfox Package Updater (Experimental)");
+    if (!import_fs6.default.existsSync(CWD_PACKAGE_JSON2)) {
+      log2(`package.json not found in ${process.cwd()}`, true);
+      process.exit(1);
+    }
+    if (packages.length > 0) {
+      log2(`Updating ${packages.length} specific package(s)...`);
+      packages.forEach((pkg) => updateSpecificPackage(pkg, !!options.dev));
+      logSection2("\u{1F389} All specified packages processed.");
+    } else {
+      updateAllPackages();
+    }
+  } catch (error) {
+    log2("", true);
+    log2(`An unexpected error occurred: ${error.message}`, true);
+    if (error.stack) {
+      log2(`Stack trace: ${error.stack}`, true);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+var updateCommand = new import_commander7.Command("update").description("Update @microfox packages to the latest versions from npm.").argument("[packages...]", "Specific packages to update").option("--experimental", "Enable experimental features").option("--dev", "Update packages in devDependencies").action(async (packages, options) => {
+  if (options.experimental) {
+    await runUpdate(packages, options);
+  } else {
+    console.log("This command is only available with the --experimental flag.");
+    process.exit(1);
+  }
+});
+
+// package.json
+var version = "1.0.11";
+
+// src/cli.ts
+var program = new import_commander8.Command();
+program.name("microfox").description("Universal CLI tool for creating and managing Microfox projects").version(version);
+program.addCommand(kickstartCommand);
+program.addCommand(addCommand);
+program.addCommand(pushCommand);
+program.addCommand(statusCommand);
+program.addCommand(logsCommand);
+program.addCommand(metricsCommand);
+program.addCommand(codeCommand);
+program.addCommand(installCommand);
+program.addCommand(updateCommand);
+program.action(() => {
+  if (process.argv.length <= 2) {
+    program.help();
+  }
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map