buncargo 1.0.29 → 3.0.0

package/dist/index-ma6tgdb2.js

@@ -0,0 +1,500 @@
+import {
+  areContainersRunning,
+  isContainerRunning,
+  startContainers,
+  startService,
+  stopContainers,
+  waitForServiceByType
+} from "./index-d8tyv5se.js";
+import {
+  getLocalIp,
+  isCI,
+  logExpoApiUrl,
+  logFrontendPort,
+  waitForDevServers,
+  waitForServer
+} from "./index-c0dr6mcv.js";
+import {
+  computeDevIdentity,
+  computePorts,
+  computeUrls,
+  findMonorepoRoot
+} from "./index-fb29934k.js";
+import {
+  getGeneratedComposePath,
+  writeGeneratedComposeFile
+} from "./index-5t9jxqm0.js";
+import {
+  logEnvironmentInfo
+} from "./index-bnk6nr0g.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat,
+  stopWatchdog
+} from "./index-mam0bcyz.js";
+import {
+  buildApps,
+  execAsync,
+  startDevServers,
+  stopProcess
+} from "./index-mm412dkp.js";
+import {
+  assertValidConfig
+} from "./index-t0fj6gg1.js";
+
+// src/prisma/prisma.ts
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+function createPrismaRunner(env, config) {
+  const {
+    cwd = "packages/prisma",
+    service = "postgres",
+    urlEnvVar = "DATABASE_URL"
+  } = config;
+  const healthCheckTypes = {
+    postgres: "pg_isready",
+    redis: "redis-cli",
+    clickhouse: "http"
+  };
+  function getDatabaseUrl() {
+    const envVars = env.buildEnvVars();
+    const url = envVars[urlEnvVar];
+    if (!url) {
+      throw new Error(`Environment variable ${urlEnvVar} not found. Make sure your dev config defines it in envVars.`);
+    }
+    return url;
+  }
+  async function ensureDatabase() {
+    const alreadyRunning = await isContainerRunning(env.projectName, service);
+    if (alreadyRunning) {
+      console.log(`✓ ${service} already running`);
+      return;
+    }
+    console.log(`\uD83D\uDC33 Starting ${service}...`);
+    const composeFile = env.ensureComposeFile();
+    const envVars = env.buildEnvVars();
+    startService(env.root, env.projectName, service, envVars, {
+      verbose: false,
+      composeFile
+    });
+    const port = env.ports[service];
+    if (!port) {
+      throw new Error(`Service ${service} not found in dev environment ports`);
+    }
+    const healthCheckType = healthCheckTypes[service] ?? "tcp";
+    console.log(`⏳ Waiting for ${service} to be healthy...`);
+    await waitForServiceByType(service, healthCheckType, port, {
+      verbose: true
+    });
+  }
+  async function run(args) {
+    if (args.length === 0) {
+      console.log(`
+Usage: bun prisma <command> [args...]
+
+Examples:
+  bun prisma migrate dev     # Create new migration
+  bun prisma migrate deploy  # Apply migrations
+  bun prisma db push         # Push schema changes
+  bun prisma studio          # Open Prisma Studio
+  bun prisma migrate reset   # Reset database
+`);
+      return 0;
+    }
+    const port = env.ports[service];
+    console.log(`
+\uD83D\uDD27 Prisma CLI
+   Project: ${env.projectName}
+   Database: localhost:${port}
+   ${env.portOffset > 0 ? `(port offset +${env.portOffset})` : ""}
+`);
+    await ensureDatabase();
+    const envVars = env.buildEnvVars();
+    const workingDir = join(env.root, cwd);
+    const fullEnv = {
+      ...process.env,
+      ...envVars,
+      [urlEnvVar]: getDatabaseUrl()
+    };
+    console.log(`\uD83D\uDD04 Running: prisma ${args.join(" ")}
+`);
+    return new Promise((resolve) => {
+      const proc = spawn("bunx", ["prisma", ...args], {
+        cwd: workingDir,
+        env: fullEnv,
+        stdio: "inherit"
+      });
+      proc.on("close", (code) => {
+        resolve(code ?? 0);
+      });
+      proc.on("error", () => {
+        resolve(1);
+      });
+    });
+  }
+  return { run, getDatabaseUrl, ensureDatabase };
+}
+// src/environment/seeding.ts
+function createCheckTableHelper(urls, exec) {
+  return async (tableName, service) => {
+    const serviceName = service ?? "postgres";
+    const serviceUrl = urls[serviceName];
+    if (!serviceUrl) {
+      console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
+      return true;
+    }
+    const checkResult = await exec(`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`, { throwOnError: false });
+    const count = checkResult.stdout.trim();
+    const shouldSeed = checkResult.exitCode !== 0 || count === "0" || count === "";
+    if (!shouldSeed) {
+      console.log(`  \uD83D\uDCCA Table "${tableName}" has ${count} rows`);
+    }
+    return shouldSeed;
+  };
+}
+function createSeedCheckContext(baseContext, checkTable) {
+  return {
+    ...baseContext,
+    checkTable
+  };
+}
+
+// src/environment/create-dev-environment.ts
+function createDevEnvironment(config, options = {}) {
+  assertValidConfig(config);
+  const root = findMonorepoRoot();
+  const suffix = options.suffix;
+  const identity = computeDevIdentity({
+    projectPrefix: config.projectPrefix,
+    suffix,
+    root,
+    worktreeIsolation: config.options?.worktreeIsolation
+  });
+  const { worktree, projectSuffix, portOffset, projectName } = identity;
+  const localIp = getLocalIp();
+  const services = config.services;
+  const apps = config.apps ?? {};
+  const composeFile = getGeneratedComposePath(root, config.docker).composeFileArg;
+  function ensureComposeFile() {
+    return writeGeneratedComposeFile(root, services, config.docker);
+  }
+  const ports = computePorts(services, apps, portOffset);
+  const urls = computeUrls(services, apps, ports, localIp);
+  const publicUrls = {};
+  function setPublicUrls(urlsInput) {
+    for (const key of Object.keys(publicUrls)) {
+      delete publicUrls[key];
+    }
+    for (const [key, value] of Object.entries(urlsInput)) {
+      publicUrls[key] = value;
+    }
+  }
+  function clearPublicUrls() {
+    for (const key of Object.keys(publicUrls)) {
+      delete publicUrls[key];
+    }
+  }
+  function buildEnvVars(production = false) {
+    const baseEnv = {
+      COMPOSE_PROJECT_NAME: projectName,
+      NODE_ENV: production ? "production" : "development"
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      const envName = `${name.toUpperCase()}_PORT`;
+      baseEnv[envName] = String(port);
+    }
+    for (const [name, url] of Object.entries(urls)) {
+      const envName = `${name.toUpperCase()}_URL`;
+      baseEnv[envName] = url;
+    }
+    for (const [name, url] of Object.entries(publicUrls)) {
+      const envName = `${name.toUpperCase()}_PUBLIC_URL`;
+      baseEnv[envName] = url;
+    }
+    if (config.envVars) {
+      const userEnv = config.envVars(ports, urls, {
+        projectName,
+        localIp,
+        portOffset,
+        publicUrls
+      });
+      for (const [key, value] of Object.entries(userEnv)) {
+        baseEnv[key] = String(value);
+      }
+    }
+    return baseEnv;
+  }
+  let hookContext = null;
+  function getHookContext() {
+    if (!hookContext) {
+      hookContext = {
+        projectName,
+        ports,
+        urls,
+        publicUrls,
+        root,
+        isCI: isCI(),
+        portOffset,
+        localIp,
+        exec: async (cmd, opts) => {
+          const envVars = buildEnvVars();
+          return execAsync(cmd, root, envVars, opts);
+        }
+      };
+    }
+    return hookContext;
+  }
+  function exec(cmd, options2) {
+    const envVars = buildEnvVars();
+    return execAsync(cmd, root, envVars, options2);
+  }
+  async function start(startOptions = {}) {
+    const isCI2 = process.env.CI === "true";
+    const {
+      verbose = config.options?.verbose ?? true,
+      wait = true,
+      startServers: shouldStartServers = true,
+      productionBuild = isCI2,
+      skipSeed = false
+    } = startOptions;
+    const envVars = buildEnvVars(productionBuild);
+    ensureComposeFile();
+    if (verbose) {
+      logInfo(productionBuild ? "Production Environment" : "Dev Environment");
+    }
+    const serviceCount = Object.keys(services).length;
+    const alreadyRunning = await areContainersRunning(projectName, serviceCount);
+    if (alreadyRunning) {
+      if (verbose)
+        console.log("✓ Containers already running");
+    } else {
+      startContainers(root, projectName, envVars, {
+        verbose,
+        wait,
+        composeFile
+      });
+    }
+    const allMigrations = [
+      ...config.prisma ? [
+        {
+          name: "prisma",
+          command: "bunx prisma migrate deploy",
+          cwd: config.prisma.cwd ?? "packages/prisma"
+        }
+      ] : [],
+      ...config.migrations ?? []
+    ];
+    if (allMigrations.length > 0) {
+      if (verbose)
+        console.log("\uD83D\uDCE6 Running migrations...");
+      const migrationResults = await Promise.all(allMigrations.map(async (migration) => {
+        const result = await exec(migration.command, {
+          cwd: migration.cwd,
+          throwOnError: false
+        });
+        return { name: migration.name, result };
+      }));
+      for (const { name, result } of migrationResults) {
+        if (result.exitCode !== 0) {
+          console.error(`❌ Migration "${name}" failed`);
+          if (result.stdout) {
+            console.error(result.stdout);
+          }
+          if (result.stderr) {
+            console.error(result.stderr);
+          }
+          throw new Error(`Migration "${name}" failed`);
+        }
+      }
+      if (verbose)
+        console.log("✓ Migrations complete");
+    }
+    if (config.hooks?.afterContainersReady) {
+      await config.hooks.afterContainersReady(getHookContext());
+    }
+    if (config.seed && !skipSeed) {
+      let shouldSeed = true;
+      if (config.seed.check) {
+        const checkTable = createCheckTableHelper(urls, exec);
+        const seedCheckContext = createSeedCheckContext(getHookContext(), checkTable);
+        shouldSeed = await config.seed.check(seedCheckContext);
+      }
+      if (shouldSeed) {
+        if (verbose)
+          console.log("\uD83C\uDF31 Running seeders...");
+        const seedResult = await exec(config.seed.command, {
+          cwd: config.seed.cwd,
+          verbose,
+          throwOnError: false
+        });
+        if (seedResult.exitCode !== 0) {
+          console.error("❌ Seeding failed");
+          console.error(seedResult.stderr);
+        } else {
+          if (verbose)
+            console.log("✓ Seeding complete");
+        }
+      } else {
+        if (verbose)
+          console.log("✓ Database already has data, skipping seeders");
+      }
+    }
+    if (shouldStartServers && Object.keys(apps).length > 0) {
+      if (config.hooks?.beforeServers) {
+        await config.hooks.beforeServers(getHookContext());
+      }
+      if (productionBuild) {
+        buildApps(apps, root, envVars, { verbose });
+      }
+      const pids = await startDevServers(apps, root, envVars, ports, {
+        verbose,
+        productionBuild,
+        isCI: isCI2
+      });
+      if (verbose)
+        console.log("⏳ Waiting for servers to be ready...");
+      await waitForDevServers(apps, ports, {
+        timeout: isCI2 ? 120000 : 60000,
+        verbose,
+        productionBuild
+      });
+      if (config.hooks?.afterServers) {
+        await config.hooks.afterServers(getHookContext());
+      }
+      if (verbose)
+        console.log(`✅ Environment ready
+`);
+      return pids;
+    }
+    if (verbose)
+      console.log(`✅ Containers ready
+`);
+    return null;
+  }
+  async function stop(stopOptions = {}) {
+    const { verbose = true, removeVolumes = false } = stopOptions;
+    ensureComposeFile();
+    if (config.hooks?.beforeStop) {
+      await config.hooks.beforeStop(getHookContext());
+    }
+    stopContainers(root, projectName, {
+      verbose,
+      removeVolumes,
+      composeFile
+    });
+  }
+  async function restart() {
+    await stop();
+    await start({ startServers: false });
+  }
+  async function isRunning() {
+    const serviceCount = Object.keys(services).length;
+    return areContainersRunning(projectName, serviceCount);
+  }
+  async function startServersOnly(options2 = {}) {
+    const { productionBuild = false, verbose = true } = options2;
+    const envVars = buildEnvVars(productionBuild);
+    const isCI2 = process.env.CI === "true";
+    if (productionBuild) {
+      buildApps(apps, root, envVars, { verbose });
+    }
+    return startDevServers(apps, root, envVars, ports, {
+      verbose,
+      productionBuild,
+      isCI: isCI2
+    });
+  }
+  async function waitForServersReady(options2 = {}) {
+    const { timeout = 60000, productionBuild = false } = options2;
+    await waitForDevServers(apps, ports, { timeout, productionBuild });
+  }
+  function logInfo(label = "Docker Dev") {
+    logEnvironmentInfo({
+      label,
+      projectName,
+      services,
+      apps,
+      ports,
+      localIp,
+      worktree,
+      portOffset,
+      projectSuffix
+    });
+  }
+  async function waitForServerUrl(url, timeout) {
+    await waitForServer(url, { timeout });
+  }
+  function startHeartbeat2(intervalMs) {
+    startHeartbeat(projectName, intervalMs);
+  }
+  function stopHeartbeat2() {
+    stopHeartbeat();
+  }
+  async function spawnWatchdog2(timeoutMinutes) {
+    await spawnWatchdog(projectName, root, {
+      timeoutMinutes,
+      verbose: true,
+      composeFile
+    });
+  }
+  function stopWatchdog2() {
+    stopWatchdog(projectName);
+  }
+  function getExpoApiUrl() {
+    const apiPort = ports.api;
+    const url = `http://${localIp}:${apiPort}`;
+    logExpoApiUrl(url);
+    return url;
+  }
+  function getFrontendPort() {
+    const port = ports.platform;
+    logFrontendPort(port);
+    return port;
+  }
+  function withSuffix(newSuffix) {
+    return createDevEnvironment(config, { suffix: newSuffix });
+  }
+  const env = {
+    projectName,
+    ports,
+    urls,
+    publicUrls,
+    services,
+    apps,
+    portOffset,
+    isWorktree: worktree,
+    localIp,
+    root,
+    composeFile,
+    start,
+    stop,
+    restart,
+    isRunning,
+    startServers: startServersOnly,
+    stopProcess,
+    waitForServers: waitForServersReady,
+    buildEnvVars,
+    setPublicUrls: (urlsInput) => {
+      setPublicUrls(urlsInput);
+    },
+    clearPublicUrls,
+    ensureComposeFile,
+    exec,
+    waitForServer: waitForServerUrl,
+    logInfo,
+    getExpoApiUrl,
+    getFrontendPort,
+    startHeartbeat: startHeartbeat2,
+    stopHeartbeat: stopHeartbeat2,
+    spawnWatchdog: spawnWatchdog2,
+    stopWatchdog: stopWatchdog2,
+    prisma: undefined,
+    withSuffix
+  };
+  if (config.prisma) {
+    env.prisma = createPrismaRunner(env, config.prisma);
+  }
+  return env;
+}
+export { createDevEnvironment };

package/dist/index-mam0bcyz.js

@@ -0,0 +1,123 @@
+import {
+  isProcessAlive
+} from "./index-mm412dkp.js";
+
+// src/core/watchdog.ts
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+function getHeartbeatFile(projectName) {
+  return `/tmp/${projectName}-heartbeat`;
+}
+function getWatchdogPidFile(projectName) {
+  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);
+}
+function stopHeartbeat() {
+  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;
+  }
+}
+function removeHeartbeatFile(projectName) {
+  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;
+  }
+}
+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;
+  }
+}
+function getWatchdogComposeArg(composeFile) {
+  return composeFile ? `-f "${composeFile}"` : "";
+}
+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: getWatchdogComposeArg(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 {}
+}
+
+export { getHeartbeatFile, getWatchdogPidFile, startHeartbeat, stopHeartbeat, readHeartbeat, removeHeartbeatFile, isWatchdogRunning, getWatchdogPid, getWatchdogComposeArg, spawnWatchdog, stopWatchdog };