@donkeylabs/cli 2.0.14 → 2.0.16

package/src/deployment/manager.ts

@@ -0,0 +1,356 @@
+// packages/cli/src/deployment/manager.ts
+/**
+ * Deployment Management System
+ * Handles deployment history, versioning, rollbacks
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+
+export interface DeploymentConfig {
+  projectName: string;
+  platform: "vercel" | "cloudflare" | "aws" | "vps";
+  environment: "production" | "staging" | "development";
+  versionStrategy: "semver" | "git-sha" | "timestamp";
+}
+
+export interface Deployment {
+  id: string;
+  version: string;
+  platform: string;
+  environment: string;
+  timestamp: string;
+  gitSha: string;
+  gitMessage: string;
+  status: "success" | "failed" | "rolling-back";
+  url?: string;
+  logs: string[];
+  metadata: Record<string, any>;
+}
+
+export interface DeploymentHistory {
+  deployments: Deployment[];
+  currentVersion: string;
+  lastDeployedAt: string;
+}
+
+export class DeploymentManager {
+  private projectDir: string;
+  private historyFile: string;
+  private config: DeploymentConfig;
+
+  constructor(projectDir: string, config: DeploymentConfig) {
+    this.projectDir = projectDir;
+    this.config = config;
+    this.historyFile = join(projectDir, ".donkeylabs", "deployments.json");
+    this.ensureHistoryDir();
+  }
+
+  /**
+   * Get next version based on strategy
+   */
+  getNextVersion(bump: "major" | "minor" | "patch" = "patch"): string {
+    const { versionStrategy } = this.config;
+    
+    if (versionStrategy === "git-sha") {
+      return this.getGitSha();
+    }
+    
+    if (versionStrategy === "timestamp") {
+      return Date.now().toString();
+    }
+    
+    // Semver
+    const current = this.getCurrentVersion();
+    const [major, minor, patch] = current.split(".").map(Number);
+    
+    switch (bump) {
+      case "major":
+        return `${major + 1}.0.0`;
+      case "minor":
+        return `${major}.${minor + 1}.0`;
+      case "patch":
+      default:
+        return `${major}.${minor}.${patch + 1}`;
+    }
+  }
+
+  /**
+   * Record a new deployment
+   */
+  async recordDeployment(
+    version: string,
+    platform: string,
+    status: Deployment["status"],
+    url?: string,
+    metadata?: Record<string, any>
+  ): Promise<Deployment> {
+    const deployment: Deployment = {
+      id: randomUUID(),
+      version,
+      platform,
+      environment: this.config.environment,
+      timestamp: new Date().toISOString(),
+      gitSha: this.getGitSha(),
+      gitMessage: this.getGitMessage(),
+      status,
+      url,
+      logs: [],
+      metadata: metadata || {},
+    };
+
+    const history = this.getHistory();
+    history.deployments.unshift(deployment);
+    history.currentVersion = version;
+    history.lastDeployedAt = deployment.timestamp;
+    
+    // Keep only last 50 deployments
+    history.deployments = history.deployments.slice(0, 50);
+    
+    this.saveHistory(history);
+    
+    return deployment;
+  }
+
+  /**
+   * Get deployment history
+   */
+  getHistory(): DeploymentHistory {
+    if (!existsSync(this.historyFile)) {
+      return {
+        deployments: [],
+        currentVersion: "0.0.0",
+        lastDeployedAt: "",
+      };
+    }
+
+    return JSON.parse(readFileSync(this.historyFile, "utf-8"));
+  }
+
+  /**
+   * Get specific deployment
+   */
+  getDeployment(deploymentId: string): Deployment | null {
+    const history = this.getHistory();
+    return history.deployments.find((d) => d.id === deploymentId) || null;
+  }
+
+  /**
+   * Get last successful deployment
+   */
+  getLastSuccessfulDeployment(): Deployment | null {
+    const history = this.getHistory();
+    return history.deployments.find((d) => d.status === "success") || null;
+  }
+
+  /**
+   * Rollback to previous version
+   */
+  async rollback(toVersion?: string): Promise<Deployment | null> {
+    const history = this.getHistory();
+    
+    // Find target deployment
+    let targetDeployment: Deployment | undefined;
+    
+    if (toVersion) {
+      targetDeployment = history.deployments.find((d) => d.version === toVersion);
+    } else {
+      // Find last successful deployment before current
+      const currentIndex = history.deployments.findIndex(
+        (d) => d.version === history.currentVersion
+      );
+      targetDeployment = history.deployments
+        .slice(currentIndex + 1)
+        .find((d) => d.status === "success");
+    }
+
+    if (!targetDeployment) {
+      throw new Error("No previous successful deployment found to rollback to");
+    }
+
+    // Checkout the git sha
+    try {
+      execSync(`git checkout ${targetDeployment.gitSha}`, {
+        cwd: this.projectDir,
+        stdio: "pipe",
+      });
+
+      // Mark as rolling back
+      targetDeployment.status = "rolling-back";
+      this.saveHistory(history);
+
+      // Redeploy
+      await this.redeploy(targetDeployment);
+
+      // Record the rollback
+      const rollbackDeployment = await this.recordDeployment(
+        `${targetDeployment.version}-rollback`,
+        targetDeployment.platform,
+        "success",
+        targetDeployment.url,
+        { rollbackFrom: history.currentVersion, originalDeployment: targetDeployment.id }
+      );
+
+      return rollbackDeployment;
+    } catch (error) {
+      // Revert git checkout
+      execSync("git checkout -", { cwd: this.projectDir, stdio: "pipe" });
+      throw error;
+    }
+  }
+
+  /**
+   * Get deployment statistics
+   */
+  getStats(): {
+    totalDeployments: number;
+    successfulDeployments: number;
+    failedDeployments: number;
+    rollbackCount: number;
+    averageDeployTime: number;
+    deploymentsByPlatform: Record<string, number>;
+  } {
+    const history = this.getHistory();
+    const deployments = history.deployments;
+
+    const successful = deployments.filter((d) => d.status === "success");
+    const failed = deployments.filter((d) => d.status === "failed");
+    const rollbacks = deployments.filter((d) => d.metadata?.rollbackFrom);
+
+    const byPlatform: Record<string, number> = {};
+    for (const d of deployments) {
+      byPlatform[d.platform] = (byPlatform[d.platform] || 0) + 1;
+    }
+
+    return {
+      totalDeployments: deployments.length,
+      successfulDeployments: successful.length,
+      failedDeployments: failed.length,
+      rollbackCount: rollbacks.length,
+      averageDeployTime: 0, // Would need to track start/end times
+      deploymentsByPlatform: byPlatform,
+    };
+  }
+
+  /**
+   * List deployments with filtering
+   */
+  listDeployments(options?: {
+    platform?: string;
+    status?: Deployment["status"];
+    limit?: number;
+  }): Deployment[] {
+    let deployments = this.getHistory().deployments;
+
+    if (options?.platform) {
+      deployments = deployments.filter((d) => d.platform === options.platform);
+    }
+
+    if (options?.status) {
+      deployments = deployments.filter((d) => d.status === options.status);
+    }
+
+    if (options?.limit) {
+      deployments = deployments.slice(0, options.limit);
+    }
+
+    return deployments;
+  }
+
+  /**
+   * Compare two deployments
+   */
+  compareDeployments(deploymentId1: string, deploymentId2: string): {
+    deployment1: Deployment;
+    deployment2: Deployment;
+    gitDiff: string;
+  } {
+    const d1 = this.getDeployment(deploymentId1);
+    const d2 = this.getDeployment(deploymentId2);
+
+    if (!d1 || !d2) {
+      throw new Error("One or both deployments not found");
+    }
+
+    const diff = execSync(
+      `git log --oneline ${d2.gitSha}..${d1.gitSha}`,
+      { cwd: this.projectDir, encoding: "utf-8" }
+    );
+
+    return {
+      deployment1: d1,
+      deployment2: d2,
+      gitDiff: diff,
+    };
+  }
+
+  private ensureHistoryDir(): void {
+    const dir = join(this.projectDir, ".donkeylabs");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  private saveHistory(history: DeploymentHistory): void {
+    writeFileSync(this.historyFile, JSON.stringify(history, null, 2));
+  }
+
+  private getCurrentVersion(): string {
+    const pkgPath = join(this.projectDir, "package.json");
+    if (!existsSync(pkgPath)) {
+      return "0.0.0";
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  }
+
+  private getGitSha(): string {
+    try {
+      return execSync("git rev-parse --short HEAD", {
+        cwd: this.projectDir,
+        encoding: "utf-8",
+      }).trim();
+    } catch {
+      return "unknown";
+    }
+  }
+
+  private getGitMessage(): string {
+    try {
+      return execSync("git log -1 --pretty=%B", {
+        cwd: this.projectDir,
+        encoding: "utf-8",
+      }).trim();
+    } catch {
+      return "unknown";
+    }
+  }
+
+  private async redeploy(deployment: Deployment): Promise<void> {
+    // Platform-specific redeploy logic
+    switch (deployment.platform) {
+      case "vercel":
+        execSync("vercel --prod", {
+          cwd: this.projectDir,
+          stdio: "inherit",
+        });
+        break;
+      case "cloudflare":
+        execSync("wrangler deploy", {
+          cwd: this.projectDir,
+          stdio: "inherit",
+        });
+        break;
+      // Add other platforms
+    }
+  }
+}
+
+export function createDeploymentManager(
+  projectDir: string,
+  config: DeploymentConfig
+): DeploymentManager {
+  return new DeploymentManager(projectDir, config);
+}

package/src/index.ts

@@ -17,6 +17,7 @@ const { positionals, values } = parseArgs({
     help: { type: "boolean", short: "h" },
     version: { type: "boolean", short: "v" },
     type: { type: "string", short: "t" },
+    local: { type: "boolean", short: "l" },
   },
   allowPositionals: true,
 });
@@ -32,24 +33,33 @@ ${pc.bold("Usage:")}
   donkeylabs <command> [options]
 
 ${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("plugin")}       Plugin management
-  ${pc.cyan("mcp")}          Setup MCP server for AI-assisted development
+  ${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("plugin")}            Plugin management
+  ${pc.cyan("deploy")} <platform> Deploy (vercel, cloudflare, aws, vps)
+  ${pc.cyan("deploy history")}     Show deployment history
+  ${pc.cyan("deploy rollback")}    Rollback to version
+  ${pc.cyan("deploy stats")}       Show deployment statistics
+  ${pc.cyan("config")}            Configure plugins, deployment, database
+  ${pc.cyan("mcp")}               Setup MCP server for AI-assisted development
 
 ${pc.bold("Options:")}
   -h, --help              Show this help message
   -v, --version           Show version number
   -t, --type <type>       Project type for init (server, sveltekit)
-
-${pc.bold("Examples:")}
-  donkeylabs                       # Interactive menu
-  donkeylabs init                  # Interactive project setup
-  donkeylabs init --type server    # Server-only project
-  donkeylabs init --type sveltekit # SvelteKit + adapter project
-  donkeylabs generate
-  donkeylabs plugin create myPlugin
+  -l, --local             Use local workspace packages (for monorepo dev)
+
+  ${pc.bold("Examples:")}
+   donkeylabs                       # Interactive menu
+   donkeylabs init                  # Interactive project setup
+   donkeylabs init --type server    # Server-only project
+   donkeylabs init --type sveltekit # SvelteKit + adapter project
+   donkeylabs generate
+   donkeylabs plugin create myPlugin
+   donkeylabs deploy vercel         # Deploy to Vercel
+   donkeylabs config                # Interactive configuration
+   donkeylabs config set DATABASE_URL postgresql://...
 `);
 }
 
@@ -78,12 +88,8 @@ async function main() {
 
   switch (command) {
     case "init":
-      const { initCommand } = await import("./commands/init");
-      const initArgs = [...positionals.slice(1)];
-      if (values.type) {
-        initArgs.push("--type", values.type);
-      }
-      await initCommand(initArgs);
+      const { initEnhancedCommand } = await import("./commands/init-enhanced");
+      await initEnhancedCommand(positionals.slice(1), { useLocalPackages: values.local });
       break;
 
     case "add":
@@ -107,6 +113,28 @@ async function main() {
       await mcpCommand(positionals.slice(1));
       break;
 
+    case "deploy":
+      const subcommand = positionals[1];
+      if (subcommand === "history") {
+        const { deployHistoryCommand } = await import("./commands/deploy-enhanced");
+        await deployHistoryCommand(positionals.slice(2));
+      } else if (subcommand === "rollback") {
+        const { deployRollbackCommand } = await import("./commands/deploy-enhanced");
+        await deployRollbackCommand(positionals.slice(2));
+      } else if (subcommand === "stats") {
+        const { deployStatsCommand } = await import("./commands/deploy-enhanced");
+        await deployStatsCommand();
+      } else {
+        const { deployEnhancedCommand } = await import("./commands/deploy-enhanced");
+        await deployEnhancedCommand(positionals.slice(1));
+      }
+      break;
+
+    case "config":
+      const { configCommand } = await import("./commands/config");
+      await configCommand(positionals.slice(1));
+      break;
+
     default:
       console.error(pc.red(`Unknown command: ${command}`));
       console.log(`Run ${pc.cyan("donkeylabs --help")} for available commands.`);

package/templates/starter/.env.example

@@ -1,44 +0,0 @@
-# =============================================================================
-# DATABASE
-# =============================================================================
-
-# SQLite database path (relative to project root)
-# Use ":memory:" for in-memory database during development
-DATABASE_URL=":memory:"
-
-# For production, use a file path:
-# DATABASE_URL="./data/app.db"
-
-# =============================================================================
-# SERVER
-# =============================================================================
-
-# Port for the API server
-PORT=3000
-
-# Node environment
-NODE_ENV=development
-
-# =============================================================================
-# AUTHENTICATION (if using auth plugin)
-# =============================================================================
-
-# JWT secret for signing tokens (generate with: openssl rand -base64 32)
-# JWT_SECRET=your-secret-key-here
-
-# =============================================================================
-# EXTERNAL SERVICES (examples)
-# =============================================================================
-
-# Email service
-# RESEND_API_KEY=re_xxxxxxxxxxxx
-
-# Payment processing
-# STRIPE_SECRET_KEY=sk_test_xxxxxxxxxxxx
-
-# =============================================================================
-# FEATURE FLAGS
-# =============================================================================
-
-# Enable debug logging
-# DEBUG=true

package/templates/starter/.gitignore.template

@@ -1,4 +0,0 @@
-node_modules/
-.@donkeylabs/
-*.db
-.env

package/templates/starter/donkeylabs.config.ts

@@ -1,6 +0,0 @@
-import { defineConfig } from "@donkeylabs/server";
-
-export default defineConfig({
-  plugins: ["./src/plugins/**/index.ts"],
-  outDir: ".@donkeylabs/server",
-});

package/templates/starter/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "my-donkeylabs-app",
-  "version": "0.0.1",
-  "type": "module",
-  "scripts": {
-    "dev": "bun --watch src/index.ts",
-    "start": "bun src/index.ts",
-    "test": "bun test",
-    "gen:types": "donkeylabs generate"
-  },
-  "dependencies": {
-    "@donkeylabs/server": "^2.0.15",
-    "kysely": "^0.27.0",
-    "kysely-bun-sqlite": "^0.3.0",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@donkeylabs/cli": "^2.0.11",
-    "@types/bun": "latest"
-  }
-}

package/templates/starter/src/index.ts

@@ -1,54 +0,0 @@
-import { AppServer, createRouter } from "@donkeylabs/server";
-import { Kysely } from "kysely";
-import { BunSqliteDialect } from "kysely-bun-sqlite";
-import { Database } from "bun:sqlite";
-import { healthRouter } from "./routes/health";
-import { statsPlugin } from "./plugins/stats";
-
-// Simple in-memory database
-const db = new Kysely<{}>({
-  dialect: new BunSqliteDialect({ database: new Database(":memory:") }),
-});
-
-const server = new AppServer({
-  port: Number(process.env.PORT) || 3000,
-  db,
-  config: { env: process.env.NODE_ENV || "development" },
-  generateTypes: {
-    output: "./.@donkeylabs/server/api.ts",
-    baseImport: 'import { ApiClientBase, type ApiClientOptions } from "@donkeylabs/server/client";',
-    baseClass: "ApiClientBase",
-    constructorSignature: "baseUrl: string, options?: ApiClientOptions",
-    constructorBody: "super(baseUrl, options);",
-    factoryFunction: `/**
- * Create an API client instance
- * @param baseUrl - The base URL of the API server
- */
-export function createApi(baseUrl: string, options?: ApiClientOptions) {
-  return new ApiClient(baseUrl, options);
-}`,
-  },
-});
-
-// Register plugins
-server.registerPlugin(statsPlugin);
-
-const api = createRouter("api");
-// Register routes
-api.router(healthRouter);
-
-server.use(api);
-
-// Handle DONKEYLABS_GENERATE mode for CLI type generation
-if (process.env.DONKEYLABS_GENERATE === "1") {
-  const routes = api.getRoutes().map((route) => ({
-    name: route.name,
-    handler: route.handler || "typed",
-    inputType: route.input ? "(generated)" : undefined,
-    outputType: route.output ? "(generated)" : undefined,
-  }));
-  console.log(JSON.stringify({ routes }));
-  process.exit(0);
-}
-
-await server.start();

package/templates/starter/src/plugins/stats/index.ts

@@ -1,105 +0,0 @@
-import { createPlugin, createMiddleware } from "@donkeylabs/server";
-
-export interface RequestStats {
-  totalRequests: number;
-  avgResponseTime: number;
-  minResponseTime: number;
-  maxResponseTime: number;
-  requestsPerRoute: Map<string, number>;
-}
-
-export interface StatsService {
-  /** Record a request with its duration */
-  recordRequest(route: string, durationMs: number): void;
-  /** Get current stats snapshot */
-  getStats(): RequestStats;
-  /** Reset all stats */
-  reset(): void;
-}
-
-export const statsPlugin = createPlugin.define({
-  name: "stats",
-  version: "1.0.0",
-
-  // Service must come before middleware for TypeScript to infer the Service type
-  service: async (ctx): Promise<StatsService> => {
-    const logger = ctx.core.logger.child({ plugin: "stats" });
-
-    // In-memory stats
-    let totalRequests = 0;
-    let totalTime = 0;
-    let minTime = Infinity;
-    let maxTime = 0;
-    const requestsPerRoute = new Map<string, number>();
-
-    function getStats(): RequestStats {
-      return {
-        totalRequests,
-        avgResponseTime: totalRequests > 0 ? totalTime / totalRequests : 0,
-        minResponseTime: minTime,
-        maxResponseTime: maxTime,
-        requestsPerRoute: new Map(requestsPerRoute),
-      };
-    }
-
-    logger.info("Stats plugin initialized");
-
-    return {
-      recordRequest(route: string, durationMs: number) {
-        totalRequests++;
-        totalTime += durationMs;
-        minTime = Math.min(minTime, durationMs);
-        maxTime = Math.max(maxTime, durationMs);
-        requestsPerRoute.set(route, (requestsPerRoute.get(route) ?? 0) + 1);
-
-        logger.debug("Request recorded", { route, durationMs: durationMs.toFixed(2) });
-      },
-
-      getStats,
-
-      reset() {
-        totalRequests = 0;
-        totalTime = 0;
-        minTime = Infinity;
-        maxTime = 0;
-        requestsPerRoute.clear();
-        logger.info("Stats reset");
-      },
-    };
-  },
-
-  // Middleware - ctx is typed PluginContext, service is typed StatsService
-  middleware: (ctx, service) => ({
-    /** Timing middleware - records request duration and updates stats */
-    timing: createMiddleware(async (req, _reqCtx, next) => {
-      const logger = ctx.core.logger;
-      const route = new URL(req.url).pathname.slice(1);
-      const start = performance.now();
-      const response = await next();
-      const duration = performance.now() - start;
-
-      // Use own service to record stats - service is typed!
-      service.recordRequest(route, duration);
-      logger.info("Request processed", { route, durationMs: duration.toFixed(2) });
-
-      return response;
-    }),
-  }),
-
-  // Register crons, events, etc. after service is created
-  init: (ctx, service) => {
-    const logger = ctx.core.logger.child({ plugin: "stats" });
-
-    // Log stats every minute
-    ctx.core.cron.schedule("* * * * *", () => {
-      const stats = service.getStats();
-      logger.info("Server stats", {
-        requests: stats.totalRequests,
-        avgMs: stats.avgResponseTime.toFixed(2),
-        minMs: stats.minResponseTime === Infinity ? 0 : stats.minResponseTime.toFixed(2),
-        maxMs: stats.maxResponseTime.toFixed(2),
-        routes: Object.fromEntries(stats.requestsPerRoute),
-      });
-    }, { name: "stats-reporter" });
-  },
-});