@standardagents/cli 0.13.0 → 0.13.2

package/README.md

@@ -35,6 +35,31 @@ pnpm exec agents scaffold
 
 Creates the `agents/` directory structure with documentation files.
 
+### Install The AgentBuilder Skill
+
+```bash
+npx @standardagents/cli skill
+```
+
+Opens an interactive picker and installs the bundled `agentbuilder` guidance
+into a supported coding agent. Right now that means:
+
+- Codex: installs a skill folder into `$CODEX_HOME/skills` or `~/.codex/skills`
+- Claude Code: installs a user subagent into `~/.claude/agents/agentbuilder.md`
+
+Use `--force` to overwrite an existing installed copy:
+
+```bash
+npx @standardagents/cli skill --force
+```
+
+Skip the picker with an explicit target:
+
+```bash
+npx @standardagents/cli skill --agent codex
+npx @standardagents/cli skill --agent claude
+```
+
 ## Manual Configuration
 
 If you prefer to configure manually, add the following to your `wrangler.jsonc`:

package/chat/vite/vite.config.ts

@@ -15,7 +15,10 @@ export default defineConfig({
     },
   },
   server: {
+    host: '0.0.0.0',
     port: 5174,
+    strictPort: true,
+    allowedHosts: true,
   },
   build: {
     outDir: '../dist/vite',

package/dist/index.js

@@ -11,6 +11,8 @@ import { loadFile, writeFile, generateCode } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
 import net from 'net';
 import { fileURLToPath } from 'url';
+import os from 'os';
+import { copySkill, readSkillFile } from '@standardagents/skill';
 
 var logger = {
   success: (message) => {
@@ -227,7 +229,7 @@ Models define which LLM provider and model to use for prompts.
 | Property | Type | Required | Description |
 |----------|------|----------|-------------|
 | \`name\` | \`string\` | Yes | Unique identifier for this model configuration |
-| \`provider\` | \`'openai' \\| 'anthropic' \\| 'openrouter' \\| 'google'\` | Yes | LLM provider |
+| \`provider\` | \`'openai' \\| 'anthropic' \\| 'openrouter' \\| 'google' \\| 'cerebras' \\| 'groq' \\| 'xai'\` | Yes | LLM provider |
 | \`model\` | \`string\` | Yes | Model ID sent to provider API |
 | \`fallbacks\` | \`string[]\` | No | Fallback model names to try if primary fails |
 | \`inputPrice\` | \`number\` | No | Cost per 1M input tokens (USD) |
@@ -265,10 +267,13 @@ Set these environment variables in \`.dev.vars\` (local) or Cloudflare secrets (
 
 | Provider | Environment Variable |
 |----------|---------------------|
+| Cerebras | \`CEREBRAS_API_KEY\` |
+| Groq | \`GROQ_API_KEY\` |
 | OpenAI | \`OPENAI_API_KEY\` |
 | Anthropic | \`ANTHROPIC_API_KEY\` |
 | OpenRouter | \`OPENROUTER_API_KEY\` |
 | Google | \`GOOGLE_API_KEY\` |
+| xAI | \`XAI_API_KEY\` |
 
 ## Fallback Strategy
 
@@ -297,7 +302,8 @@ export default defineModel({
 
 - **Name by use case**, not model ID (e.g., \`fast\`, \`default\`, \`heavy\`)
 - **Configure fallbacks** for production reliability
-- **Set pricing** for cost tracking in logs
+- **Set pricing** for cost tracking in logs when your provider or runtime does not supply it automatically
+- **Cerebras note:** documented Cerebras models have built-in fallback pricing for request logs, but custom/private Cerebras models should still set \`inputPrice\` and \`outputPrice\`
 - **Use environment variables** for API keys, never hardcode
 
 ## Documentation
@@ -1780,12 +1786,13 @@ async function promptPassword(question) {
     stdin.on("data", onData);
   });
 }
-function runCommand(command, args, cwd) {
+function runCommand(command, args, cwd, env) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
       stdio: "inherit",
-      shell: false
+      shell: false,
+      env: { ...process.env, ...env }
     });
     child.on("close", (code) => {
       if (code === 0) {
@@ -1813,11 +1820,14 @@ function detectPackageManager() {
   if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
-function getPackageVersion() {
+function getWorkspacePackageVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.13.0";
+  return "0.13.2";
+}
+function getSipPackageVersion() {
+  return "1.0.1";
 }
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
@@ -1914,21 +1924,21 @@ async function init(projectNameArg, options = {}) {
     switch (pm) {
       case "pnpm":
         createCmd = "pnpm";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
+        createArgs = ["dlx", "create-vite@latest", projectName, "--template", template, "--no-interactive"];
         break;
       case "yarn":
         createCmd = "yarn";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
+        createArgs = ["dlx", "create-vite@latest", projectName, "--template", template, "--no-interactive"];
         break;
       case "bun":
         createCmd = "bun";
-        createArgs = ["create", "vite@latest", projectName, "--template", template, "--yes"];
+        createArgs = ["x", "create-vite@latest", projectName, "--template", template, "--no-interactive"];
         break;
       default:
-        createCmd = "npm";
-        createArgs = ["create", "vite@latest", projectName, "--", "--template", template, "--yes"];
+        createCmd = "npx";
+        createArgs = ["create-vite@latest", projectName, "--template", template, "--no-interactive"];
     }
-    await runCommand(createCmd, createArgs, cwd);
+    await runCommand(createCmd, createArgs, cwd, { CI: "1" });
     const createdPackageJsonPath = path3.join(projectPath, "package.json");
     if (!fs3.existsSync(createdPackageJsonPath)) {
       throw new Error("Vite project scaffolding did not create package.json");
@@ -1961,15 +1971,29 @@ export default defineConfig({
   logger.info("Step 2: Configuring environment variables...");
   logger.log("");
   const encryptionKey = crypto.randomBytes(32).toString("hex");
+  let cloudflareToken = "";
+  let cloudflareAccountId = "";
+  let cerebrasKey = "";
+  let googleKey = "";
+  let groqKey = "";
   let openrouterKey = "";
   let openaiKey = "";
+  let xaiKey = "";
   let adminPassword = "";
   if (!options.yes) {
     logger.log("API keys are optional but required to use AI models.");
     logger.log("You can add them later by editing .dev.vars");
     logger.log("");
+    cloudflareToken = await prompt("Cloudflare Workers AI API token (optional, press Enter to skip): ");
+    if (cloudflareToken) {
+      cloudflareAccountId = await prompt("Cloudflare Account ID: ");
+    }
+    cerebrasKey = await prompt("Cerebras API key (optional, press Enter to skip): ");
+    googleKey = await prompt("Google Gemini API key (optional, press Enter to skip): ");
+    groqKey = await prompt("Groq API key (optional, press Enter to skip): ");
     openrouterKey = await prompt("OpenRouter API key (optional, press Enter to skip): ");
     openaiKey = await prompt("OpenAI API key (optional, press Enter to skip): ");
+    xaiKey = await prompt("xAI API key (optional, press Enter to skip): ");
     logger.log("");
     logger.log("Set a temporary admin password for development access.");
     logger.log('Press Enter to use the default password "admin".');
@@ -1999,7 +2023,8 @@ export default defineConfig({
   try {
     const installCmd = pm === "npm" ? "install" : "add";
     const devFlag = pm === "npm" ? "--save-dev" : "-D";
-    const packageVersion = getPackageVersion();
+    const workspacePackageVersion = getWorkspacePackageVersion();
+    const sipPackageVersion = getSipPackageVersion();
     await runCommand(pm, [
       installCmd,
       devFlag,
@@ -2007,16 +2032,31 @@ export default defineConfig({
       "wrangler"
     ], projectPath);
     const deps = [
-      `@standardagents/builder@${packageVersion}`,
-      `@standardagents/spec@${packageVersion}`,
-      `@standardagents/sip@${packageVersion}`,
+      `@standardagents/builder@${workspacePackageVersion}`,
+      `@standardagents/spec@${workspacePackageVersion}`,
+      `@standardagents/sip@${sipPackageVersion}`,
       "zod"
     ];
+    if (cloudflareToken) {
+      deps.push(`@standardagents/cloudflare@${workspacePackageVersion}`);
+    }
+    if (cerebrasKey) {
+      deps.push(`@standardagents/cerebras@${workspacePackageVersion}`);
+    }
+    if (googleKey) {
+      deps.push(`@standardagents/google@${workspacePackageVersion}`);
+    }
+    if (groqKey) {
+      deps.push(`@standardagents/groq@${workspacePackageVersion}`);
+    }
     if (openaiKey) {
-      deps.push(`@standardagents/openai@${packageVersion}`);
+      deps.push(`@standardagents/openai@${workspacePackageVersion}`);
     }
     if (openrouterKey) {
-      deps.push(`@standardagents/openrouter@${packageVersion}`);
+      deps.push(`@standardagents/openrouter@${workspacePackageVersion}`);
+    }
+    if (xaiKey) {
+      deps.push(`@standardagents/xai@${workspacePackageVersion}`);
     }
     await runCommand(pm, [installCmd, ...deps], projectPath);
   } catch (error) {
@@ -2045,6 +2085,28 @@ export default defineConfig({
     "# AI Provider API Keys",
     "# Uncomment and add your keys as needed"
   ];
+  if (cloudflareToken) {
+    devVarsLines.push(`CLOUDFLARE_API_TOKEN=${cloudflareToken}`);
+    devVarsLines.push(`CLOUDFLARE_ACCOUNT_ID=${cloudflareAccountId}`);
+  } else {
+    devVarsLines.push("# CLOUDFLARE_API_TOKEN=your-cloudflare-workers-ai-token");
+    devVarsLines.push("# CLOUDFLARE_ACCOUNT_ID=your-cloudflare-account-id");
+  }
+  if (cerebrasKey) {
+    devVarsLines.push(`CEREBRAS_API_KEY=${cerebrasKey}`);
+  } else {
+    devVarsLines.push("# CEREBRAS_API_KEY=your-cerebras-key");
+  }
+  if (googleKey) {
+    devVarsLines.push(`GOOGLE_API_KEY=${googleKey}`);
+  } else {
+    devVarsLines.push("# GOOGLE_API_KEY=your-google-gemini-key");
+  }
+  if (groqKey) {
+    devVarsLines.push(`GROQ_API_KEY=${groqKey}`);
+  } else {
+    devVarsLines.push("# GROQ_API_KEY=your-groq-key");
+  }
   if (openrouterKey) {
     devVarsLines.push(`OPENROUTER_API_KEY=${openrouterKey}`);
   } else {
@@ -2055,6 +2117,11 @@ export default defineConfig({
   } else {
     devVarsLines.push("# OPENAI_API_KEY=your-openai-key");
   }
+  if (xaiKey) {
+    devVarsLines.push(`XAI_API_KEY=${xaiKey}`);
+  } else {
+    devVarsLines.push("# XAI_API_KEY=your-xai-key");
+  }
   devVarsLines.push("");
   const devVarsPath = path3.join(projectPath, ".dev.vars");
   fs3.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
@@ -3325,10 +3392,188 @@ async function deploy(options) {
     process.exit(1);
   }
 }
+var DEFAULT_SKILL_NAME = "agentbuilder";
+function resolveCodexHome(env = process.env, homeDir = os.homedir()) {
+  return env.CODEX_HOME || path3.join(homeDir, ".codex");
+}
+function resolveClaudeHome(homeDir = os.homedir()) {
+  return path3.join(homeDir, ".claude");
+}
+function expandHomePath(inputPath, homeDir = os.homedir()) {
+  if (inputPath === "~") {
+    return homeDir;
+  }
+  if (inputPath.startsWith("~/")) {
+    return path3.join(homeDir, inputPath.slice(2));
+  }
+  return inputPath;
+}
+function buildInstallTargets(options = {}, env = process.env, homeDir = os.homedir()) {
+  const customRoot = options.dir ? path3.resolve(expandHomePath(options.dir, homeDir)) : null;
+  const codexHome = resolveCodexHome(env, homeDir);
+  const claudeHome = resolveClaudeHome(homeDir);
+  return [
+    {
+      id: "codex",
+      label: "Codex",
+      summary: "Install as a Codex skill folder",
+      detected: fs3.existsSync(codexHome),
+      installPath: customRoot ?? path3.join(codexHome, "skills")
+    },
+    {
+      id: "claude",
+      label: "Claude Code",
+      summary: "Install as a Claude Code user subagent",
+      detected: fs3.existsSync(claudeHome),
+      installPath: customRoot ?? path3.join(claudeHome, "agents")
+    }
+  ];
+}
+function resolveSelectedTarget(targetId, options = {}, env = process.env, homeDir = os.homedir()) {
+  const target = buildInstallTargets(options, env, homeDir).find(
+    (candidate) => candidate.id === targetId
+  );
+  if (!target) {
+    throw new Error(`Unknown install target "${targetId}".`);
+  }
+  return target;
+}
+function buildClaudeSubagentMarkdown(skillName, description, body) {
+  const normalizedBody = body.replace(/^\uFEFF/, "").trim();
+  return [
+    "---",
+    `name: ${skillName}`,
+    `description: ${description}`,
+    "---",
+    "",
+    normalizedBody,
+    ""
+  ].join("\n");
+}
+async function selectInstallTarget(targets) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const render = (initial = false) => {
+      const lines = [];
+      lines.push("Choose where to install the AgentBuilder skill:");
+      lines.push("");
+      for (let i = 0; i < targets.length; i++) {
+        const target = targets[i];
+        const isSelected = i === selectedIndex;
+        const cursor = isSelected ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const title = isSelected ? "\x1B[36m" : "\x1B[90m";
+        const detection = target.detected ? "\x1B[32m(detected)\x1B[0m" : "\x1B[90m(not found yet)\x1B[0m";
+        lines.push(`${cursor} ${title}${target.label}\x1B[0m ${detection}`);
+        lines.push(`  ${target.summary}`);
+        lines.push(`  ${target.installPath}`);
+        lines.push("");
+      }
+      lines.push("Use arrows to move, Enter to install, Ctrl+C to cancel.");
+      if (!initial) {
+        stdout.write("\x1B[?25l");
+        stdout.write(`\x1B[${lines.length}A`);
+        stdout.write("\x1B[0J");
+      }
+      stdout.write(lines.join("\n") + "\n");
+    };
+    render(true);
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + targets.length) % targets.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % targets.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(targets[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function installBundledSkill(targetId, skillName = DEFAULT_SKILL_NAME, options = {}) {
+  const target = resolveSelectedTarget(targetId, options);
+  if (target.id === "codex") {
+    const targetDir = path3.join(target.installPath, skillName);
+    if (fs3.existsSync(targetDir) && !options.force) {
+      throw new Error(
+        `Skill already exists at ${targetDir}. Re-run with --force to overwrite it.`
+      );
+    }
+    return copySkill(skillName, target.installPath, {
+      overwrite: options.force ?? false
+    });
+  }
+  const targetFile = path3.join(target.installPath, `${skillName}.md`);
+  if (fs3.existsSync(targetFile) && !options.force) {
+    throw new Error(
+      `Claude subagent already exists at ${targetFile}. Re-run with --force to overwrite it.`
+    );
+  }
+  const skillBody = await readSkillFile(skillName);
+  const subagentMarkdown = buildClaudeSubagentMarkdown(
+    skillName,
+    "Use for Standard Agents and AgentBuilder architecture, composition, subagent design, and implementation work.",
+    skillBody
+  );
+  fs3.mkdirSync(target.installPath, { recursive: true });
+  fs3.writeFileSync(targetFile, subagentMarkdown, "utf8");
+  return targetFile;
+}
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function skill(options = {}) {
+  try {
+    const selectedTarget = options.agent ? resolveSelectedTarget(options.agent, options) : isInteractiveTerminal() ? await selectInstallTarget(buildInstallTargets(options)) : resolveSelectedTarget("codex", options);
+    logger.log("");
+    logger.info(`Installing AgentBuilder skill into ${selectedTarget.label}...`);
+    const installedPath = await installBundledSkill(
+      selectedTarget.id,
+      DEFAULT_SKILL_NAME,
+      options
+    );
+    logger.success(`Installed ${DEFAULT_SKILL_NAME} into ${selectedTarget.label}`);
+    logger.log("");
+    logger.log(`Path: ${installedPath}`);
+    logger.log("");
+    logger.log("Next steps:");
+    if (selectedTarget.id === "codex") {
+      logger.log("  Restart Codex if it is already running");
+      logger.log(`  Edit ${path3.join(installedPath, "SKILL.md")} to continue customizing the skill`);
+    } else {
+      logger.log("  Restart Claude Code if it is already running");
+      logger.log(`  Edit ${installedPath} to continue customizing the subagent`);
+    }
+  } catch (error) {
+    logger.log("");
+    logger.error(error instanceof Error ? error.message : "Failed to install skill");
+    process.exit(1);
+  }
+}
 
 // src/index.ts
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.13.0");
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.13.2");
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
 program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
@@ -3336,6 +3581,7 @@ program.command("pack [agent-name]").description("Pack an agent with all its dep
 program.command("unpack [package]").description("Unpack a packed agent to the local agents directory").option("--no-signatures", "Remove package signatures (fully editable)").action(unpack);
 program.command("list-packed").description("List all discovered packed agents").action(listPacked);
 program.command("deploy").description("Build and deploy your project to the Standard Agents platform").option("--api-key <key>", "Platform API key (overrides PLATFORM_API_KEY env var)").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").action(deploy);
+program.command("skill").description("Install the bundled AgentBuilder guidance into a supported coding agent").option("--agent <target>", "Install target: codex or claude").option("--dir <path>", "Install directory override for the selected target").option("--force", "Overwrite an existing installed skill").action(skill);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map