zdev 0.1.0

package/src/config.ts

@@ -0,0 +1,106 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+
+export const ZEBU_HOME = join(homedir(), ".zdev");
+export const CONFIG_PATH = join(ZEBU_HOME, "config.json");
+export const WORKTREES_DIR = join(ZEBU_HOME, "worktrees");
+export const SEEDS_DIR = join(ZEBU_HOME, "seeds");
+
+export interface WorktreeAllocation {
+  project: string;
+  projectPath: string;
+  branch: string;
+  webDir: string;  // Subdirectory containing package.json
+  frontendPort: number;
+  convexPort: number;
+  funnelPath: string;
+  pids: {
+    frontend?: number;
+    convex?: number;
+  };
+  started: string;
+}
+
+export interface zdevConfig {
+  nextFrontendPort: number;
+  nextConvexPort: number;
+  // File patterns to auto-copy from main project to worktree
+  copyPatterns: string[];
+  // Docker host IP - how Traefik reaches host services
+  // Default 172.17.0.1 works for standard Docker on Linux
+  dockerHostIp: string;
+  // Dev domain for public URLs (e.g., "dev.example.com")
+  devDomain: string;
+  // Traefik dynamic config directory
+  traefikConfigDir: string;
+  allocations: Record<string, WorktreeAllocation>;
+}
+
+const DEFAULT_CONFIG: zdevConfig = {
+  nextFrontendPort: 5173,
+  nextConvexPort: 3210,
+  copyPatterns: [
+    ".env.local",
+    ".env.development",
+    ".env.development.local",
+  ],
+  dockerHostIp: "172.17.0.1",
+  devDomain: "",
+  traefikConfigDir: "/infra/traefik/dynamic",
+  allocations: {},
+};
+
+export function ensurezdevDirs(): void {
+  if (!existsSync(ZEBU_HOME)) {
+    mkdirSync(ZEBU_HOME, { recursive: true });
+  }
+  if (!existsSync(WORKTREES_DIR)) {
+    mkdirSync(WORKTREES_DIR, { recursive: true });
+  }
+  if (!existsSync(SEEDS_DIR)) {
+    mkdirSync(SEEDS_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig(): zdevConfig {
+  ensurezdevDirs();
+  
+  if (!existsSync(CONFIG_PATH)) {
+    saveConfig(DEFAULT_CONFIG);
+    return DEFAULT_CONFIG;
+  }
+  
+  try {
+    const data = readFileSync(CONFIG_PATH, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+export function saveConfig(config: zdevConfig): void {
+  ensurezdevDirs();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function allocatePorts(config: zdevConfig, includeConvex: boolean = true): { frontend: number; convex: number } {
+  const frontend = config.nextFrontendPort;
+  config.nextFrontendPort = frontend + 1;
+  
+  let convex = 0;
+  if (includeConvex) {
+    convex = config.nextConvexPort;
+    config.nextConvexPort = convex + 1;
+  }
+  
+  return { frontend, convex };
+}
+
+export function getWorktreePath(name: string): string {
+  return join(WORKTREES_DIR, name);
+}
+
+export function getSeedPath(projectName: string): string {
+  return join(SEEDS_DIR, `${projectName}.zip`);
+}

package/src/index.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { create } from "./commands/create.js";
+import { init } from "./commands/init.js";
+import { start } from "./commands/start.js";
+import { stop } from "./commands/stop.js";
+import { list } from "./commands/list.js";
+import { clean } from "./commands/clean.js";
+import { seedExport, seedImport } from "./commands/seed.js";
+import { configCmd } from "./commands/config.js";
+
+const program = new Command();
+
+program
+  .name("zdev")
+  .description("🐂 zdev - Multi-agent worktree development environment")
+  .version("0.1.0");
+
+// zdev create
+program
+  .command("create <name>")
+  .description("Create a new TanStack Start project")
+  .option("--convex", "Add Convex backend integration")
+  .option("--flat", "Flat structure (no monorepo)")
+  .action(async (name, options) => {
+    await create(name, {
+      convex: options.convex,
+      flat: options.flat,
+    });
+  });
+
+// zdev init
+program
+  .command("init [path]")
+  .description("Initialize zdev for a project")
+  .option("-s, --seed", "Create initial seed data from current Convex state")
+  .action(async (path, options) => {
+    await init(path, options);
+  });
+
+// zdev start
+program
+  .command("start <feature>")
+  .description("Start working on a feature (creates worktree, starts servers)")
+  .option("-p, --project <path>", "Project path (default: current directory)", ".")
+  .option("--port <number>", "Frontend port (auto-allocated if not specified)", parseInt)
+  .option("--local", "Local only - skip public URL setup via Traefik")
+  .option("-s, --seed", "Import seed data into the new worktree")
+  .option("-b, --base-branch <branch>", "Base branch to create from", "origin/main")
+  .option("-w, --web-dir <dir>", "Subdirectory containing package.json (auto-detected if not specified)")
+  .action(async (feature, options) => {
+    await start(feature, options.project, {
+      port: options.port,
+      local: options.local,
+      seed: options.seed,
+      baseBranch: options.baseBranch,
+      webDir: options.webDir,
+    });
+  });
+
+// zdev stop
+program
+  .command("stop <feature>")
+  .description("Stop servers for a feature")
+  .option("-p, --project <path>", "Project path (to disambiguate features)")
+  .option("-k, --keep", "Keep worktree, just stop servers")
+  .action(async (feature, options) => {
+    await stop(feature, options);
+  });
+
+// zdev list
+program
+  .command("list")
+  .description("List active features and their status")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    await list(options);
+  });
+
+// zdev clean
+program
+  .command("clean <feature>")
+  .description("Remove a feature worktree (use after PR is merged)")
+  .option("-p, --project <path>", "Project path")
+  .option("-f, --force", "Force remove even if git worktree fails")
+  .action(async (feature, options) => {
+    await clean(feature, options);
+  });
+
+// zdev seed
+const seedCmd = program
+  .command("seed")
+  .description("Manage seed data for projects");
+
+seedCmd
+  .command("export [path]")
+  .description("Export current Convex data as seed")
+  .action(async (path) => {
+    await seedExport(path);
+  });
+
+seedCmd
+  .command("import [path]")
+  .description("Import seed data into current worktree")
+  .action(async (path) => {
+    await seedImport(path);
+  });
+
+// zdev config
+program
+  .command("config")
+  .description("View and manage zdev configuration")
+  .option("-a, --add <pattern>", "Add a file pattern to auto-copy")
+  .option("-r, --remove <pattern>", "Remove a file pattern")
+  .option("-s, --set <key=value>", "Set a config value (devDomain, dockerHostIp, traefikConfigDir)")
+  .option("-l, --list", "List current configuration")
+  .action(async (options) => {
+    await configCmd(options);
+  });
+
+// zdev status (alias for list)
+program
+  .command("status")
+  .description("Show zdev status (alias for list)")
+  .action(async () => {
+    await list({});
+  });
+
+program.parse();

package/src/utils.ts

@@ -0,0 +1,230 @@
+import { spawn, spawnSync, type SpawnOptions } from "child_process";
+import { existsSync, writeFileSync, unlinkSync } from "fs";
+import { basename, resolve } from "path";
+
+export function run(
+  command: string,
+  args: string[],
+  options?: SpawnOptions
+): { success: boolean; stdout: string; stderr: string; code: number | null } {
+  const result = spawnSync(command, args, {
+    encoding: "utf-8",
+    ...options,
+  });
+  
+  return {
+    success: result.status === 0,
+    stdout: (result.stdout as string) || "",
+    stderr: (result.stderr as string) || "",
+    code: result.status,
+  };
+}
+
+export function runBackground(
+  command: string,
+  args: string[],
+  options?: SpawnOptions
+): number | undefined {
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore",
+    ...options,
+  });
+  
+  child.unref();
+  return child.pid;
+}
+
+export function isGitRepo(path: string): boolean {
+  return existsSync(resolve(path, ".git"));
+}
+
+export function getRepoName(path: string): string {
+  const result = run("git", ["remote", "get-url", "origin"], { cwd: path });
+  if (result.success) {
+    // Extract repo name from URL
+    const url = result.stdout.trim();
+    const match = url.match(/\/([^\/]+?)(\.git)?$/);
+    if (match) return match[1];
+  }
+  return basename(resolve(path));
+}
+
+export function gitFetch(repoPath: string): boolean {
+  const result = run("git", ["fetch", "origin"], { cwd: repoPath });
+  return result.success;
+}
+
+export function createWorktree(
+  repoPath: string,
+  worktreePath: string,
+  branch: string,
+  baseBranch: string = "origin/main"
+): { success: boolean; error?: string } {
+  const result = run(
+    "git",
+    ["worktree", "add", worktreePath, "-b", branch, baseBranch],
+    { cwd: repoPath }
+  );
+  
+  if (!result.success) {
+    return { success: false, error: result.stderr };
+  }
+  return { success: true };
+}
+
+export function removeWorktree(
+  repoPath: string,
+  worktreePath: string
+): { success: boolean; error?: string } {
+  const result = run("git", ["worktree", "remove", worktreePath, "--force"], {
+    cwd: repoPath,
+  });
+  
+  if (!result.success) {
+    return { success: false, error: result.stderr };
+  }
+  
+  // Prune worktree references
+  run("git", ["worktree", "prune"], { cwd: repoPath });
+  
+  return { success: true };
+}
+
+export function listWorktrees(repoPath: string): string[] {
+  const result = run("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoPath,
+  });
+  
+  if (!result.success) return [];
+  
+  const worktrees: string[] = [];
+  const lines = result.stdout.split("\n");
+  
+  for (const line of lines) {
+    if (line.startsWith("worktree ")) {
+      worktrees.push(line.replace("worktree ", ""));
+    }
+  }
+  
+  return worktrees;
+}
+
+import { loadConfig } from "./config.js";
+
+export function traefikAddRoute(name: string, port: number): boolean {
+  const config = loadConfig();
+  const configPath = `${config.traefikConfigDir}/${name}.yml`;
+  const subdomain = name;
+  
+  const traefikConfig = `# zdev auto-generated config for ${name}
+http:
+  routers:
+    ${name}:
+      rule: "Host(\`${subdomain}.${config.devDomain}\`)"
+      entrypoints:
+        - websecure
+      service: ${name}
+      tls:
+        certResolver: myresolver
+
+  services:
+    ${name}:
+      loadBalancer:
+        servers:
+          - url: "http://${config.dockerHostIp}:${port}"
+`;
+
+  try {
+    writeFileSync(configPath, traefikConfig);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function traefikRemoveRoute(name: string): boolean {
+  const zdevConfig = loadConfig();
+  const configPath = `${zdevConfig.traefikConfigDir}/${name}.yml`;
+  
+  try {
+    if (existsSync(configPath)) {
+      unlinkSync(configPath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getTraefikStatus(): { baseUrl?: string; running: boolean; devDomain?: string } {
+  const config = loadConfig();
+  
+  // If devDomain not configured, can't do public URLs
+  if (!config.devDomain) {
+    return { running: false, devDomain: undefined };
+  }
+  
+  // Check if Traefik config dir exists (don't need API - just file provider)
+  const configDirExists = existsSync(config.traefikConfigDir);
+  
+  return {
+    running: configDirExists,
+    baseUrl: configDirExists ? `https://*.${config.devDomain}` : undefined,
+    devDomain: config.devDomain,
+  };
+}
+
+// Legacy Tailscale functions (kept for compatibility)
+export function tailscaleServe(path: string, port: number): boolean {
+  const result = run("tailscale", [
+    "funnel",
+    "--bg",
+    "--set-path",
+    path,
+    `http://127.0.0.1:${port}`,
+  ]);
+  return result.success;
+}
+
+export function tailscaleRemove(path: string): boolean {
+  const result = run("tailscale", ["funnel", "--set-path", path, "off"]);
+  return result.success;
+}
+
+export function getTailscaleStatus(): { baseUrl?: string; running: boolean } {
+  const result = run("tailscale", ["status", "--json"]);
+  
+  if (!result.success) {
+    return { running: false };
+  }
+  
+  try {
+    const status = JSON.parse(result.stdout);
+    const dnsName = status.Self?.DNSName?.replace(/\.$/, "");
+    return {
+      running: true,
+      baseUrl: dnsName ? `https://${dnsName}` : undefined,
+    };
+  } catch {
+    return { running: false };
+  }
+}
+
+export function killProcess(pid: number): boolean {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}