buncargo 1.0.29 → 3.2.0

package/dist/index-g6eb5wdw.js

@@ -1,132 +1,133 @@
+// cli.ts
+import { spawn } from "node:child_process";
 import {
-  spawnWatchdog,
-  startHeartbeat,
-  stopHeartbeat
+	spawnWatchdog,
+	startHeartbeat,
+	stopHeartbeat,
 } from "./index-vhs88xhe.js";
 
-// cli.ts
-import { spawn } from "node:child_process";
 async function runCli(env, options = {}) {
-  const {
-    args = process.argv.slice(2),
-    watchdog = true,
-    watchdogTimeout = 10,
-    devServersCommand
-  } = options;
-  env.logInfo();
-  if (args.includes("--down")) {
-    await env.stop();
-    process.exit(0);
-  }
-  if (args.includes("--reset")) {
-    await env.stop({ removeVolumes: true });
-    process.exit(0);
-  }
-  const running = await env.isRunning();
-  if (running) {
-    console.log("✓ Containers already running");
-  } else {
-    await env.start({ startServers: false, wait: true });
-  }
-  if (args.includes("--migrate")) {
-    console.log("");
-    console.log("✅ Migrations applied successfully");
-    process.exit(0);
-  }
-  if (args.includes("--seed")) {
-    console.log("\uD83C\uDF31 Running seeders...");
-    const result = await env.exec("bun run run:seeder", {
-      throwOnError: false
-    });
-    if (result.exitCode !== 0) {
-      console.error("❌ Seeding failed");
-      process.exit(1);
-    }
-    console.log("");
-    console.log("✅ Seeding complete");
-    process.exit(0);
-  }
-  if (args.includes("--up-only")) {
-    console.log("");
-    console.log("✅ Containers started. Environment ready.");
-    console.log("");
-    process.exit(0);
-  }
-  if (watchdog) {
-    await spawnWatchdog(env.projectName, env.root, {
-      timeoutMinutes: watchdogTimeout,
-      verbose: true
-    });
-    startHeartbeat(env.projectName);
-  }
-  const command = devServersCommand ?? buildDevServersCommand(env.apps);
-  if (!command) {
-    console.log("✅ Containers ready. No apps configured.");
-    await new Promise(() => {});
-    return;
-  }
-  console.log("");
-  console.log("\uD83D\uDD27 Starting dev servers...");
-  console.log("");
-  await runCommand(command, env.root, env.buildEnvVars());
-  stopHeartbeat();
+	const {
+		args = process.argv.slice(2),
+		watchdog = true,
+		watchdogTimeout = 10,
+		devServersCommand,
+	} = options;
+	env.logInfo();
+	if (args.includes("--down")) {
+		await env.stop();
+		process.exit(0);
+	}
+	if (args.includes("--reset")) {
+		await env.stop({ removeVolumes: true });
+		process.exit(0);
+	}
+	const running = await env.isRunning();
+	if (running) {
+		console.log("✓ Containers already running");
+	} else {
+		await env.start({ startServers: false, wait: true });
+	}
+	if (args.includes("--migrate")) {
+		console.log("");
+		console.log("✅ Migrations applied successfully");
+		process.exit(0);
+	}
+	if (args.includes("--seed")) {
+		console.log("\uD83C\uDF31 Running seeders...");
+		const result = await env.exec("bun run run:seeder", {
+			throwOnError: false,
+		});
+		if (result.exitCode !== 0) {
+			console.error("❌ Seeding failed");
+			process.exit(1);
+		}
+		console.log("");
+		console.log("✅ Seeding complete");
+		process.exit(0);
+	}
+	if (args.includes("--up-only")) {
+		console.log("");
+		console.log("✅ Containers started. Environment ready.");
+		console.log("");
+		process.exit(0);
+	}
+	if (watchdog) {
+		await spawnWatchdog(env.projectName, env.root, {
+			timeoutMinutes: watchdogTimeout,
+			verbose: true,
+		});
+		startHeartbeat(env.projectName);
+	}
+	const command = devServersCommand ?? buildDevServersCommand(env.apps);
+	if (!command) {
+		console.log("✅ Containers ready. No apps configured.");
+		await new Promise(() => {});
+		return;
+	}
+	console.log("");
+	console.log("\uD83D\uDD27 Starting dev servers...");
+	console.log("");
+	await runCommand(command, env.root, env.buildEnvVars());
+	stopHeartbeat();
 }
 function buildDevServersCommand(apps) {
-  const appEntries = Object.entries(apps);
-  if (appEntries.length === 0)
-    return null;
-  const commands = [];
-  const names = [];
-  const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
-  for (const [name, config] of appEntries) {
-    names.push(name);
-    const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
-    commands.push(`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim());
-  }
-  const namesArg = `-n ${names.join(",")}`;
-  const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
-  const commandsArg = commands.join(" ");
-  return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
+	const appEntries = Object.entries(apps);
+	if (appEntries.length === 0) return null;
+	const commands = [];
+	const names = [];
+	const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
+	for (const [name, config] of appEntries) {
+		names.push(name);
+		const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
+		commands.push(
+			`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim(),
+		);
+	}
+	const namesArg = `-n ${names.join(",")}`;
+	const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
+	const commandsArg = commands.join(" ");
+	return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
 }
 function runCommand(command, cwd, envVars) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, [], {
-      cwd,
-      env: { ...process.env, ...envVars },
-      stdio: "inherit",
-      shell: true
-    });
-    proc.on("close", (code) => {
-      if (code === 0 || code === null) {
-        resolve();
-      } else {
-        reject(new Error(`Command exited with code ${code}`));
-      }
-    });
-    proc.on("error", reject);
-    const cleanup = () => {
-      proc.kill("SIGTERM");
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-  });
+	return new Promise((resolve, reject) => {
+		const proc = spawn(command, [], {
+			cwd,
+			env: { ...process.env, ...envVars },
+			stdio: "inherit",
+			shell: true,
+		});
+		proc.on("close", (code) => {
+			if (code === 0 || code === null) {
+				resolve();
+			} else {
+				reject(new Error(`Command exited with code ${code}`));
+			}
+		});
+		proc.on("error", reject);
+		const cleanup = () => {
+			proc.kill("SIGTERM");
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	});
 }
 function hasFlag(args, flag) {
-  return args.includes(flag);
+	return args.includes(flag);
 }
 function getFlagValue(args, flag) {
-  const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
-  if (prefixed) {
-    return prefixed.split("=")[1];
-  }
-  const index = args.indexOf(flag);
-  if (index !== -1 && index + 1 < args.length) {
-    const nextArg = args[index + 1];
-    if (nextArg !== undefined && !nextArg.startsWith("-")) {
-      return nextArg;
-    }
-  }
-  return;
+	const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
+	if (prefixed) {
+		return prefixed.split("=")[1];
+	}
+	const index = args.indexOf(flag);
+	if (index !== -1 && index + 1 < args.length) {
+		const nextArg = args[index + 1];
+		if (nextArg !== undefined && !nextArg.startsWith("-")) {
+			return nextArg;
+		}
+	}
+	return;
 }
 
 export { runCli, hasFlag, getFlagValue };

package/dist/index-ggq3yryx.js

@@ -1,120 +1,124 @@
-import {
-  isProcessAlive
-} from "./index-1yvbwj4k.js";
-
 // core/watchdog.ts
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { isProcessAlive } from "./index-1yvbwj4k.js";
+
 function getHeartbeatFile(projectName) {
-  return `/tmp/${projectName}-heartbeat`;
+	return `/tmp/${projectName}-heartbeat`;
 }
 function getWatchdogPidFile(projectName) {
-  return `/tmp/${projectName}-watchdog.pid`;
+	return `/tmp/${projectName}-watchdog.pid`;
 }
 var heartbeatInterval = null;
 function startHeartbeat(projectName, intervalMs = 30000) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  writeFileSync(heartbeatFile, Date.now().toString());
-  heartbeatInterval = setInterval(() => {
-    writeFileSync(heartbeatFile, Date.now().toString());
-  }, intervalMs);
+	const heartbeatFile = getHeartbeatFile(projectName);
+	writeFileSync(heartbeatFile, Date.now().toString());
+	heartbeatInterval = setInterval(() => {
+		writeFileSync(heartbeatFile, Date.now().toString());
+	}, intervalMs);
 }
 function stopHeartbeat() {
-  if (heartbeatInterval) {
-    clearInterval(heartbeatInterval);
-    heartbeatInterval = null;
-  }
+	if (heartbeatInterval) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = null;
+	}
 }
 function readHeartbeat(projectName) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  try {
-    if (!existsSync(heartbeatFile))
-      return null;
-    const content = readFileSync(heartbeatFile, "utf-8");
-    const timestamp = parseInt(content, 10);
-    return Number.isNaN(timestamp) ? null : timestamp;
-  } catch {
-    return null;
-  }
+	const heartbeatFile = getHeartbeatFile(projectName);
+	try {
+		if (!existsSync(heartbeatFile)) return null;
+		const content = readFileSync(heartbeatFile, "utf-8");
+		const timestamp = parseInt(content, 10);
+		return Number.isNaN(timestamp) ? null : timestamp;
+	} catch {
+		return null;
+	}
 }
 function removeHeartbeatFile(projectName) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  try {
-    unlinkSync(heartbeatFile);
-  } catch {}
+	const heartbeatFile = getHeartbeatFile(projectName);
+	try {
+		unlinkSync(heartbeatFile);
+	} catch {}
 }
 function isWatchdogRunning(projectName) {
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    if (!existsSync(pidFile))
-      return false;
-    const content = readFileSync(pidFile, "utf-8");
-    const pid = parseInt(content, 10);
-    if (Number.isNaN(pid))
-      return false;
-    return isProcessAlive(pid);
-  } catch {
-    return false;
-  }
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		if (!existsSync(pidFile)) return false;
+		const content = readFileSync(pidFile, "utf-8");
+		const pid = parseInt(content, 10);
+		if (Number.isNaN(pid)) return false;
+		return isProcessAlive(pid);
+	} catch {
+		return false;
+	}
 }
 function getWatchdogPid(projectName) {
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    if (!existsSync(pidFile))
-      return null;
-    const content = readFileSync(pidFile, "utf-8");
-    const pid = parseInt(content, 10);
-    if (Number.isNaN(pid))
-      return null;
-    if (!isProcessAlive(pid))
-      return null;
-    return pid;
-  } catch {
-    return null;
-  }
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		if (!existsSync(pidFile)) return null;
+		const content = readFileSync(pidFile, "utf-8");
+		const pid = parseInt(content, 10);
+		if (Number.isNaN(pid)) return null;
+		if (!isProcessAlive(pid)) return null;
+		return pid;
+	} catch {
+		return null;
+	}
 }
 async function spawnWatchdog(projectName, root, options = {}) {
-  const { timeoutMinutes = 10, verbose = true, composeFile } = options;
-  const existingPid = getWatchdogPid(projectName);
-  if (existingPid) {
-    if (verbose)
-      console.log(`✓ Watchdog already running (PID: ${existingPid})`);
-    return;
-  }
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    unlinkSync(pidFile);
-  } catch {}
-  const watchdogScript = new URL("./watchdog-runner.ts", import.meta.url).pathname;
-  const proc = spawn("bun", ["run", watchdogScript], {
-    cwd: root,
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      WATCHDOG_PROJECT_NAME: projectName,
-      WATCHDOG_HEARTBEAT_FILE: getHeartbeatFile(projectName),
-      WATCHDOG_PID_FILE: pidFile,
-      WATCHDOG_TIMEOUT_MS: String(timeoutMinutes * 60 * 1000),
-      WATCHDOG_COMPOSE_ARG: composeFile ? `-f ${composeFile}` : ""
-    }
-  });
-  proc.unref();
-  if (verbose && proc.pid) {
-    console.log(`✓ Watchdog started (PID: ${proc.pid})`);
-  }
+	const { timeoutMinutes = 10, verbose = true, composeFile } = options;
+	const existingPid = getWatchdogPid(projectName);
+	if (existingPid) {
+		if (verbose)
+			console.log(`✓ Watchdog already running (PID: ${existingPid})`);
+		return;
+	}
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		unlinkSync(pidFile);
+	} catch {}
+	const watchdogScript = new URL("./watchdog-runner.ts", import.meta.url)
+		.pathname;
+	const proc = spawn("bun", ["run", watchdogScript], {
+		cwd: root,
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			WATCHDOG_PROJECT_NAME: projectName,
+			WATCHDOG_HEARTBEAT_FILE: getHeartbeatFile(projectName),
+			WATCHDOG_PID_FILE: pidFile,
+			WATCHDOG_TIMEOUT_MS: String(timeoutMinutes * 60 * 1000),
+			WATCHDOG_COMPOSE_ARG: composeFile ? `-f ${composeFile}` : "",
+		},
+	});
+	proc.unref();
+	if (verbose && proc.pid) {
+		console.log(`✓ Watchdog started (PID: ${proc.pid})`);
+	}
 }
 function stopWatchdog(projectName) {
-  const pid = getWatchdogPid(projectName);
-  if (pid) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {}
-  }
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    unlinkSync(pidFile);
-  } catch {}
+	const pid = getWatchdogPid(projectName);
+	if (pid) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+	}
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		unlinkSync(pidFile);
+	} catch {}
 }
 
-export { getHeartbeatFile, getWatchdogPidFile, startHeartbeat, stopHeartbeat, readHeartbeat, removeHeartbeatFile, isWatchdogRunning, getWatchdogPid, spawnWatchdog, stopWatchdog };
+export {
+	getHeartbeatFile,
+	getWatchdogPidFile,
+	startHeartbeat,
+	stopHeartbeat,
+	readHeartbeat,
+	removeHeartbeatFile,
+	isWatchdogRunning,
+	getWatchdogPid,
+	spawnWatchdog,
+	stopWatchdog,
+};

package/dist/index-h70tce00.js

@@ -0,0 +1,177 @@
+// src/typecheck/typecheck.ts
+import { execSync } from "node:child_process";
+import { readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import fg from "fast-glob";
+var DEFAULT_PATTERNS = ["apps/*", "packages/*", "modules"];
+var DEFAULT_CONCURRENCY = 1;
+var CORRUPTED_CACHE_PATTERNS = [
+  "all goroutines are asleep - deadlock",
+  "fatal error:",
+  "panic:",
+  "github.com/microsoft/typescript-go"
+];
+function isCorruptedCacheError(output) {
+  return CORRUPTED_CACHE_PATTERNS.some((pattern) => output.includes(pattern));
+}
+async function clearTsBuildInfo(workspace, verbose) {
+  if (verbose) {
+    console.log(`\uD83E\uDDF9 Clearing corrupted tsbuildinfo cache for ${workspace}...`);
+  }
+  try {
+    const tsbuildInfoFiles = await fg(`${workspace}/**/*.tsbuildinfo`, {
+      absolute: true
+    });
+    for (const file of tsbuildInfoFiles) {
+      try {
+        unlinkSync(file);
+      } catch {}
+    }
+    const cacheFiles = await fg(`${workspace}/**/.cache/tsbuildinfo.json`, {
+      absolute: true
+    });
+    for (const file of cacheFiles) {
+      try {
+        unlinkSync(file);
+      } catch {}
+    }
+  } catch {}
+}
+async function countTypeScriptFiles(pkgPath, root) {
+  const files = await fg(`${pkgPath}/**/*.{ts,tsx}`, {
+    cwd: root,
+    ignore: ["**/node_modules/**"]
+  });
+  return files.length;
+}
+function formatErrorOutput(output) {
+  return output.split(`
+`).map((line) => {
+    return line.replace(/\.\.\/\.\.\/packages\/modules\//g, "").replace(/\((\d+),(\d+)\):?/g, ":$1:$2 -");
+  }).join(`
+`).trim();
+}
+async function runSingleTypecheck(workspace, fileCount, root, verbose, isRetry = false) {
+  const startTime = performance.now();
+  if (verbose) {
+    console.log(`Running typecheck in ${workspace} (${fileCount} files)${isRetry ? " (retry)" : ""}...`);
+  }
+  const workspacePath = join(root, workspace);
+  let success = false;
+  let stdout = "";
+  let stderr = "";
+  try {
+    const output = execSync("bun run typecheck", {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    stdout = output ?? "";
+    success = true;
+  } catch (error) {
+    const execError = error;
+    stdout = execError.stdout ?? "";
+    stderr = execError.stderr ?? "";
+    success = false;
+  }
+  const duration = Number(((performance.now() - startTime) / 1000).toFixed(2));
+  let errorOutput;
+  if (!success) {
+    const parts = [stdout.trim(), stderr.trim()].filter(Boolean);
+    errorOutput = parts.length > 0 ? parts.join(`
+`) : undefined;
+    if (!isRetry && errorOutput && isCorruptedCacheError(errorOutput)) {
+      await clearTsBuildInfo(workspacePath, verbose);
+      return runSingleTypecheck(workspace, fileCount, root, verbose, true);
+    }
+  }
+  return { workspace, duration, success, fileCount, errorOutput };
+}
+async function discoverWorkspaces(patterns, root) {
+  const workspaces = [];
+  for (const pattern of patterns) {
+    const matches = await fg(`${pattern}/package.json`, { cwd: root });
+    for (const match of matches) {
+      const pkgPath = match.replace("/package.json", "");
+      try {
+        const pkgJsonContent = readFileSync(join(root, match), "utf-8");
+        const pkgJson = JSON.parse(pkgJsonContent);
+        if (pkgJson.scripts?.typecheck) {
+          const fileCount = await countTypeScriptFiles(pkgPath, root);
+          workspaces.push({ path: pkgPath, fileCount });
+        }
+      } catch {}
+    }
+  }
+  workspaces.sort((a, b) => a.fileCount - b.fileCount);
+  return workspaces;
+}
+async function runWorkspaceTypecheck(options = {}) {
+  const {
+    root = process.cwd(),
+    patterns = DEFAULT_PATTERNS,
+    concurrency = DEFAULT_CONCURRENCY,
+    verbose = true
+  } = options;
+  const workspaces = await discoverWorkspaces(patterns, root);
+  if (workspaces.length === 0) {
+    if (verbose) {
+      console.log("No workspaces with typecheck script found.");
+    }
+    return {
+      success: true,
+      totalDuration: 0,
+      totalFiles: 0,
+      workspaceCount: 0,
+      results: []
+    };
+  }
+  const totalStartTime = performance.now();
+  if (verbose) {
+    console.log(`Running typecheck across ${workspaces.length} workspaces with concurrency limit of ${concurrency}...
+`);
+  }
+  const results = [];
+  const running = new Set;
+  for (let i = 0;i < workspaces.length; i++) {
+    const { path, fileCount } = workspaces[i];
+    const promise = runSingleTypecheck(path, fileCount, root, verbose).then((result) => {
+      results[i] = result;
+      running.delete(promise);
+      if (verbose) {
+        const icon = result.success ? "✅" : "❌";
+        const log = result.success ? console.log : console.error;
+        log(`${icon} ${result.workspace} (${result.fileCount} files) ${result.success ? "completed" : "failed"} in ${result.duration.toFixed(2)}s`);
+        if (!result.success && result.errorOutput) {
+          console.error(`
+${formatErrorOutput(result.errorOutput)}`);
+        }
+      }
+    });
+    running.add(promise);
+    if (running.size >= concurrency) {
+      await Promise.race(running);
+    }
+  }
+  await Promise.all(running);
+  const totalDuration = Number(((performance.now() - totalStartTime) / 1000).toFixed(2));
+  const totalFiles = workspaces.reduce((sum, w) => sum + w.fileCount, 0);
+  const success = results.every((r) => r.success);
+  if (verbose) {
+    if (success) {
+      console.log(`
+All typecheck checks passed! Total time: ${totalDuration}s (${totalFiles} files)`);
+    } else {
+      console.error(`
+Typecheck failed. Total time: ${totalDuration}s`);
+    }
+  }
+  return {
+    success,
+    totalDuration,
+    totalFiles,
+    workspaceCount: workspaces.length,
+    results
+  };
+}
+export { runWorkspaceTypecheck };