@donkeylabs/cli 2.0.22 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "2.0.22",
+  "version": "2.2.0",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",

package/src/commands/generate-client.ts

@@ -0,0 +1,105 @@
+import { writeFile, mkdir } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import pc from "picocolors";
+import { loadConfig, extractRoutesFromServer, type DonkeylabsConfig, type RouteInfo } from "./generate-utils";
+
+export async function generateClientCommand(
+  _args: string[],
+  options: { output?: string; adapter?: string }
+): Promise<void> {
+  const config = await loadConfig();
+
+  // Resolve adapter: flag > config > default "typescript"
+  const adapter = options.adapter || config.adapter || "typescript";
+
+  // Resolve output: flag > config.client.output > "./client"
+  const output = options.output || config.client?.output || "./client";
+
+  // Extract routes from server
+  const entryPath = config.entry || "./src/index.ts";
+  console.log(pc.dim(`Extracting routes from ${entryPath}...`));
+  const serverOutput = await extractRoutesFromServer(entryPath);
+  const routes = serverOutput.routes;
+
+  if (routes.length === 0) {
+    console.warn(pc.yellow("No routes found - generating empty client"));
+  } else {
+    console.log(pc.green(`Found ${routes.length} routes`));
+  }
+
+  // Dispatch to adapter
+  if (adapter === "typescript") {
+    await generateTypescriptClient(routes, output);
+  } else {
+    await generateAdapterClient(adapter, config, routes, output);
+  }
+}
+
+/**
+ * Built-in TypeScript client generation using @donkeylabs/server/generator
+ */
+async function generateTypescriptClient(routes: RouteInfo[], output: string): Promise<void> {
+  try {
+    const { generateClientCode } = await import("@donkeylabs/server/generator");
+
+    const code = generateClientCode({ routes });
+
+    // Write single .ts file
+    const outputPath = output.endsWith(".ts") ? output : join(output, "index.ts");
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, code);
+
+    console.log(pc.green(`Generated TypeScript client:`), pc.dim(outputPath));
+  } catch (e: any) {
+    if (e.code === "ERR_MODULE_NOT_FOUND" || e.message?.includes("Cannot find")) {
+      console.error(pc.red("@donkeylabs/server not found"));
+      console.error(pc.dim("Make sure @donkeylabs/server is installed"));
+    } else {
+      console.error(pc.red("Failed to generate TypeScript client"));
+      console.error(pc.dim(e.message));
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Adapter-based client generation (sveltekit, swift, or custom package)
+ */
+async function generateAdapterClient(
+  adapter: string,
+  config: DonkeylabsConfig,
+  routes: RouteInfo[],
+  output: string
+): Promise<void> {
+  // Resolve adapter to package path
+  let adapterPackage: string;
+  if (adapter === "sveltekit") {
+    adapterPackage = "@donkeylabs/adapter-sveltekit";
+  } else if (adapter === "swift") {
+    adapterPackage = "@donkeylabs/adapter-swift";
+  } else {
+    // Treat as full package name (e.g., "@myorg/custom-adapter")
+    adapterPackage = adapter;
+  }
+
+  const generatorPath = `${adapterPackage}/generator`;
+
+  try {
+    const adapterModule = await import(generatorPath);
+    if (!adapterModule.generateClient) {
+      console.error(pc.red(`Adapter ${adapterPackage} does not export generateClient`));
+      process.exit(1);
+    }
+    await adapterModule.generateClient(config, routes, output);
+    console.log(pc.green(`Generated client (${adapter}):`), pc.dim(output));
+  } catch (e: any) {
+    if (e.code === "ERR_MODULE_NOT_FOUND" || e.message?.includes("Cannot find")) {
+      console.error(pc.red(`Adapter not found: ${adapterPackage}`));
+      console.error(pc.dim(`Install it with: bun add ${adapterPackage}`));
+    } else {
+      console.error(pc.red(`Failed to generate client with adapter: ${adapterPackage}`));
+      console.error(pc.dim(e.message));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/generate-utils.ts

@@ -0,0 +1,140 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+
+export interface DonkeylabsConfig {
+  plugins: string[];
+  outDir?: string;
+  client?: {
+    output: string;
+  };
+  routes?: string;
+  entry?: string;
+  adapter?: string;
+}
+
+export async function loadConfig(): Promise<DonkeylabsConfig> {
+  const configPath = join(process.cwd(), "donkeylabs.config.ts");
+
+  if (!existsSync(configPath)) {
+    throw new Error("donkeylabs.config.ts not found. Run 'donkeylabs init' first.");
+  }
+
+  const config = await import(configPath);
+  return config.default;
+}
+
+export interface RouteInfo {
+  name: string;
+  prefix: string;
+  routeName: string;
+  handler: "typed" | "raw" | string;
+  inputSource?: string;
+  outputSource?: string;
+  /** SSE event schemas (for sse handler) */
+  eventsSource?: Record<string, string>;
+}
+
+export interface ProcessInfo {
+  name: string;
+  events?: Record<string, string>;
+  commands?: Record<string, string>;
+}
+
+export interface ServerOutput {
+  routes: RouteInfo[];
+  processes: ProcessInfo[];
+}
+
+/**
+ * Run the server entry file with DONKEYLABS_GENERATE=1 to get typed route metadata
+ */
+export async function extractRoutesFromServer(entryPath: string): Promise<ServerOutput> {
+  const fullPath = join(process.cwd(), entryPath);
+
+  if (!existsSync(fullPath)) {
+    console.warn(pc.yellow(`Entry file not found: ${entryPath}`));
+    return { routes: [], processes: [] };
+  }
+
+  const TIMEOUT_MS = 10000; // 10 second timeout
+
+  return new Promise((resolve) => {
+    const child = spawn("bun", [fullPath], {
+      env: { ...process.env, DONKEYLABS_GENERATE: "1" },
+      stdio: ["inherit", "pipe", "pipe"],
+      cwd: process.cwd(),
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      console.warn(pc.yellow(`Route extraction timed out after ${TIMEOUT_MS / 1000}s`));
+      console.warn(pc.dim("Make sure routes are registered with server.use() before any blocking operations"));
+      resolve({ routes: [], processes: [] });
+    }, TIMEOUT_MS);
+
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return; // Already resolved
+
+      if (code !== 0) {
+        console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
+        if (stderr) console.warn(pc.dim(stderr));
+        resolve({ routes: [], processes: [] });
+        return;
+      }
+
+      try {
+        const result = JSON.parse(stdout.trim());
+        // Convert server output to RouteInfo format
+        const routes: RouteInfo[] = (result.routes || []).map((r: any) => {
+          const parts = r.name.split(".");
+          return {
+            name: r.name,
+            prefix: parts.slice(0, -1).join("."),
+            routeName: parts[parts.length - 1] || r.name,
+            handler: r.handler || "typed",
+            // Server outputs TypeScript strings directly now
+            inputSource: r.inputType,
+            outputSource: r.outputType,
+            // SSE event schemas
+            eventsSource: r.eventsType,
+          };
+        });
+
+        // Parse process definitions
+        const processes: ProcessInfo[] = (result.processes || []).map((p: any) => ({
+          name: p.name,
+          events: p.events,
+          commands: p.commands,
+        }));
+
+        resolve({ routes, processes });
+      } catch (e) {
+        console.warn(pc.yellow("Failed to parse route data from server"));
+        resolve({ routes: [], processes: [] });
+      }
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
+      resolve({ routes: [], processes: [] });
+    });
+  });
+}

package/src/commands/generate.ts

@@ -1,35 +1,13 @@
 import { readdir, writeFile, readFile, mkdir, unlink } from "node:fs/promises";
 import { join, relative, dirname, basename } from "node:path";
 import { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
 import pc from "picocolors";
 import { Kysely, Migrator, FileMigrationProvider } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { generate, KyselyBunSqliteDialect } from "kysely-codegen";
 import * as ts from "typescript";
-
-interface DonkeylabsConfig {
-  plugins: string[];
-  outDir?: string;
-  client?: {
-    output: string;
-  };
-  routes?: string; // Route files pattern, default: "./src/routes/**/handler.ts"
-  entry?: string; // Server entry file for extracting routes, default: "./src/index.ts"
-  adapter?: string; // Adapter package for framework-specific generation, e.g., "@donkeylabs/adapter-sveltekit"
-}
-
-async function loadConfig(): Promise<DonkeylabsConfig> {
-  const configPath = join(process.cwd(), "donkeylabs.config.ts");
-
-  if (!existsSync(configPath)) {
-    throw new Error("donkeylabs.config.ts not found. Run 'donkeylabs init' first.");
-  }
-
-  const config = await import(configPath);
-  return config.default;
-}
+import { loadConfig, extractRoutesFromServer, type DonkeylabsConfig, type RouteInfo, type ProcessInfo } from "./generate-utils";
 
 async function getPluginExportName(pluginPath: string): Promise<string | null> {
   try {
@@ -55,18 +33,95 @@ async function getPluginDefinedName(pluginPath: string): Promise<string | null>
 async function extractHandlerNames(pluginPath: string): Promise<string[]> {
   try {
     const content = await readFile(pluginPath, "utf-8");
-    const handlersMatch = content.match(/handlers:\s*\{([^}]+)\}/);
-    if (!handlersMatch?.[1]) return [];
+    const astNames = extractHandlerNamesFromAst(content, pluginPath);
+    if (astNames.length > 0) {
+      return astNames;
+    }
 
-    const handlersBlock = handlersMatch[1];
-    return [...handlersBlock.matchAll(/(\w+)\s*:/g)]
-      .map((m) => m[1])
-      .filter((name): name is string => !!name);
+    return extractHandlerNamesRegexFallback(content);
   } catch {
     return [];
   }
 }
 
+function extractHandlerNamesFromAst(content: string, fileName: string): string[] {
+  const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const names = new Set<string>();
+
+  const addFromObjectLiteral = (obj: ts.ObjectLiteralExpression) => {
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
+      const propName = getStaticPropertyName(prop.name);
+      if (propName && isSafeIdentifier(propName)) {
+        names.add(propName);
+      }
+    }
+  };
+
+  const collectFromHandlersInitializer = (initializer: ts.Expression) => {
+    if (ts.isObjectLiteralExpression(initializer)) {
+      addFromObjectLiteral(initializer);
+      return;
+    }
+
+    if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+      const body = initializer.body;
+
+      if (ts.isObjectLiteralExpression(body)) {
+        addFromObjectLiteral(body);
+        return;
+      }
+
+      if (ts.isParenthesizedExpression(body) && ts.isObjectLiteralExpression(body.expression)) {
+        addFromObjectLiteral(body.expression);
+        return;
+      }
+
+      if (ts.isBlock(body)) {
+        for (const stmt of body.statements) {
+          if (!ts.isReturnStatement(stmt) || !stmt.expression) continue;
+
+          if (ts.isObjectLiteralExpression(stmt.expression)) {
+            addFromObjectLiteral(stmt.expression);
+            return;
+          }
+
+          if (
+            ts.isParenthesizedExpression(stmt.expression) &&
+            ts.isObjectLiteralExpression(stmt.expression.expression)
+          ) {
+            addFromObjectLiteral(stmt.expression.expression);
+            return;
+          }
+        }
+      }
+    }
+  };
+
+  const visit = (node: ts.Node) => {
+    if (ts.isPropertyAssignment(node)) {
+      const propName = getStaticPropertyName(node.name);
+      if (propName === "handlers") {
+        collectFromHandlersInitializer(node.initializer);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return [...names];
+}
+
+function extractHandlerNamesRegexFallback(content: string): string[] {
+  const handlersMatch = content.match(/handlers:\s*\{([^}]+)\}/);
+  if (!handlersMatch?.[1]) return [];
+
+  const handlersBlock = handlersMatch[1];
+  return [...handlersBlock.matchAll(/(\w+)\s*:/g)]
+    .map((m) => m[1])
+    .filter((name): name is string => !!name);
+}
+
 async function extractMiddlewareNames(pluginPath: string): Promise<string[]> {
   try {
     const content = await readFile(pluginPath, "utf-8");
@@ -358,82 +413,49 @@ interface EventDefinitionInfo {
 async function extractEventsFromFile(filePath: string): Promise<EventDefinitionInfo[]> {
   try {
     const content = await readFile(filePath, "utf-8");
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const events: EventDefinitionInfo[] = [];
 
-    // Find defineEvents call
-    const defineEventsMatch = content.match(/defineEvents\s*\(\s*\{/);
-    if (!defineEventsMatch || defineEventsMatch.index === undefined) {
-      return events;
-    }
-
-    // Extract the object block
-    const blockStart = defineEventsMatch.index + defineEventsMatch[0].length - 1;
-    const block = extractBalancedBlock(content, blockStart, "{", "}");
-    if (!block) return events;
-
-    // Parse event entries: "event.name": z.object({...})
-    // Match quoted keys followed by Zod schemas
-    const eventPattern = /["']([^"']+)["']\s*:\s*(z\.[^,}]+(?:\([^)]*\))?)/g;
-
-    let match;
-    const innerBlock = block.slice(1, -1); // Remove outer braces
+    const addFromObjectLiteral = (obj: ts.ObjectLiteralExpression) => {
+      for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue;
+        const eventName = getEventNameFromPropertyName(prop.name);
+        if (!eventName) continue;
 
-    // More robust extraction - find each event key and its schema
-    const keyPattern = /["']([a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)*)["']\s*:/gi;
-    let keyMatch;
-    const keyPositions: { name: string; pos: number }[] = [];
+        const schemaSource = prop.initializer.getText(sourceFile).trim();
+        if (!schemaSource) continue;
 
-    while ((keyMatch = keyPattern.exec(innerBlock)) !== null) {
-      keyPositions.push({ name: keyMatch[1]!, pos: keyMatch.index + keyMatch[0].length });
-    }
-
-    // For each key, extract the Zod schema that follows
-    for (let i = 0; i < keyPositions.length; i++) {
-      const { name, pos } = keyPositions[i]!;
-      const nextPos = keyPositions[i + 1]?.pos ?? innerBlock.length;
-
-      // Get the slice between this key and the next
-      let schemaSlice = innerBlock.slice(pos, nextPos).trim();
-
-      // Find where the Zod expression ends
-      if (schemaSlice.startsWith("z.")) {
-        // Extract balanced parentheses for the schema
-        let depth = 0;
-        let endIdx = 0;
-        let foundParen = false;
-
-        for (let j = 0; j < schemaSlice.length; j++) {
-          if (schemaSlice[j] === "(") {
-            depth++;
-            foundParen = true;
-          } else if (schemaSlice[j] === ")") {
-            depth--;
-            if (depth === 0 && foundParen) {
-              endIdx = j + 1;
-              // Check for chained methods
-              const rest = schemaSlice.slice(endIdx);
-              const chainMatch = rest.match(/^(\s*\.\w+\([^)]*\))+/);
-              if (chainMatch) {
-                endIdx += chainMatch[0].length;
-              }
-              break;
-            }
-          }
-        }
+        events.push({ name: eventName, schemaSource });
+      }
+    };
 
-        if (endIdx > 0) {
-          const schema = schemaSlice.slice(0, endIdx).trim();
-          events.push({ name, schemaSource: schema });
+    const visit = (node: ts.Node) => {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineEvents") {
+        const firstArg = node.arguments[0];
+        if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+          addFromObjectLiteral(firstArg);
         }
       }
-    }
+      ts.forEachChild(node, visit);
+    };
 
+    visit(sourceFile);
     return events;
   } catch {
     return [];
   }
 }
 
+function getEventNameFromPropertyName(name: ts.PropertyName): string | null {
+  if (ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) {
+    return name.text;
+  }
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+  return null;
+}
+
 /**
  * Find and extract server-level events from common locations.
  */
@@ -560,16 +582,7 @@ interface ExtractedRoute {
   handler: string;
 }
 
-interface RouteInfo {
-  name: string;
-  prefix: string;
-  routeName: string;
-  handler: "typed" | "raw" | string;
-  inputSource?: string;
-  outputSource?: string;
-  /** SSE event schemas (for sse handler) */
-  eventsSource?: Record<string, string>;
-}
+// RouteInfo is imported from ./generate-utils
 
 /**
  * Extract a balanced block from source code starting at a given position
@@ -792,89 +805,7 @@ async function findRouteFiles(pattern: string): Promise<string[]> {
   return files;
 }
 
-/**
- * Run the server entry file with DONKEYLABS_GENERATE=1 to get typed route metadata
- */
-async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]> {
-  const fullPath = join(process.cwd(), entryPath);
-
-  if (!existsSync(fullPath)) {
-    console.warn(pc.yellow(`Entry file not found: ${entryPath}`));
-    return [];
-  }
-
-  const TIMEOUT_MS = 10000; // 10 second timeout
-
-  return new Promise((resolve) => {
-    const child = spawn("bun", [fullPath], {
-      env: { ...process.env, DONKEYLABS_GENERATE: "1" },
-      stdio: ["inherit", "pipe", "pipe"],
-      cwd: process.cwd(),
-    });
-
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-
-    // Timeout handler
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      console.warn(pc.yellow(`Route extraction timed out after ${TIMEOUT_MS / 1000}s`));
-      console.warn(pc.dim("Make sure routes are registered with server.use() before any blocking operations"));
-      resolve([]);
-    }, TIMEOUT_MS);
-
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    child.on("close", (code) => {
-      clearTimeout(timeout);
-      if (timedOut) return; // Already resolved
-
-      if (code !== 0) {
-        console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
-        if (stderr) console.warn(pc.dim(stderr));
-        resolve([]);
-        return;
-      }
-
-      try {
-        const result = JSON.parse(stdout.trim());
-        // Convert server output to RouteInfo format
-        const routes: RouteInfo[] = (result.routes || []).map((r: any) => {
-          const parts = r.name.split(".");
-          return {
-            name: r.name,
-            prefix: parts.slice(0, -1).join("."),
-            routeName: parts[parts.length - 1] || r.name,
-            handler: r.handler || "typed",
-            // Server outputs TypeScript strings directly now
-            inputSource: r.inputType,
-            outputSource: r.outputType,
-            // SSE event schemas
-            eventsSource: r.eventsType,
-          };
-        });
-        resolve(routes);
-      } catch (e) {
-        console.warn(pc.yellow("Failed to parse route data from server"));
-        resolve([]);
-      }
-    });
-
-    child.on("error", (err) => {
-      clearTimeout(timeout);
-      console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
-      resolve([]);
-    });
-  });
-}
+// extractRoutesFromServer is imported from ./generate-utils
 
 /**
  * Generate schema.ts from plugin migrations using kysely-codegen
@@ -987,9 +918,11 @@ export async function generateCommand(_args: string[]): Promise<void> {
     );
   }
 
-  // Extract routes by running the server with DONKEYLABS_GENERATE=1
+  // Extract routes and processes by running the server with DONKEYLABS_GENERATE=1
   const entryPath = config.entry || "./src/index.ts";
-  const serverRoutes = await extractRoutesFromServer(entryPath);
+  const serverOutput = await extractRoutesFromServer(entryPath);
+  const serverRoutes = serverOutput.routes;
+  const serverProcesses = serverOutput.processes;
 
   // Find custom service definitions
   const services = await findServiceDefinitions(entryPath);
@@ -1009,13 +942,22 @@ export async function generateCommand(_args: string[]): Promise<void> {
     );
   }
 
+  // Log process definitions found
+  if (serverProcesses.length > 0) {
+    console.log(
+      pc.green("Found processes:"),
+      serverProcesses.map((p) => pc.dim(p.name)).join(", ")
+    );
+  }
+
   // Generate all files
   await generateRegistry(plugins, outPath);
   await generateContext(plugins, services, outPath);
   await generateRouteTypes(fileRoutes, outPath);
   await generateEventTypes(serverEvents, outPath);
+  await generateProcessTypes(serverProcesses, outPath);
 
-  const generated = ["registry", "context", "routes", "events"];
+  const generated = ["registry", "context", "routes", "events", "processes"];
 
   // Determine client output path
   const clientOutput = config.client?.output || join(outPath, "client.ts");
@@ -1523,3 +1465,99 @@ ${eventRegistryEntries.join("\n")}
 
   await writeFile(join(outPath, "events.ts"), content);
 }
+
+/**
+ * Generate processes.ts with typed events, commands, and ProcessRegistry augmentation.
+ */
+async function generateProcessTypes(processes: ProcessInfo[], outPath: string): Promise<void> {
+  if (processes.length === 0) {
+    const content = `// Auto-generated by donkeylabs generate
+// Processes - import as: import { type ProcessEventMap, type ProcessCommandMap } from ".@donkeylabs/server/processes";
+
+/** Map of all process event names to their data types */
+export interface ProcessEventMap {}
+
+/** Map of all process command names to their data types */
+export interface ProcessCommandMap {}
+
+// Augment ProcessRegistry for typed send() (empty when no processes defined)
+declare module "@donkeylabs/server" {
+  interface ProcessRegistry {}
+}
+`;
+    await writeFile(join(outPath, "processes.ts"), content);
+    return;
+  }
+
+  const namespaceBlocks: string[] = [];
+  const eventMapEntries: string[] = [];
+  const commandMapEntries: string[] = [];
+  const registryEntries: string[] = [];
+
+  for (const proc of processes) {
+    const pascalName = toPascalCase(proc.name);
+
+    const eventDecls: string[] = [];
+    const commandDecls: string[] = [];
+
+    // Generate event types
+    if (proc.events) {
+      for (const [eventName, tsType] of Object.entries(proc.events)) {
+        const pascalEvent = toPascalCase(eventName);
+        eventDecls.push(`    export type ${pascalEvent} = ${tsType};`);
+        eventMapEntries.push(`  "${proc.name}.${eventName}": ${pascalName}.Events.${pascalEvent};`);
+      }
+    }
+
+    // Generate command types
+    if (proc.commands) {
+      for (const [cmdName, tsType] of Object.entries(proc.commands)) {
+        const pascalCmd = toPascalCase(cmdName);
+        commandDecls.push(`    export type ${pascalCmd} = ${tsType};`);
+        commandMapEntries.push(`  "${proc.name}.${cmdName}": ${pascalName}.Commands.${pascalCmd};`);
+      }
+    }
+
+    // Build namespace
+    const eventsNs = eventDecls.length > 0
+      ? `  export namespace Events {\n${eventDecls.join("\n")}\n  }`
+      : `  export namespace Events {}`;
+    const commandsNs = commandDecls.length > 0
+      ? `  export namespace Commands {\n${commandDecls.join("\n")}\n  }`
+      : `  export namespace Commands {}`;
+
+    namespaceBlocks.push(`export namespace ${pascalName} {\n${eventsNs}\n${commandsNs}\n}`);
+
+    // Registry entry
+    registryEntries.push(`    "${proc.name}": {
+      events: ${pascalName}.Events;
+      commands: ${pascalName}.Commands;
+    };`);
+  }
+
+  const content = `// Auto-generated by donkeylabs generate
+// Processes - import as: import { type ProcessEventMap, type ProcessCommandMap } from ".@donkeylabs/server/processes";
+
+// Process type namespaces
+${namespaceBlocks.join("\n\n")}
+
+/** Map of all process event names to their data types */
+export interface ProcessEventMap {
+${eventMapEntries.join("\n")}
+}
+
+/** Map of all process command names to their data types */
+export interface ProcessCommandMap {
+${commandMapEntries.join("\n")}
+}
+
+// Augment ProcessRegistry for typed send()
+declare module "@donkeylabs/server" {
+  interface ProcessRegistry {
+${registryEntries.join("\n")}
+  }
+}
+`;
+
+  await writeFile(join(outPath, "processes.ts"), content);
+}

package/src/index.ts

@@ -20,6 +20,7 @@ const { positionals, values } = parseArgs({
     local: { type: "boolean", short: "l" },
     list: { type: "boolean" },
     output: { type: "string", short: "o" },
+    adapter: { type: "string" },
     all: { type: "boolean", short: "a" },
     check: { type: "boolean", short: "c" },
     "skip-docs": { type: "boolean" },
@@ -41,6 +42,7 @@ ${pc.bold("Commands:")}
   ${pc.cyan("init")}              Initialize a new project
   ${pc.cyan("add")}               Add optional plugins (images, auth, etc.)
   ${pc.cyan("generate")}          Generate types (registry, context, client)
+  ${pc.cyan("generate-client")}   Generate API client only (TypeScript, Swift, SvelteKit)
   ${pc.cyan("plugin")}            Plugin management
   ${pc.cyan("update")}            Check and install package updates
   ${pc.cyan("docs")}              Sync documentation from installed package
@@ -56,6 +58,7 @@ ${pc.bold("Options:")}
   -v, --version           Show version number
   -t, --type <type>       Project type for init (server, sveltekit)
   -l, --local             Use local workspace packages (for monorepo dev)
+  --adapter <adapter>     Client adapter (typescript, sveltekit, swift, or package name)
 
   ${pc.bold("Examples:")}
    donkeylabs                       # Interactive menu
@@ -63,6 +66,9 @@ ${pc.bold("Options:")}
    donkeylabs init --type server    # Server-only project
    donkeylabs init --type sveltekit # SvelteKit + adapter project
    donkeylabs generate
+   donkeylabs generate-client -o ./clients/typescript
+   donkeylabs generate-client -o ./ios/ApiClient --adapter swift
+   donkeylabs generate-client --adapter sveltekit
    donkeylabs plugin create myPlugin
    donkeylabs update                # Interactive package update
    donkeylabs update --check        # Check for updates only
@@ -115,6 +121,15 @@ async function main() {
       await generateCommand(positionals.slice(1));
       break;
 
+    case "generate-client":
+    case "gen-client":
+      const { generateClientCommand } = await import("./commands/generate-client");
+      await generateClientCommand(positionals.slice(1), {
+        output: values.output,
+        adapter: values.adapter,
+      });
+      break;
+
     case "plugin":
       const { pluginCommand } = await import("./commands/plugin");
       await pluginCommand(positionals.slice(1));