@aixyz/cli 0.0.0 → 0.1.1

package/README.md

@@ -0,0 +1,45 @@
+# aixyz-cli
+
+[![npm](https://img.shields.io/npm/v/aixyz-cli)](https://www.npmjs.com/package/aixyz-cli)
+
+CLI for building and deploying [aixyz](https://ai-xyz.dev) agents.
+
+## Quick Start
+
+Run without installing:
+
+```bash
+bunx aixyz-cli dev
+npx aixyz-cli dev
+```
+
+> Note: Requires [Bun](https://bun.sh) to be installed on your system.
+
+## Installation
+
+```bash
+bun add aixyz-cli
+```
+
+## Commands
+
+### `aixyz-cli dev`
+
+Start a local development server with file watching and auto-restart.
+
+```bash
+aixyz-cli dev
+aixyz-cli dev --port 8080
+```
+
+### `aixyz-cli build`
+
+Build the agent for Vercel deployment using the [Build Output API v3](https://vercel.com/docs/build-output-api/v3).
+
+```bash
+aixyz-cli build
+```
+
+## License
+
+MIT

package/bin.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env bun
+import { program } from "commander";
+import { build } from "./build";
+import { dev } from "./dev";
+import pkg from "./package.json";
+
+function handleAction(
+  action: (options: Record<string, unknown>) => Promise<void>,
+): (options: Record<string, unknown>) => Promise<void> {
+  return async (options) => {
+    try {
+      await action(options);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  };
+}
+
+program.name("aixyz").description("CLI for building and deploying aixyz agents").version(pkg.version);
+
+program
+  .command("dev")
+  .description("Start a local development server")
+  .option("-p, --port <port>", "Port to listen on", "3000")
+  .action(handleAction(dev));
+
+program
+  .command("build")
+  .description("Build the aixyz agent for Vercel deployment")
+  .addHelpText(
+    "after",
+    `
+Details:
+  Bundles your aixyz agent into a Vercel serverless function output.
+
+  The build process:
+    1. Loads aixyz.config.ts from the current directory
+    2. Detects entrypoint (app/server.ts or auto-generates from app/agent.ts + app/tools/)
+    3. Generates Vercel Build Output API v3 structure
+    4. Copies static assets from public/ (if present)
+
+  Output is written to .vercel/output/ in the current directory.
+
+Prerequisites:
+  - An aixyz.config.ts with a default export
+  - An entrypoint at app/server.ts, or app/agent.ts + app/tools/ for auto-generation
+
+Examples:
+  $ aixyz build`,
+  )
+  .action(handleAction(build));
+
+program.parse();

package/build/AixyzConfigPlugin.ts

@@ -0,0 +1,24 @@
+import { getAixyzConfig } from "@aixyz/config";
+import type { BunPlugin } from "bun";
+
+export function AixyzConfigPlugin(): BunPlugin {
+  const materialized = getAixyzConfig();
+
+  // TODO(@fuxingloh): change how this is formatted
+  console.log("AixyzConfig loaded:", materialized);
+
+  return {
+    name: "aixyz-config",
+    setup(build) {
+      build.onLoad({ filter: /packages\/aixyz\/config\.ts$/ }, () => ({
+        contents: `
+        const config = ${JSON.stringify(materialized)};
+        export function getAixyzConfig() {
+          return config;
+        }
+      `,
+        loader: "ts",
+      }));
+    },
+  };
+}

package/build/AixyzServerPlugin.ts

@@ -0,0 +1,96 @@
+import type { BunPlugin } from "bun";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { resolve, relative, basename, join } from "path";
+
+export function AixyzServerPlugin(entrypoint: string): BunPlugin {
+  return {
+    name: "aixyz-entrypoint",
+    setup(build) {
+      build.onLoad({ filter: /server\.ts$/ }, async (args) => {
+        if (args.path !== entrypoint) return;
+
+        const source = await Bun.file(args.path).text();
+        const transformed = source.replace(/export\s+default\s+(\w+)\s*;/, "export default $1.express;");
+
+        return { contents: transformed, loader: "ts" };
+      });
+    },
+  };
+}
+
+export function getEntrypointMayGenerate(cwd: string, mode: "dev" | "build"): string {
+  const appDir = resolve(cwd, "app");
+
+  if (existsSync(resolve(appDir, "server.ts"))) {
+    return resolve(appDir, "server.ts");
+  }
+
+  const devDir = resolve(cwd, join(".aixyz", mode));
+  mkdirSync(devDir, { recursive: true });
+  const entrypoint = resolve(devDir, "server.ts");
+  writeFileSync(entrypoint, generateServer(appDir, devDir));
+  return entrypoint;
+}
+
+/**
+ * Generate server.ts content by scanning the app directory for agent.ts and tools/.
+ *
+ * @param appDir - The app directory containing agent.ts and tools/
+ * @param entrypointDir - Directory where the generated file will live (for computing relative imports).
+ */
+function generateServer(appDir: string, entrypointDir: string): string {
+  const rel = relative(entrypointDir, appDir);
+  const importPrefix = rel === "" ? "." : rel.startsWith(".") ? rel : `./${rel}`;
+
+  const imports: string[] = [];
+  const body: string[] = [];
+
+  imports.push('import { AixyzServer } from "aixyz/server";');
+
+  const hasAgent = existsSync(resolve(appDir, "agent.ts"));
+  if (hasAgent) {
+    imports.push('import { useA2A } from "aixyz/server/adapters/a2a";');
+    imports.push(`import * as agent from "${importPrefix}/agent";`);
+  }
+
+  const toolsDir = resolve(appDir, "tools");
+  const tools: { name: string }[] = [];
+  if (existsSync(toolsDir)) {
+    for (const file of readdirSync(toolsDir)) {
+      if (file.endsWith(".ts")) {
+        const name = basename(file, ".ts");
+        // Skip tools starting with underscore
+        if (!name.startsWith("_")) {
+          tools.push({ name });
+        }
+      }
+    }
+  }
+
+  if (tools.length > 0) {
+    imports.push('import { AixyzMCP } from "aixyz/server/adapters/mcp";');
+    for (const tool of tools) {
+      imports.push(`import * as ${tool.name} from "${importPrefix}/tools/${tool.name}";`);
+    }
+  }
+
+  body.push("const server = new AixyzServer();");
+  body.push("await server.initialize();");
+  body.push("server.unstable_withIndexPage();");
+
+  if (hasAgent) {
+    body.push("useA2A(server, agent);");
+  }
+
+  if (tools.length > 0) {
+    body.push("const mcp = new AixyzMCP(server);");
+    for (const tool of tools) {
+      body.push(`await mcp.register("${tool.name}", ${tool.name});`);
+    }
+    body.push("await mcp.connect();");
+  }
+
+  body.push("export default server;");
+
+  return [...imports, "", ...body].join("\n");
+}

package/build/index.ts

@@ -0,0 +1,90 @@
+import { resolve } from "path";
+import { existsSync, mkdirSync, cpSync, rmSync } from "fs";
+import { AixyzConfigPlugin } from "./AixyzConfigPlugin";
+import { AixyzServerPlugin, getEntrypointMayGenerate } from "./AixyzServerPlugin";
+
+export async function build(): Promise<void> {
+  const cwd = process.cwd();
+
+  const entrypoint = getEntrypointMayGenerate(cwd, "build");
+
+  const outputDir = resolve(cwd, ".vercel/output");
+  rmSync(outputDir, { recursive: true, force: true });
+
+  const funcDir = resolve(outputDir, "functions/index.func");
+  mkdirSync(funcDir, { recursive: true });
+
+  // Write functions/index.func
+  const result = await Bun.build({
+    entrypoints: [entrypoint],
+    outdir: funcDir,
+    naming: "server.js",
+    target: "bun",
+    format: "esm",
+    sourcemap: "linked",
+    plugins: [AixyzConfigPlugin(), AixyzServerPlugin(entrypoint)],
+  });
+
+  if (!result.success) {
+    console.error("Build failed:");
+    for (const log of result.logs) {
+      console.error(log);
+    }
+    process.exit(1);
+  }
+
+  // Write .vc-config.json
+  await Bun.write(
+    resolve(funcDir, ".vc-config.json"),
+    JSON.stringify(
+      {
+        handler: "server.js",
+        runtime: "bun1.x",
+        launcherType: "Bun",
+        shouldAddHelpers: true,
+        shouldAddSourcemapSupport: true,
+      },
+      null,
+      2,
+    ),
+  );
+
+  // Write package.json for ESM support
+  await Bun.write(resolve(funcDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+
+  // Write config.json
+  await Bun.write(
+    resolve(outputDir, "config.json"),
+    JSON.stringify(
+      {
+        version: 3,
+        routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/" }],
+      },
+      null,
+      2,
+    ),
+  );
+
+  // Copy static assets (public/ → .vercel/output/static/)
+  const staticDir = resolve(outputDir, "static");
+
+  const publicDir = resolve(cwd, "public");
+  if (existsSync(publicDir)) {
+    cpSync(publicDir, staticDir, { recursive: true });
+    console.log("Copied public/ →", staticDir);
+  }
+
+  const iconFile = resolve(cwd, "app/icon.png");
+  if (existsSync(iconFile)) {
+    mkdirSync(staticDir, { recursive: true });
+    cpSync(iconFile, resolve(staticDir, "icon.png"));
+    console.log("Copied app/icon.png →", staticDir);
+  }
+
+  // Log summary
+  console.log("");
+  console.log("Build complete! Output:");
+  console.log("  .vercel/output/config.json");
+  console.log("  .vercel/output/functions/index.func/index.js");
+  console.log("  .vercel/output/static/");
+}

package/dev/index.ts

@@ -0,0 +1,96 @@
+import { resolve, relative } from "path";
+import { existsSync, watch } from "fs";
+import { loadEnvConfig } from "@next/env";
+import { getEntrypointMayGenerate } from "../build/AixyzServerPlugin";
+import pkg from "../package.json";
+
+export async function dev(options: { port?: string }): Promise<void> {
+  const cwd = process.cwd();
+
+  // Load environment config
+  const { loadedEnvFiles } = loadEnvConfig(cwd, true);
+  const envFileNames = loadedEnvFiles.map((f) => relative(cwd, f.path));
+
+  const port = options.port || process.env.PORT || "3000";
+  const baseUrl = `http://localhost:${port}`;
+
+  console.log("");
+  console.log(`⟡ ai-xyz.dev v${pkg.version}`);
+  console.log("");
+  console.log(`- A2A:          ${baseUrl}/.well-known/agent-card.json`);
+  console.log(`- MCP:          ${baseUrl}/mcp`);
+  if (envFileNames.length > 0) {
+    console.log(`- Environments: ${envFileNames.join(", ")}`);
+  }
+  console.log("");
+
+  // Spawn worker process
+  const workerPath = resolve(__dirname, "worker.js");
+  let child: ReturnType<typeof Bun.spawn> | null = null;
+  let restarting = false;
+
+  function startServer() {
+    const endpoint = getEntrypointMayGenerate(cwd, "dev");
+    child = Bun.spawn(["bun", workerPath, endpoint, port], {
+      cwd,
+      stdout: "inherit",
+      stderr: "inherit",
+      env: process.env,
+    });
+    child.exited.then((code) => {
+      if (!restarting && code !== 0) {
+        console.log(`\nServer exited with code ${code}, waiting for changes...`);
+      }
+    });
+  }
+
+  async function restartServer(reason: string) {
+    restarting = true;
+    if (child) {
+      child.kill();
+      await child.exited;
+      child = null;
+    }
+    restarting = false;
+    console.log(`Restarting... ${reason}`);
+    startServer();
+  }
+
+  startServer();
+
+  // Watch app/ for changes
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function scheduleRestart(reason: string) {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      restartServer(reason);
+    }, 100);
+  }
+
+  watch(resolve(cwd, "app"), { recursive: true }, (_event, filename) => {
+    scheduleRestart(filename ? `${filename} changed` : "file changed");
+  });
+
+  // Watch config file
+  const configFile = resolve(cwd, "aixyz.config.ts");
+  if (existsSync(configFile)) {
+    watch(configFile, () => {
+      scheduleRestart("config changed");
+    });
+  }
+
+  // Handle shutdown
+  process.on("SIGINT", () => {
+    if (child) child.kill();
+    process.exit(0);
+  });
+
+  process.on("SIGTERM", () => {
+    if (child) child.kill();
+    process.exit(0);
+  });
+
+  // Keep the process alive
+  await new Promise(() => {});
+}

package/dev/worker.ts

@@ -0,0 +1,26 @@
+async function main() {
+  const entrypoint = process.argv[2];
+  const port = parseInt(process.argv[3], 10);
+
+  if (!entrypoint || isNaN(port)) {
+    console.error("Usage: dev-worker <entrypoint> <port>");
+    process.exit(1);
+  }
+
+  const startTime = performance.now();
+  const mod = await import(entrypoint);
+  const app = mod.default;
+
+  if (!app || typeof app.express?.listen !== "function") {
+    console.error("Error: Entrypoint must default-export an AixyzApp");
+    process.exit(1);
+  }
+
+  app.express.listen(port, () => {
+    const duration = Math.round(performance.now() - startTime);
+    console.log(`Ready in ${duration}ms`);
+    console.log("");
+  });
+}
+
+main();

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@aixyz/cli",
-  "version": "0.0.0",
-  "private": false,
-  "files": []
+  "version": "0.1.1",
+  "description": "CLI for building and deploying aixyz agents.",
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "aixyz",
+    "erc-8004",
+    "deploy"
+  ],
+  "homepage": "https://ai-xyz.dev",
+  "bugs": {
+    "url": "https://github.com/AgentlyHQ/aixyz/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgentlyHQ/aixyz.git"
+  },
+  "license": "MIT",
+  "author": "AgentlyHQ",
+  "type": "module",
+  "bin": {
+    "aixyz-cli": "bin.ts"
+  },
+  "files": [
+    "build",
+    "dev",
+    "bin.ts"
+  ],
+  "dependencies": {
+    "@aixyz/config": "workspace:*",
+    "@next/env": "^16.1.6",
+    "commander": "^13.0.0"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  }
 }