@t3x-dev/local 0.1.2

package/README.md

@@ -0,0 +1,12 @@
+# `@t3x-dev/local`
+
+Minimal local entry package for T3X.
+
+Current PR2 scope:
+
+- `t3x-local start` launches the locally built API + Web
+- `t3x` forwards to `@t3x-dev/cli`
+- `t3x-mcp` forwards to `@t3x-dev/mcp`
+
+This phase uses local build artifacts already present in the monorepo.
+It does not download runtime assets yet.

package/dist/bin/t3x-local.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/t3x-local.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import {
+  checkHttpHealth,
+  getPortStatus,
+  getVersionLockReport,
+  getVersionSnapshot,
+  resolveStartOptions,
+  runStartCommand
+} from "../chunk-KNAXB6AU.js";
+import {
+  clearRuntimeState,
+  getLocalPaths,
+  getMissingStartArtifacts,
+  getRuntimeMetadataPaths,
+  getRuntimeProcessStatus,
+  readRuntimeState,
+  terminatePid
+} from "../chunk-E4LL4ESG.js";
+
+// src/bin/t3x-local.ts
+import { Command } from "commander";
+
+// src/commands/doctor.ts
+import fs from "fs";
+async function runDoctorCommand(input = {}) {
+  const paths = getLocalPaths();
+  const metadataPaths = getRuntimeMetadataPaths(paths);
+  const configured = resolveStartOptions(input, paths, process.env);
+  const state = await readRuntimeState(paths);
+  const versions = getVersionSnapshot(paths);
+  const versionLock = getVersionLockReport(paths);
+  const effective = {
+    dataDir: input.dataDir ? configured.dataDir : state?.dataDir ?? configured.dataDir,
+    apiPort: input.apiPort ?? state?.apiPort ?? configured.apiPort,
+    webPort: input.webPort ?? state?.webPort ?? configured.webPort
+  };
+  const missingArtifacts = getMissingStartArtifacts(paths);
+  const processStatus = state ? getRuntimeProcessStatus(state) : null;
+  const [apiPortStatus, webPortStatus, apiHealth, webHealth] = await Promise.all([
+    getPortStatus(effective.apiPort),
+    getPortStatus(effective.webPort),
+    checkHttpHealth(`http://127.0.0.1:${effective.apiPort}/health`),
+    checkHttpHealth(`http://127.0.0.1:${effective.webPort}/health`)
+  ]);
+  const problems = [];
+  if (missingArtifacts.length > 0) {
+    problems.push(
+      ...missingArtifacts.map((item) => `Missing build artifact: ${item.label} (${item.path})`)
+    );
+  }
+  if (!fs.existsSync(paths.cliEntryPath)) {
+    problems.push(`Missing CLI shim target: ${paths.cliEntryPath}`);
+  }
+  if (!fs.existsSync(paths.mcpEntryPath)) {
+    problems.push(`Missing MCP shim target: ${paths.mcpEntryPath}`);
+  }
+  if (state && processStatus && (!processStatus.apiRunning || !processStatus.webRunning)) {
+    problems.push("Runtime state file exists but one or more recorded PIDs are not running");
+  }
+  if (!state && !apiPortStatus.available) {
+    problems.push(`API port ${effective.apiPort} is occupied outside the local runtime`);
+  }
+  if (!state && !webPortStatus.available) {
+    problems.push(`Web port ${effective.webPort} is occupied outside the local runtime`);
+  }
+  if (state && processStatus?.apiRunning && !apiHealth.ok) {
+    problems.push(`API process is running but health check failed: ${apiHealth.details}`);
+  }
+  if (state && processStatus?.webRunning && !webHealth.ok) {
+    problems.push(`Web process is running but health check failed: ${webHealth.details}`);
+  }
+  if (versionLock.problems.length > 0) {
+    problems.push(...versionLock.problems);
+  }
+  const status = getDoctorStatus(state, processStatus, apiHealth.ok, webHealth.ok);
+  console.log("[t3x-local] Doctor");
+  console.log(`Status: ${status}`);
+  console.log(
+    `Versions: local=${versions.local} api=${versions.api} web=${versions.web} cli=${versions.cli} mcp=${versions.mcp}`
+  );
+  console.log(
+    `Fixed version: ${versions.fixedVersion} (${versionLock.problems.length === 0 ? "ok" : "mismatch"})`
+  );
+  console.log(`Node: ${versions.node} (${versions.platform})`);
+  console.log(`Repo root: ${paths.repoRoot}`);
+  console.log(`Runtime source: ${paths.runtimeSource}`);
+  console.log(`Installed runtime dir: ${paths.installedRuntimeDir}`);
+  console.log(
+    `Configured data dir: ${effective.dataDir} (${fs.existsSync(effective.dataDir) ? "exists" : "missing"})`
+  );
+  console.log(
+    `State file: ${metadataPaths.stateFilePath} (${fs.existsSync(metadataPaths.stateFilePath) ? "present" : "absent"})`
+  );
+  console.log(`API log: ${metadataPaths.apiLogPath}`);
+  console.log(`Web log: ${metadataPaths.webLogPath}`);
+  console.log(
+    `CLI target: ${paths.cliEntryPath} (${fs.existsSync(paths.cliEntryPath) ? "ok" : "missing"})`
+  );
+  console.log(
+    `MCP target: ${paths.mcpEntryPath} (${fs.existsSync(paths.mcpEntryPath) ? "ok" : "missing"})`
+  );
+  console.log(
+    `API: port=${effective.apiPort} pid=${state?.apiPid ?? "n/a"} portStatus=${apiPortStatus.details} health=${formatHealth(apiHealth)}`
+  );
+  console.log(
+    `Web: port=${effective.webPort} pid=${state?.webPid ?? "n/a"} portStatus=${webPortStatus.details} health=${formatHealth(webHealth)}`
+  );
+  if (missingArtifacts.length === 0) {
+    console.log("Artifacts: all required local build artifacts are present");
+  } else {
+    console.log("Artifacts: missing required build outputs");
+  }
+  if (problems.length > 0) {
+    console.log("Problems:");
+    for (const problem of problems) {
+      console.log(`- ${problem}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  console.log("Problems: none");
+}
+function getDoctorStatus(state, processStatus, apiHealthy, webHealthy) {
+  if (!state) {
+    return "stopped";
+  }
+  if (!processStatus?.apiRunning && !processStatus?.webRunning) {
+    return "stale-state";
+  }
+  if (processStatus.apiRunning && processStatus.webRunning && apiHealthy && webHealthy) {
+    return "running";
+  }
+  return "degraded";
+}
+function formatHealth(result) {
+  return result.ok ? `ok (${result.details})` : `failed (${result.details})`;
+}
+
+// src/commands/reset.ts
+import fs2 from "fs/promises";
+
+// src/commands/stop.ts
+async function runStopCommand() {
+  const paths = getLocalPaths();
+  const state = await readRuntimeState(paths);
+  if (!state) {
+    console.log("[t3x-local] No local runtime state file found. Nothing to stop.");
+    return;
+  }
+  const before = getRuntimeProcessStatus(state);
+  if (!before.apiRunning && !before.webRunning) {
+    await clearRuntimeState(paths);
+    console.log("[t3x-local] Runtime state was stale. Cleared local state files.");
+    return;
+  }
+  const webResult = await terminatePid(state.webPid);
+  const apiResult = await terminatePid(state.apiPid);
+  await clearRuntimeState(paths);
+  console.log(
+    `[t3x-local] Web process ${state.webPid}: ${webResult === "stopped" ? "stopped" : "not running"}`
+  );
+  console.log(
+    `[t3x-local] API process ${state.apiPid}: ${apiResult === "stopped" ? "stopped" : "not running"}`
+  );
+  console.log("[t3x-local] Cleared local runtime state.");
+}
+
+// src/commands/reset.ts
+async function runResetCommand(input = {}) {
+  const paths = getLocalPaths();
+  const state = await readRuntimeState(paths);
+  const configured = resolveStartOptions({ dataDir: input.dataDir }, paths, process.env);
+  const dataDir = input.dataDir ? configured.dataDir : state?.dataDir ?? configured.dataDir;
+  const processStatus = state ? getRuntimeProcessStatus(state) : null;
+  if (processStatus && (processStatus.apiRunning || processStatus.webRunning)) {
+    if (!input.force) {
+      throw new Error(
+        "[t3x-local] Local runtime is still running. Run `t3x-local stop` first or use `t3x-local reset --force`."
+      );
+    }
+    await runStopCommand();
+  }
+  await Promise.all([
+    fs2.rm(dataDir, { recursive: true, force: true }),
+    fs2.rm(paths.localRuntimeRoot, { recursive: true, force: true })
+  ]);
+  console.log(`[t3x-local] Removed data dir: ${dataDir}`);
+  console.log(`[t3x-local] Removed runtime dir: ${paths.localRuntimeRoot}`);
+}
+
+// src/bin/t3x-local.ts
+var program = new Command();
+program.name("t3x-local").description("T3X local runtime entrypoint").version("0.1.1");
+program.command("start").description("Start the local API and Web runtimes in the background").option("--data-dir <path>", "Embedded PostgreSQL data directory").option("--api-port <port>", "API port (default: 8000)", parseInteger).option("--web-port <port>", "Web port (default: 3000)", parseInteger).action(async (options) => {
+  await runStartCommand(options);
+});
+program.command("stop").description("Stop the local API and Web runtimes").action(async () => {
+  await runStopCommand();
+});
+program.command("doctor").description("Print local runtime diagnostics").option("--data-dir <path>", "Embedded PostgreSQL data directory").option("--api-port <port>", "API port override", parseInteger).option("--web-port <port>", "Web port override", parseInteger).action(async (options) => {
+  await runDoctorCommand(options);
+});
+program.command("reset").description("Remove local runtime state and data").option("--data-dir <path>", "Embedded PostgreSQL data directory").option("--force", "Stop the runtime before clearing local data").action(async (options) => {
+  await runResetCommand(options);
+});
+program.parseAsync().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[t3x-local] ${message}`);
+  process.exit(1);
+});
+function parseInteger(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid integer: ${value}`);
+  }
+  return parsed;
+}

package/dist/bin/t3x-mcp.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/t3x-mcp.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  getLocalPaths,
+  readRuntimeState,
+  runNodeScript
+} from "../chunk-E4LL4ESG.js";
+
+// src/bin/t3x-mcp.ts
+var paths = getLocalPaths();
+var runtimeState = await readRuntimeState(paths);
+if (runtimeState) {
+  process.env.T3X_DATA_DIR ??= runtimeState.dataDir;
+}
+await runNodeScript({
+  name: "t3x-mcp",
+  entryPath: paths.mcpEntryPath,
+  args: process.argv.slice(2),
+  env: process.env
+});

package/dist/bin/t3x.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/t3x.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  getLocalPaths,
+  readRuntimeState,
+  runNodeScript
+} from "../chunk-E4LL4ESG.js";
+
+// src/bin/t3x.ts
+var paths = getLocalPaths();
+var runtimeState = await readRuntimeState(paths);
+if (runtimeState) {
+  process.env.T3X_API_URL ??= `${runtimeState.apiUrl}/api`;
+  process.env.T3X_WEB_URL ??= runtimeState.webUrl;
+}
+await runNodeScript({
+  name: "t3x",
+  entryPath: paths.cliEntryPath,
+  args: process.argv.slice(2),
+  env: process.env
+});

package/dist/chunk-E4LL4ESG.js

@@ -0,0 +1,381 @@
+// src/runtime/paths.ts
+import fs from "fs";
+import { createRequire } from "module";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+function getLocalPaths() {
+  const packageDir = findLocalPackageDir(path.dirname(fileURLToPath(import.meta.url)));
+  const repoRoot = findRepoRoot(packageDir);
+  const appHomeDir = resolveAppHomeDir(repoRoot);
+  const runtimeManifestPath = path.join(packageDir, "runtime-manifest.json");
+  const installedRuntimeDir = resolveInstalledRuntimeDir(packageDir);
+  const runtimeSource = resolveRuntimeSource(repoRoot, installedRuntimeDir);
+  return {
+    packageDir,
+    repoRoot,
+    appHomeDir,
+    defaultDataDir: path.join(appHomeDir, "pg-data"),
+    localRuntimeRoot: path.join(appHomeDir, "local-runtime"),
+    runtimeManifestPath,
+    installedRuntimeDir,
+    runtimeSource,
+    apiEntryPath: runtimeSource === "installed" ? path.join(installedRuntimeDir, "api", "dist", "index.js") : path.join(assertRepoRoot(repoRoot), "apps", "api", "dist", "index.js"),
+    webStandaloneDir: runtimeSource === "installed" ? path.join(installedRuntimeDir, "web", "standalone") : path.join(assertRepoRoot(repoRoot), "apps", "web", ".next", "standalone"),
+    webStandaloneServerPath: runtimeSource === "installed" ? path.join(installedRuntimeDir, "web", "standalone", "apps", "web", "server.js") : path.join(
+      assertRepoRoot(repoRoot),
+      "apps",
+      "web",
+      ".next",
+      "standalone",
+      "apps",
+      "web",
+      "server.js"
+    ),
+    webStaticDir: runtimeSource === "installed" ? path.join(installedRuntimeDir, "web", "static") : path.join(assertRepoRoot(repoRoot), "apps", "web", ".next", "static"),
+    webPublicDir: runtimeSource === "installed" ? path.join(installedRuntimeDir, "web", "public") : path.join(assertRepoRoot(repoRoot), "apps", "web", "public"),
+    cliEntryPath: resolvePackageBinEntry({
+      packageName: "@t3x-dev/cli",
+      binName: "t3x",
+      repoRoot,
+      workspaceRelativeDir: path.join("apps", "cli")
+    }),
+    mcpEntryPath: resolvePackageBinEntry({
+      packageName: "@t3x-dev/mcp",
+      binName: "t3x-mcp",
+      repoRoot,
+      workspaceRelativeDir: path.join("apps", "mcp")
+    })
+  };
+}
+function findLocalPackageDir(startDir) {
+  let current = startDir;
+  while (current !== path.dirname(current)) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (packageJson.name === "@t3x-dev/local") {
+        return current;
+      }
+    }
+    current = path.dirname(current);
+  }
+  throw new Error(`Could not locate @t3x-dev/local package root above ${startDir}`);
+}
+function getMissingStartArtifacts(paths) {
+  const required = [
+    { label: "API runtime entry", path: paths.apiEntryPath },
+    { label: "Web standalone server", path: paths.webStandaloneServerPath },
+    { label: "Web static assets", path: paths.webStaticDir },
+    { label: "Web public assets", path: paths.webPublicDir }
+  ];
+  return required.filter((item) => !fs.existsSync(item.path));
+}
+function formatMissingArtifacts(items, paths) {
+  const details = items.map((item) => `- ${item.label}: ${item.path}`).join("\n");
+  const hint = paths.runtimeSource === "installed" ? "Reinstall `@t3x-dev/local`, or rerun the postinstall download with `T3X_LOCAL_RUNTIME_MIRROR` configured." : "Run `pnpm build:api-server` and `pnpm build:webui` from the repo root first.";
+  return `Missing local runtime artifacts required by \`t3x-local start\`.
+${details}
+` + hint;
+}
+function resolvePlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+function resolveRuntimeSource(repoRoot, installedRuntimeDir) {
+  if (process.env.T3X_LOCAL_RUNTIME_DIR) {
+    return "installed";
+  }
+  if (!repoRoot) {
+    return "installed";
+  }
+  return fs.existsSync(path.join(installedRuntimeDir, "api", "dist", "index.js")) ? "installed" : "workspace";
+}
+function resolveAppHomeDir(repoRoot) {
+  if (repoRoot) {
+    return path.join(repoRoot, ".t3x");
+  }
+  return path.join(os.homedir(), ".t3x");
+}
+function resolveInstalledRuntimeDir(packageDir) {
+  if (process.env.T3X_LOCAL_RUNTIME_DIR) {
+    return path.resolve(process.env.T3X_LOCAL_RUNTIME_DIR);
+  }
+  return path.join(packageDir, "runtime", resolvePlatformKey());
+}
+function findRepoRoot(startDir) {
+  let current = startDir;
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, "pnpm-workspace.yaml")) && fs.existsSync(path.join(current, "apps", "api", "package.json")) && fs.existsSync(path.join(current, "apps", "web", "package.json")) && fs.existsSync(path.join(current, "apps", "local", "package.json"))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
+function resolvePackageBinEntry(options) {
+  const installedPackageJsonPath = resolveInstalledPackageJson(options.packageName);
+  if (installedPackageJsonPath) {
+    return resolveBinFromPackageJson(installedPackageJsonPath, options.binName);
+  }
+  if (!options.repoRoot) {
+    throw new Error(`Could not resolve installed package ${options.packageName}`);
+  }
+  return resolveBinFromPackageJson(
+    path.join(options.repoRoot, options.workspaceRelativeDir, "package.json"),
+    options.binName
+  );
+}
+function resolveInstalledPackageJson(packageName) {
+  try {
+    const entryPath = require2.resolve(packageName);
+    return findNearestPackageJson(entryPath);
+  } catch {
+    return null;
+  }
+}
+function resolveBinFromPackageJson(packageJsonPath, binName) {
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`Missing package.json for ${binName}: ${packageJsonPath}`);
+  }
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  const relativeEntry = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[binName];
+  if (!relativeEntry) {
+    const packageName = packageJson.name ?? packageJsonPath;
+    throw new Error(`Package ${packageName} does not declare a \`${binName}\` bin entry`);
+  }
+  return path.resolve(path.dirname(packageJsonPath), relativeEntry);
+}
+function findNearestPackageJson(startPath) {
+  let current = path.dirname(startPath);
+  while (current !== path.dirname(current)) {
+    const packageJsonPath = path.join(current, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
+    current = path.dirname(current);
+  }
+  throw new Error(`Could not locate package.json above ${startPath}`);
+}
+function assertRepoRoot(repoRoot) {
+  if (!repoRoot) {
+    throw new Error("Workspace runtime source requested outside the monorepo");
+  }
+  return repoRoot;
+}
+
+// src/runtime/pid.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var STATE_SCHEMA_VERSION = 1;
+function getRuntimeMetadataPaths(paths) {
+  return {
+    runtimeRoot: paths.localRuntimeRoot,
+    logsDir: path2.join(paths.localRuntimeRoot, "logs"),
+    stateFilePath: path2.join(paths.localRuntimeRoot, "state.json"),
+    apiPidFilePath: path2.join(paths.localRuntimeRoot, "api.pid"),
+    webPidFilePath: path2.join(paths.localRuntimeRoot, "web.pid"),
+    apiLogPath: path2.join(paths.localRuntimeRoot, "logs", "api.log"),
+    webLogPath: path2.join(paths.localRuntimeRoot, "logs", "web.log")
+  };
+}
+async function ensureRuntimeMetadataDirs(paths) {
+  const metadataPaths = getRuntimeMetadataPaths(paths);
+  await fs2.mkdir(metadataPaths.runtimeRoot, { recursive: true });
+  await fs2.mkdir(metadataPaths.logsDir, { recursive: true });
+  return metadataPaths;
+}
+async function readRuntimeState(paths) {
+  const { stateFilePath } = getRuntimeMetadataPaths(paths);
+  try {
+    const raw = await fs2.readFile(stateFilePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== STATE_SCHEMA_VERSION) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeRuntimeState(paths, state) {
+  const metadataPaths = await ensureRuntimeMetadataDirs(paths);
+  await Promise.all([
+    fs2.writeFile(metadataPaths.stateFilePath, `${JSON.stringify(state, null, 2)}
+`, "utf8"),
+    fs2.writeFile(metadataPaths.apiPidFilePath, `${state.apiPid}
+`, "utf8"),
+    fs2.writeFile(metadataPaths.webPidFilePath, `${state.webPid}
+`, "utf8")
+  ]);
+}
+async function clearRuntimeState(paths) {
+  const metadataPaths = getRuntimeMetadataPaths(paths);
+  await Promise.all([
+    fs2.rm(metadataPaths.stateFilePath, { force: true }),
+    fs2.rm(metadataPaths.apiPidFilePath, { force: true }),
+    fs2.rm(metadataPaths.webPidFilePath, { force: true })
+  ]);
+}
+function getRuntimeProcessStatus(state) {
+  return {
+    apiRunning: isProcessRunning(state.apiPid),
+    webRunning: isProcessRunning(state.webPid)
+  };
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isPermissionError(error);
+  }
+}
+async function terminatePid(pid, signal = "SIGTERM", timeoutMs = 5e3) {
+  if (!isProcessRunning(pid)) {
+    return "not-running";
+  }
+  process.kill(pid, signal);
+  const stopped = await waitForPidExit(pid, timeoutMs);
+  if (stopped) {
+    return "stopped";
+  }
+  process.kill(pid, "SIGKILL");
+  await waitForPidExit(pid, 2e3);
+  return "stopped";
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessRunning(pid)) {
+      return true;
+    }
+    await sleep(200);
+  }
+  return !isProcessRunning(pid);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isFileNotFoundError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+function isPermissionError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "EPERM"
+  );
+}
+
+// src/runtime/spawn.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+function spawnNodeScript(options) {
+  if (!fs3.existsSync(options.entryPath)) {
+    throw new Error(`[t3x-local] Missing ${options.name} entrypoint: ${options.entryPath}`);
+  }
+  const { stdio, openDescriptors } = buildStdio(options);
+  const child = spawn(process.execPath, [options.entryPath, ...options.args ?? []], {
+    cwd: options.cwd,
+    detached: options.detached,
+    env: options.env,
+    stdio
+  });
+  for (const descriptor of openDescriptors) {
+    fs3.closeSync(descriptor);
+  }
+  if (options.detached) {
+    child.unref();
+  }
+  child.on("error", (error) => {
+    console.error(`[t3x-local] Failed to start ${options.name}: ${error.message}`);
+  });
+  return {
+    name: options.name,
+    child
+  };
+}
+async function runNodeScript(options) {
+  const spawned = spawnNodeScript(options);
+  const exit = await onProcessExit(spawned);
+  if (exit.signal) {
+    process.kill(process.pid, exit.signal);
+    return new Promise(() => {
+    });
+  }
+  process.exit(exit.code ?? 1);
+}
+function buildStdio(options) {
+  if (!options.stdoutPath && !options.stderrPath) {
+    return {
+      stdio: "inherit",
+      openDescriptors: []
+    };
+  }
+  const stdoutPath = options.stdoutPath ?? options.stderrPath;
+  const stderrPath = options.stderrPath ?? options.stdoutPath;
+  if (!stdoutPath || !stderrPath) {
+    throw new Error(
+      `[t3x-local] Both stdout and stderr log paths must be provided for ${options.name}`
+    );
+  }
+  fs3.mkdirSync(path3.dirname(stdoutPath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(stderrPath), { recursive: true });
+  const stdoutDescriptor = fs3.openSync(stdoutPath, "a");
+  const stderrDescriptor = fs3.openSync(stderrPath, "a");
+  return {
+    stdio: ["ignore", stdoutDescriptor, stderrDescriptor],
+    openDescriptors: [stdoutDescriptor, stderrDescriptor]
+  };
+}
+function onProcessExit(processInfo) {
+  return new Promise((resolve) => {
+    processInfo.child.once("exit", (code, signal) => {
+      resolve({
+        name: processInfo.name,
+        code,
+        signal
+      });
+    });
+  });
+}
+async function terminateProcess(processInfo) {
+  if (processInfo.child.exitCode !== null || processInfo.child.signalCode !== null) {
+    return;
+  }
+  processInfo.child.kill("SIGTERM");
+  await Promise.race([
+    onProcessExit(processInfo).then(() => void 0),
+    new Promise((resolve) => {
+      setTimeout(() => {
+        if (processInfo.child.exitCode === null && processInfo.child.signalCode === null) {
+          processInfo.child.kill("SIGKILL");
+        }
+        resolve();
+      }, 5e3);
+    })
+  ]);
+}
+
+export {
+  getLocalPaths,
+  getMissingStartArtifacts,
+  formatMissingArtifacts,
+  getRuntimeMetadataPaths,
+  ensureRuntimeMetadataDirs,
+  readRuntimeState,
+  writeRuntimeState,
+  clearRuntimeState,
+  getRuntimeProcessStatus,
+  terminatePid,
+  spawnNodeScript,
+  runNodeScript,
+  terminateProcess
+};