@visulima/vis 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_chunks/handler36.js

@@ -0,0 +1,542 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  open,
+  stat,
+  watch
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { isAccessible } from '@visulima/fs';
+import { p as pail, Y as loadVisTaskConfigsForWorkspace, d as discoverWorkspace, Z as loadEnvFile } from './bin.js';
+import { join } from '@visulima/path';
+import { R as REGISTRY_FILE_MODE, w as withServiceLock, r as readEntry, i as isAlive, d as deleteEntry, g as getRegistryDir, s as slugify, a as writeEntry, b as runReadiness, p as pruneDead, S as ServiceReadinessError, c as readAllEntries } from '../packem_shared/registry-CbqXI0rc.js';
+const {
+  spawn
+} = __cjs_getBuiltinModule("node:child_process");
+import { formatAge } from './handler14.js';
+
+const isWindows = process.platform === "win32";
+const spawnDetached = async (input) => {
+  const { command, cwd, env, logFile } = input;
+  const logHandle = await open(logFile, "a", REGISTRY_FILE_MODE);
+  let child;
+  try {
+    const shell = isWindows ? "cmd" : "/bin/sh";
+    const args = isWindows ? ["/d", "/s", "/c", command] : ["-c", command];
+    child = spawn(shell, args, {
+      cwd,
+      detached: true,
+      env: { ...process.env, ...env },
+      stdio: ["ignore", logHandle.fd, logHandle.fd],
+      // Windows: spawn in a new console so the child isn't tied
+      // to this terminal's lifetime.
+      windowsHide: true
+    });
+  } finally {
+    await logHandle.close().catch(() => {
+    });
+  }
+  if (child.pid === void 0) {
+    await new Promise((resolve, reject) => {
+      child.once("spawn", () => resolve());
+      child.once("error", (error) => reject(error));
+    });
+  }
+  if (child.pid === void 0) {
+    throw new Error(`Failed to spawn detached process for command: ${command}`);
+  }
+  child.unref();
+  return { pid: child.pid };
+};
+
+const DEFAULT_KILL_GRACE_MS = 5e3;
+const startService = async (input) => withServiceLock(input.workspaceRoot, input.id, async () => {
+  const existing = await readEntry(input.workspaceRoot, input.id);
+  if (existing && isAlive(existing.pid)) {
+    throw new Error(`Service ${input.id} is already running (pid ${String(existing.pid)})`);
+  }
+  if (existing) {
+    await deleteEntry(input.workspaceRoot, input.id, existing);
+  }
+  const registryDirectory = await getRegistryDir(input.workspaceRoot);
+  const slug = slugify(input.id);
+  const logFile = join(registryDirectory, `${slug}.log`);
+  const { pid } = await spawnDetached({
+    command: input.command,
+    cwd: input.cwd,
+    env: input.env,
+    logFile
+  });
+  const entry = {
+    command: input.command,
+    config: input.config,
+    cwd: input.cwd,
+    env: input.config.env ?? {},
+    id: input.id,
+    logFile,
+    pid,
+    slug,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    visVersion: process.env["VIS_VERSION"] ?? "0.0.0"
+  };
+  await writeEntry(input.workspaceRoot, entry);
+  if (input.skipReadiness !== true) {
+    try {
+      await runReadiness(input.config, { timeoutMs: input.readinessTimeoutMs });
+    } catch (error) {
+      await stopServiceByPid(pid, input.config.killGracePeriodMs ?? DEFAULT_KILL_GRACE_MS).catch(() => {
+      });
+      await deleteEntry(input.workspaceRoot, input.id, entry).catch(() => {
+      });
+      throw error;
+    }
+  }
+  return { entry };
+});
+const stopService = async (input) => withServiceLock(input.workspaceRoot, input.id, async () => {
+  const entry = await readEntry(input.workspaceRoot, input.id);
+  if (!entry) {
+    return { stopped: false };
+  }
+  if (!isAlive(entry.pid)) {
+    await deleteEntry(input.workspaceRoot, input.id, entry);
+    return { stopped: false };
+  }
+  const graceMs = input.graceMs ?? entry.config.killGracePeriodMs ?? DEFAULT_KILL_GRACE_MS;
+  await stopServiceByPid(entry.pid, graceMs);
+  await deleteEntry(input.workspaceRoot, input.id, entry);
+  return { stopped: true };
+});
+const stopServiceByPid = async (pid, graceMs) => {
+  sendSignalToServiceGroup(pid, "SIGTERM");
+  const start = Date.now();
+  while (Date.now() - start < graceMs) {
+    if (!isAlive(pid)) {
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 100);
+    });
+  }
+  if (isAlive(pid)) {
+    sendSignalToServiceGroup(pid, "SIGKILL");
+  }
+};
+const sendSignalToServiceGroup = (pid, signal) => {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, signal);
+    } else {
+      process.kill(-pid, signal);
+    }
+  } catch (error) {
+    if (error.code === "ESRCH") {
+      return;
+    }
+    throw error;
+  }
+};
+
+const splitTargetId = (raw) => {
+  const id = raw.trim();
+  const idx = id.lastIndexOf(":");
+  if (idx <= 0 || idx === id.length - 1) {
+    return void 0;
+  }
+  return { project: id.slice(0, idx), target: id.slice(idx + 1) };
+};
+const resolveCwd = (workspaceRoot, projectRoot, runFromWorkspaceRoot) => {
+  if (runFromWorkspaceRoot || !projectRoot) {
+    return workspaceRoot;
+  }
+  return projectRoot.startsWith("/") ? projectRoot : `${workspaceRoot}/${projectRoot}`;
+};
+const resolveTarget = async (workspaceRoot, visConfig, targetId) => {
+  const split = splitTargetId(targetId);
+  if (!split) {
+    pail.error(`Invalid target id "${targetId}". Expected "<project>:<target>", e.g. "@my/api:db".`);
+    return void 0;
+  }
+  const taskConfigs = await loadVisTaskConfigsForWorkspace(workspaceRoot);
+  const { projectOptions, workspace } = discoverWorkspace(workspaceRoot, visConfig, taskConfigs);
+  const project = workspace.projects[split.project];
+  const target = projectOptions.get(split.project)?.[split.target];
+  if (!project || !target) {
+    pail.error(`Target "${targetId}" not found in this workspace.`);
+    return void 0;
+  }
+  const service = target.options?.service;
+  if (!service) {
+    pail.error(`Target "${targetId}" is not a service. Add an \`options.service\` block to make it eligible for \`vis service\`.`);
+    return void 0;
+  }
+  if (!target.command) {
+    pail.error(`Target "${targetId}" has no command — services must be runnable.`);
+    return void 0;
+  }
+  const cwd = resolveCwd(workspaceRoot, project.root, target.options?.runFromWorkspaceRoot === true);
+  const envFromFiles = target.options?.envFile ? loadEnvFile(cwd, target.options.envFile) : {};
+  return {
+    command: target.command,
+    cwd,
+    env: { ...envFromFiles, ...service.env },
+    service,
+    target,
+    targetId
+  };
+};
+const requireWorkspace = (wsRoot) => {
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root. Run `vis service` inside a workspace.");
+  }
+  return wsRoot;
+};
+const serviceStartExecute = async ({ argument, options, visConfig, workspaceRoot: wsRoot }) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const targetId = argument[0]?.trim();
+  if (!targetId) {
+    pail.error("Missing target id. Usage: vis service start <project>:<target>");
+    process.exitCode = 1;
+    return;
+  }
+  const resolved = await resolveTarget(workspaceRoot, visConfig, targetId);
+  if (!resolved) {
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const { entry } = await startService({
+      command: resolved.command,
+      config: resolved.service,
+      cwd: resolved.cwd,
+      env: resolved.env,
+      id: targetId,
+      readinessTimeoutMs: options.timeout,
+      skipReadiness: options.noReadiness === true,
+      workspaceRoot
+    });
+    pail.success(`Started ${targetId} (pid ${String(entry.pid)})`);
+    pail.info(`  log: ${entry.logFile}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof ServiceReadinessError) {
+      pail.error(`Readiness probe failed for ${targetId}: ${message}`);
+    } else {
+      pail.error(`Failed to start ${targetId}: ${message}`);
+    }
+    process.exitCode = 1;
+  }
+};
+const stopOne = async (workspaceRoot, id, graceMs) => {
+  const { stopped } = await stopService({ graceMs, id, workspaceRoot });
+  if (stopped) {
+    pail.success(`Stopped ${id}`);
+    return true;
+  }
+  pail.info(`No running service registered for ${id}`);
+  return false;
+};
+const serviceStopExecute = async ({ argument, options, workspaceRoot: wsRoot }) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const { graceMs } = options;
+  const targetId = argument[0]?.trim();
+  if (options.all === true) {
+    if (targetId) {
+      pail.error("Cannot combine --all with a target id. Use one or the other.");
+      process.exitCode = 1;
+      return;
+    }
+    const entries = await readAllEntries(workspaceRoot);
+    if (entries.length === 0) {
+      pail.info("No running services registered for this workspace.");
+      return;
+    }
+    for (const entry of entries) {
+      await stopOne(workspaceRoot, entry.id, graceMs);
+    }
+    return;
+  }
+  if (!targetId) {
+    pail.error("Missing target id. Usage: vis service stop <project>:<target> | --all");
+    process.exitCode = 1;
+    return;
+  }
+  const stopped = await stopOne(workspaceRoot, targetId, graceMs);
+  if (!stopped) {
+    process.exitCode = 1;
+  }
+};
+const formatPort = (entry) => {
+  const port = entry.config.readiness?.tcp.port ?? entry.config.port;
+  return port === void 0 ? "—" : String(port);
+};
+const VALID_LIST_FORMATS = /* @__PURE__ */ new Set(["json", "table"]);
+const serviceListExecute = async ({ logger, options, workspaceRoot: wsRoot }) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const format = options.format ?? "table";
+  if (!VALID_LIST_FORMATS.has(format)) {
+    pail.error(`Invalid --format "${format}". Expected one of: ${[...VALID_LIST_FORMATS].sort().join(", ")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const { surviving: entries } = await pruneDead(workspaceRoot);
+  if (format === "json") {
+    const now = Date.now();
+    process.stdout.write(
+      `${JSON.stringify(
+        entries.map((entry) => {
+          const startedMs = Date.parse(entry.startedAt);
+          return {
+            ageMs: Number.isFinite(startedMs) ? now - startedMs : null,
+            alive: isAlive(entry.pid),
+            command: entry.command,
+            cwd: entry.cwd,
+            env: entry.env,
+            id: entry.id,
+            logFile: entry.logFile,
+            pid: entry.pid,
+            port: entry.config.readiness?.tcp.port ?? entry.config.port ?? null,
+            startedAt: entry.startedAt,
+            visVersion: entry.visVersion
+          };
+        }),
+        void 0,
+        2
+      )}
+`
+    );
+    return;
+  }
+  if (entries.length === 0) {
+    pail.info("No running services registered for this workspace.");
+    return;
+  }
+  const renderedAt = Date.now();
+  const rows = entries.map((entry) => {
+    const startedMs = Date.parse(entry.startedAt);
+    return {
+      age: Number.isFinite(startedMs) ? formatAge(startedMs, renderedAt) : "?",
+      id: entry.id,
+      log: entry.logFile,
+      pid: String(entry.pid),
+      port: formatPort(entry)
+    };
+  });
+  const idWidth = Math.max(2, ...rows.map((r) => r.id.length));
+  const pidWidth = Math.max(3, ...rows.map((r) => r.pid.length));
+  const portWidth = Math.max(4, ...rows.map((r) => r.port.length));
+  const ageWidth = Math.max(3, ...rows.map((r) => r.age.length));
+  logger.info(`  ${"id".padEnd(idWidth)}  ${"pid".padEnd(pidWidth)}  ${"port".padEnd(portWidth)}  ${"age".padEnd(ageWidth)}  log`);
+  logger.info(`  ${"-".repeat(idWidth)}  ${"-".repeat(pidWidth)}  ${"-".repeat(portWidth)}  ${"-".repeat(ageWidth)}  ---`);
+  for (const row of rows) {
+    logger.info(`  ${row.id.padEnd(idWidth)}  ${row.pid.padEnd(pidWidth)}  ${row.port.padEnd(portWidth)}  ${row.age.padEnd(ageWidth)}  ${row.log}`);
+  }
+};
+const serviceStatusExecute = async ({ argument, options, workspaceRoot: wsRoot }) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const targetId = argument[0]?.trim();
+  if (!targetId) {
+    pail.error("Missing target id. Usage: vis service status <project>:<target>");
+    process.exitCode = 1;
+    return;
+  }
+  const entry = await readEntry(workspaceRoot, targetId);
+  if (!entry) {
+    pail.error(`No service registered for ${targetId}.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!isAlive(entry.pid)) {
+    pail.error(`Service ${targetId} is not running (pid ${String(entry.pid)} is dead). Run \`vis service start ${targetId}\` to recover.`);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    await runReadiness(entry.config, { timeoutMs: options.timeout });
+    pail.success(`${targetId} healthy (pid ${String(entry.pid)})`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    pail.error(`${targetId} probe failed: ${message}`);
+    process.exitCode = 1;
+  }
+};
+const serviceRestartExecute = async ({
+  argument,
+  options,
+  visConfig,
+  workspaceRoot: wsRoot
+}) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const targetId = argument[0]?.trim();
+  if (!targetId) {
+    pail.error("Missing target id. Usage: vis service restart <project>:<target>");
+    process.exitCode = 1;
+    return;
+  }
+  await stopService({ graceMs: options.graceMs, id: targetId, workspaceRoot });
+  const resolved = await resolveTarget(workspaceRoot, visConfig, targetId);
+  if (!resolved) {
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const { entry } = await startService({
+      command: resolved.command,
+      config: resolved.service,
+      cwd: resolved.cwd,
+      env: resolved.env,
+      id: targetId,
+      readinessTimeoutMs: options.timeout,
+      skipReadiness: options.noReadiness === true,
+      workspaceRoot
+    });
+    pail.success(`Restarted ${targetId} (pid ${String(entry.pid)})`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    pail.error(`Failed to restart ${targetId}: ${message}`);
+    process.exitCode = 1;
+  }
+};
+const TAIL_POLL_MS = 200;
+const TAIL_MAX_CHUNK_BYTES = 1024 * 1024;
+const tailLog = async (logFile) => {
+  let position = 0;
+  try {
+    const initial = await stat(logFile);
+    position = initial.size;
+  } catch {
+    position = 0;
+  }
+  const controller = new AbortController();
+  let sigintReceived = false;
+  const onSigint = () => {
+    sigintReceived = true;
+    controller.abort();
+  };
+  const onSigterm = () => {
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  let tickInFlight = false;
+  const tickOnce = async () => {
+    if (tickInFlight) {
+      return;
+    }
+    tickInFlight = true;
+    try {
+      const stats = await stat(logFile).catch(() => void 0);
+      if (!stats) {
+        return;
+      }
+      if (stats.size < position) {
+        position = 0;
+      }
+      if (stats.size === position) {
+        return;
+      }
+      const available = stats.size - position;
+      const chunkSize = Math.min(available, TAIL_MAX_CHUNK_BYTES);
+      const handle = await open(logFile, "r");
+      try {
+        const buffer = Buffer.alloc(chunkSize);
+        await handle.read(buffer, 0, chunkSize, position);
+        process.stdout.write(buffer);
+        position += chunkSize;
+      } finally {
+        await handle.close().catch(() => {
+        });
+      }
+    } finally {
+      tickInFlight = false;
+    }
+  };
+  try {
+    const watcher = (async () => {
+      try {
+        for await (const _event of watch(logFile, { signal: controller.signal })) {
+          await tickOnce();
+        }
+      } catch {
+      }
+    })();
+    while (!controller.signal.aborted) {
+      await tickOnce();
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, TAIL_POLL_MS);
+        controller.signal.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(timer);
+            resolve();
+          },
+          { once: true }
+        );
+      });
+    }
+    await watcher.catch(() => {
+    });
+    await tickOnce().catch(() => {
+    });
+  } finally {
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+  }
+  if (sigintReceived) {
+    process.exitCode = 130;
+  }
+};
+const serviceLogsExecute = async ({ argument, options, workspaceRoot: wsRoot }) => {
+  const workspaceRoot = requireWorkspace(wsRoot);
+  const targetId = argument[0]?.trim();
+  if (!targetId) {
+    pail.error("Missing target id. Usage: vis service logs <project>:<target>");
+    process.exitCode = 1;
+    return;
+  }
+  const entry = await readEntry(workspaceRoot, targetId);
+  if (!entry) {
+    pail.error(`No service registered for ${targetId}.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!await isAccessible(entry.logFile)) {
+    pail.warn(`Log file is missing for ${targetId}: ${entry.logFile}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (options.follow === true) {
+    await tailLog(entry.logFile);
+    return;
+  }
+  const handle = await open(entry.logFile, "r");
+  try {
+    const stream = handle.createReadStream();
+    await new Promise((resolve, reject) => {
+      stream.on("end", resolve);
+      stream.on("error", reject);
+      stream.pipe(process.stdout, { end: false });
+    });
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+};
+
+export { serviceListExecute, serviceLogsExecute, serviceRestartExecute, serviceStartExecute, serviceStatusExecute, serviceStopExecute };