@atercates/claude-deck 0.2.1

package/lib/env-setup.ts

@@ -0,0 +1,285 @@
+/**
+ * Environment Setup for Worktrees
+ *
+ * Handles copying env files, installing dependencies, and running setup scripts
+ * when creating new worktrees.
+ */
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+
+const execAsync = promisify(exec);
+
+export interface WorktreeConfig {
+  setup?: string[];
+  devServer?: {
+    command: string;
+    portEnvVar?: string;
+  };
+}
+
+export interface SetupResult {
+  success: boolean;
+  steps: Array<{
+    name: string;
+    command: string;
+    success: boolean;
+    output?: string;
+    error?: string;
+  }>;
+  envFilesCopied: string[];
+  packageManager?: string;
+  port?: number;
+}
+
+/**
+ * Read worktree config from project
+ */
+export async function readWorktreeConfig(
+  projectPath: string
+): Promise<WorktreeConfig | null> {
+  const configPaths = [
+    path.join(projectPath, ".claude-deck", "worktrees.json"),
+    path.join(projectPath, ".claude-deck.json"),
+  ];
+
+  for (const configPath of configPaths) {
+    try {
+      if (fs.existsSync(configPath)) {
+        const content = await fs.promises.readFile(configPath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+      // Continue to next path
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detect package manager from lockfiles
+ */
+export function detectPackageManager(projectPath: string): {
+  name: string;
+  installCommand: string;
+} | null {
+  const lockfiles = [
+    { file: "bun.lockb", name: "bun", command: "bun install" },
+    { file: "pnpm-lock.yaml", name: "pnpm", command: "pnpm install" },
+    { file: "yarn.lock", name: "yarn", command: "yarn install" },
+    { file: "package-lock.json", name: "npm", command: "npm install" },
+  ];
+
+  for (const { file, name, command } of lockfiles) {
+    if (fs.existsSync(path.join(projectPath, file))) {
+      return { name, installCommand: command };
+    }
+  }
+
+  // Fallback: check if package.json exists
+  if (fs.existsSync(path.join(projectPath, "package.json"))) {
+    return { name: "npm", installCommand: "npm install" };
+  }
+
+  return null;
+}
+
+/**
+ * Find env files to copy (excludes .env.example)
+ */
+export function findEnvFiles(projectPath: string): string[] {
+  try {
+    const files = fs.readdirSync(projectPath);
+    return files.filter(
+      (f) =>
+        f.startsWith(".env") &&
+        !f.endsWith(".example") &&
+        fs.statSync(path.join(projectPath, f)).isFile()
+    );
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Copy env files from source to worktree
+ */
+export async function copyEnvFiles(
+  sourcePath: string,
+  worktreePath: string
+): Promise<string[]> {
+  const envFiles = findEnvFiles(sourcePath);
+  const copied: string[] = [];
+
+  for (const file of envFiles) {
+    try {
+      const src = path.join(sourcePath, file);
+      const dest = path.join(worktreePath, file);
+      await fs.promises.copyFile(src, dest);
+      copied.push(file);
+    } catch (error) {
+      console.error(`Failed to copy ${file}:`, error);
+    }
+  }
+
+  return copied;
+}
+
+/**
+ * Run a setup command in the worktree directory
+ */
+async function runCommand(
+  command: string,
+  cwd: string,
+  env: Record<string, string> = {}
+): Promise<{ success: boolean; output: string; error?: string }> {
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd,
+      timeout: 300000, // 5 minutes
+      env: { ...process.env, ...env },
+    });
+    return {
+      success: true,
+      output: stdout + (stderr ? `\n${stderr}` : ""),
+    };
+  } catch (error: unknown) {
+    const err = error as { stdout?: string; stderr?: string; message?: string };
+    return {
+      success: false,
+      output: err.stdout || "",
+      error: err.stderr || err.message || "Unknown error",
+    };
+  }
+}
+
+/**
+ * Run setup for a new worktree
+ */
+export async function setupWorktree(options: {
+  worktreePath: string;
+  sourcePath: string;
+  port?: number;
+  skipInstall?: boolean;
+}): Promise<SetupResult> {
+  const { worktreePath, sourcePath, port, skipInstall } = options;
+
+  const result: SetupResult = {
+    success: true,
+    steps: [],
+    envFilesCopied: [],
+    port,
+  };
+
+  // 1. Read config if exists
+  const config = await readWorktreeConfig(sourcePath);
+
+  // 2. Copy env files
+  result.envFilesCopied = await copyEnvFiles(sourcePath, worktreePath);
+  if (result.envFilesCopied.length > 0) {
+    result.steps.push({
+      name: "Copy env files",
+      command: `cp ${result.envFilesCopied.join(" ")}`,
+      success: true,
+      output: `Copied: ${result.envFilesCopied.join(", ")}`,
+    });
+  }
+
+  // Build env vars for commands
+  const envVars: Record<string, string> = {
+    ROOT_WORKTREE_PATH: sourcePath,
+    WORKTREE_PATH: worktreePath,
+  };
+  if (port) {
+    envVars.PORT = String(port);
+  }
+
+  // 3. Run config setup commands if present
+  if (config?.setup && config.setup.length > 0) {
+    for (const cmd of config.setup) {
+      // Expand variables in command
+      let expandedCmd = cmd;
+      for (const [key, value] of Object.entries(envVars)) {
+        expandedCmd = expandedCmd.replace(new RegExp(`\\$${key}`, "g"), value);
+      }
+
+      const cmdResult = await runCommand(expandedCmd, worktreePath, envVars);
+      result.steps.push({
+        name: `Config: ${cmd.slice(0, 50)}${cmd.length > 50 ? "..." : ""}`,
+        command: expandedCmd,
+        success: cmdResult.success,
+        output: cmdResult.output,
+        error: cmdResult.error,
+      });
+
+      if (!cmdResult.success) {
+        result.success = false;
+      }
+    }
+  } else if (!skipInstall) {
+    // 4. Auto-detect and install dependencies
+    const pm = detectPackageManager(sourcePath);
+    if (pm) {
+      result.packageManager = pm.name;
+      const installResult = await runCommand(
+        pm.installCommand,
+        worktreePath,
+        envVars
+      );
+      result.steps.push({
+        name: `Install dependencies (${pm.name})`,
+        command: pm.installCommand,
+        success: installResult.success,
+        output: installResult.output,
+        error: installResult.error,
+      });
+
+      if (!installResult.success) {
+        result.success = false;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get dev server command from config or package.json
+ */
+export async function getDevServerCommand(
+  projectPath: string,
+  port?: number
+): Promise<{ command: string; port: number } | null> {
+  // Check config first
+  const config = await readWorktreeConfig(projectPath);
+  if (config?.devServer) {
+    const portEnvVar = config.devServer.portEnvVar || "PORT";
+    const finalPort = port || 3000;
+    return {
+      command: `${portEnvVar}=${finalPort} ${config.devServer.command}`,
+      port: finalPort,
+    };
+  }
+
+  // Check package.json for dev script
+  const pkgPath = path.join(projectPath, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await fs.promises.readFile(pkgPath, "utf-8"));
+      if (pkg.scripts?.dev) {
+        const finalPort = port || 3000;
+        return {
+          command: `PORT=${finalPort} npm run dev`,
+          port: finalPort,
+        };
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  return null;
+}

package/lib/file-upload.ts

@@ -0,0 +1,34 @@
+/**
+ * Upload a file to temporary storage and return its path.
+ * Converts the file to base64 and POSTs to /api/files/upload-temp.
+ *
+ * @param file - The file to upload
+ * @returns The path to the uploaded file, or null if upload failed
+ */
+export async function uploadFileToTemp(file: File): Promise<string | null> {
+  const buffer = await file.arrayBuffer();
+  const base64 = btoa(
+    new Uint8Array(buffer).reduce(
+      (data, byte) => data + String.fromCharCode(byte),
+      ""
+    )
+  );
+
+  const res = await fetch("/api/files/upload-temp", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      filename: file.name || `file-${Date.now()}`,
+      base64,
+      mimeType: file.type || "application/octet-stream",
+    }),
+  });
+
+  const data = await res.json();
+  if (data.path) {
+    return data.path;
+  }
+
+  console.error("Upload failed:", data.error);
+  return null;
+}

package/lib/file-utils.ts

@@ -0,0 +1,50 @@
+/**
+ * Client-safe file utilities (no Node.js dependencies)
+ */
+
+export interface FileNode {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  size?: number;
+  extension?: string;
+  children?: FileNode[];
+}
+
+/**
+ * Get file extension for syntax highlighting
+ */
+export function getLanguageFromExtension(ext: string): string {
+  const languageMap: Record<string, string> = {
+    js: "javascript",
+    jsx: "javascript",
+    ts: "typescript",
+    tsx: "typescript",
+    py: "python",
+    rb: "ruby",
+    go: "go",
+    rs: "rust",
+    java: "java",
+    c: "c",
+    cpp: "cpp",
+    cs: "csharp",
+    php: "php",
+    html: "html",
+    css: "css",
+    scss: "scss",
+    json: "json",
+    xml: "xml",
+    yaml: "yaml",
+    yml: "yaml",
+    md: "markdown",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    sql: "sql",
+    graphql: "graphql",
+    vue: "vue",
+    svelte: "svelte",
+  };
+
+  return languageMap[ext.toLowerCase()] || "plaintext";
+}

package/lib/files.ts

@@ -0,0 +1,207 @@
+/**
+ * File system utilities for file explorer (server-only)
+ */
+
+import { readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import { join, extname } from "path";
+
+// Re-export client-safe types and utilities
+export type { FileNode } from "./file-utils";
+export { getLanguageFromExtension } from "./file-utils";
+import type { FileNode } from "./file-utils";
+
+/**
+ * Default exclude patterns (matches common ignore patterns)
+ */
+const DEFAULT_EXCLUDES = [
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".cache",
+  ".vercel",
+  ".turbo",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".venv",
+  "venv",
+  ".DS_Store",
+  "*.log",
+  ".env",
+  ".env.local",
+  ".env.*.local",
+  "*.db",
+  "*.db-wal",
+  "*.db-shm",
+];
+
+/**
+ * Check if a file/directory should be excluded
+ */
+function shouldExclude(name: string, excludePatterns: string[]): boolean {
+  return excludePatterns.some((pattern) => {
+    if (pattern.includes("*")) {
+      // Simple glob pattern matching
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      return regex.test(name);
+    }
+    return name === pattern;
+  });
+}
+
+/**
+ * List directory contents with exclusions
+ */
+export function listDirectory(
+  dirPath: string,
+  options: {
+    excludePatterns?: string[];
+    recursive?: boolean;
+    maxDepth?: number;
+    currentDepth?: number;
+  } = {}
+): FileNode[] {
+  const {
+    excludePatterns = DEFAULT_EXCLUDES,
+    recursive = false,
+    maxDepth = 3,
+    currentDepth = 0,
+  } = options;
+
+  try {
+    const entries = readdirSync(dirPath);
+    const nodes: FileNode[] = [];
+
+    for (const entry of entries) {
+      // Skip excluded files
+      if (shouldExclude(entry, excludePatterns)) {
+        continue;
+      }
+
+      const fullPath = join(dirPath, entry);
+      let stat;
+
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        // Permission denied or other error, skip
+        continue;
+      }
+
+      const isDir = stat.isDirectory();
+      const node: FileNode = {
+        name: entry,
+        path: fullPath,
+        type: isDir ? "directory" : "file",
+      };
+
+      if (!isDir) {
+        node.size = stat.size;
+        node.extension = extname(entry).slice(1); // Remove leading dot
+      }
+
+      // Recursively load children if requested and not at max depth
+      if (isDir && recursive && currentDepth < maxDepth) {
+        node.children = listDirectory(fullPath, {
+          excludePatterns,
+          recursive: true,
+          maxDepth,
+          currentDepth: currentDepth + 1,
+        });
+      }
+
+      nodes.push(node);
+    }
+
+    // Sort: directories first, then files, alphabetically within each group
+    return nodes.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "directory" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+  } catch (error) {
+    console.error(`Failed to list directory ${dirPath}:`, error);
+    return [];
+  }
+}
+
+/**
+ * Read file contents with encoding detection
+ */
+export function readFileContent(
+  filePath: string,
+  options: { maxSize?: number } = {}
+): { content: string; isBinary: boolean; size: number } {
+  const { maxSize = 1024 * 1024 } = options; // Default 1MB max
+
+  try {
+    const stat = statSync(filePath);
+
+    if (stat.size > maxSize) {
+      return {
+        content: `File too large (${(stat.size / 1024 / 1024).toFixed(2)}MB). Maximum size: ${(maxSize / 1024 / 1024).toFixed(2)}MB`,
+        isBinary: false,
+        size: stat.size,
+      };
+    }
+
+    const buffer = readFileSync(filePath);
+
+    // Simple binary detection: check for null bytes
+    const isBinary = buffer.includes(0);
+
+    if (isBinary) {
+      return {
+        content: `Binary file (${(stat.size / 1024).toFixed(2)}KB)`,
+        isBinary: true,
+        size: stat.size,
+      };
+    }
+
+    return {
+      content: buffer.toString("utf-8"),
+      isBinary: false,
+      size: stat.size,
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to read file: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+/**
+ * Write content to a file
+ */
+export function writeFileContent(
+  filePath: string,
+  content: string,
+  options: { maxSize?: number } = {}
+): { success: boolean; size: number } {
+  const { maxSize = 1024 * 1024 } = options; // Default 1MB max
+
+  const contentBuffer = Buffer.from(content, "utf-8");
+
+  if (contentBuffer.length > maxSize) {
+    throw new Error(
+      `Content too large (${(contentBuffer.length / 1024 / 1024).toFixed(2)}MB). Maximum size: ${(maxSize / 1024 / 1024).toFixed(2)}MB`
+    );
+  }
+
+  try {
+    writeFileSync(filePath, content, "utf-8");
+    return {
+      success: true,
+      size: contentBuffer.length,
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to write file: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}