ownlab 0.0.3

package/dist/index.js

@@ -0,0 +1,853 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { Command } from "commander";
+
+// ../../packages/shared/src/constants.ts
+var ADAPTER_TYPE_LABELS = {
+  codex_local: "Codex",
+  claude_code: "Claude Code",
+  opencode: "OpenCode"
+};
+
+// src/config/store.ts
+import fs from "node:fs";
+import path2 from "node:path";
+
+// src/config/home.ts
+import os from "node:os";
+import path from "node:path";
+var DEFAULT_INSTANCE_ID = "default";
+var INSTANCE_ID_RE = /^[a-zA-Z0-9_-]+$/;
+function expandHomePrefix(value) {
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/")) return path.resolve(os.homedir(), value.slice(2));
+  return value;
+}
+function resolveOwnlabHomeDir() {
+  const envHome = process.env.OWNLAB_HOME?.trim();
+  if (envHome) return path.resolve(expandHomePrefix(envHome));
+  return path.resolve(os.homedir(), ".ownlab");
+}
+function resolveOwnlabInstanceId(override) {
+  const raw = override?.trim() || process.env.OWNLAB_INSTANCE_ID?.trim() || DEFAULT_INSTANCE_ID;
+  if (!INSTANCE_ID_RE.test(raw)) {
+    throw new Error(`Invalid instance id '${raw}'. Allowed characters: letters, numbers, '_' and '-'.`);
+  }
+  return raw;
+}
+function resolveOwnlabInstanceRoot(instanceId) {
+  return path.resolve(resolveOwnlabHomeDir(), "instances", resolveOwnlabInstanceId(instanceId));
+}
+function resolveDefaultConfigPath(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), "config.json");
+}
+function resolveDefaultEnvPath(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), ".env");
+}
+function resolveDefaultDbDir(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), "db");
+}
+function resolveDefaultLogDir(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), "logs");
+}
+function resolveDefaultBackupDir(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), "data", "backups");
+}
+function resolveDefaultCacheDir(instanceId) {
+  return path.resolve(resolveOwnlabInstanceRoot(instanceId), "cache");
+}
+function describeLocalInstancePaths(instanceId) {
+  const resolvedInstanceId = resolveOwnlabInstanceId(instanceId);
+  const instanceRoot = resolveOwnlabInstanceRoot(resolvedInstanceId);
+  return {
+    homeDir: resolveOwnlabHomeDir(),
+    instanceId: resolvedInstanceId,
+    instanceRoot,
+    configPath: resolveDefaultConfigPath(resolvedInstanceId),
+    envPath: resolveDefaultEnvPath(resolvedInstanceId),
+    dbDir: resolveDefaultDbDir(resolvedInstanceId),
+    logDir: resolveDefaultLogDir(resolvedInstanceId),
+    backupDir: resolveDefaultBackupDir(resolvedInstanceId),
+    cacheDir: resolveDefaultCacheDir(resolvedInstanceId)
+  };
+}
+
+// src/config/schema.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPort(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535;
+}
+function validateOwnlabCliConfig(value) {
+  if (!isObject(value)) {
+    throw new Error("Config must be an object");
+  }
+  const { version, server, web, database, runtime } = value;
+  if (version !== 1) {
+    throw new Error("Config version must be 1");
+  }
+  if (!isObject(server) || typeof server.host !== "string" || !isPort(server.port)) {
+    throw new Error("Config server.host/server.port are required");
+  }
+  if (!isObject(web) || typeof web.host !== "string" || !isPort(web.port) || web.mode !== "local-next") {
+    throw new Error("Config web.host/web.port/web.mode are required");
+  }
+  if (!isObject(database) || database.mode !== "embedded-postgres" && database.mode !== "postgres" || typeof database.embeddedPostgresDataDir !== "string" || !isPort(database.embeddedPostgresPort)) {
+    throw new Error("Config database settings are invalid");
+  }
+  if (!isObject(runtime) || typeof runtime.ownlabHome !== "string" || typeof runtime.instanceId !== "string" || typeof runtime.logDir !== "string" || typeof runtime.backupDir !== "string" || typeof runtime.cacheDir !== "string") {
+    throw new Error("Config runtime settings are invalid");
+  }
+  return {
+    version: 1,
+    server: {
+      host: server.host,
+      port: server.port
+    },
+    web: {
+      host: web.host,
+      port: web.port,
+      mode: "local-next"
+    },
+    database: {
+      mode: database.mode,
+      ...typeof database.connectionString === "string" ? { connectionString: database.connectionString } : {},
+      embeddedPostgresDataDir: database.embeddedPostgresDataDir,
+      embeddedPostgresPort: database.embeddedPostgresPort
+    },
+    runtime: {
+      ownlabHome: runtime.ownlabHome,
+      instanceId: runtime.instanceId,
+      logDir: runtime.logDir,
+      backupDir: runtime.backupDir,
+      cacheDir: runtime.cacheDir
+    }
+  };
+}
+
+// src/config/store.ts
+var DEFAULT_CONFIG_BASENAME = "config.json";
+function findConfigFileFromAncestors(startDir) {
+  let currentDir = path2.resolve(startDir);
+  while (true) {
+    const candidate = path2.resolve(currentDir, ".ownlab", DEFAULT_CONFIG_BASENAME);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const nextDir = path2.resolve(currentDir, "..");
+    if (nextDir === currentDir) break;
+    currentDir = nextDir;
+  }
+  return null;
+}
+function resolveConfigPath(overridePath) {
+  if (overridePath) return path2.resolve(overridePath);
+  if (process.env.OWNLAB_CONFIG) return path2.resolve(process.env.OWNLAB_CONFIG);
+  return findConfigFileFromAncestors(process.cwd()) ?? resolveDefaultConfigPath(resolveOwnlabInstanceId());
+}
+function configExists(configPath) {
+  return fs.existsSync(resolveConfigPath(configPath));
+}
+function readConfig(configPath) {
+  const filePath = resolveConfigPath(configPath);
+  if (!fs.existsSync(filePath)) return null;
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return validateOwnlabCliConfig(raw);
+}
+function writeConfig(config, configPath) {
+  const filePath = resolveConfigPath(configPath);
+  fs.mkdirSync(path2.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  return filePath;
+}
+
+// src/checks/config.ts
+function configCheck(configPath) {
+  if (!configExists(configPath)) {
+    return {
+      name: "Config file",
+      status: "fail",
+      message: "No config file found. Run `ownlab onboard --yes` first."
+    };
+  }
+  try {
+    readConfig(configPath);
+    return {
+      name: "Config file",
+      status: "pass",
+      message: "Config file exists and is valid."
+    };
+  } catch (error) {
+    return {
+      name: "Config file",
+      status: "fail",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/checks/env.ts
+import fs3 from "node:fs";
+
+// src/config/env.ts
+import fs2 from "node:fs";
+import path3 from "node:path";
+var loadedEnvFiles = /* @__PURE__ */ new Set();
+function resolveEnvFilePath(configPath) {
+  return path3.resolve(path3.dirname(resolveConfigPath(configPath)), ".env");
+}
+function parseEnvFile(contents) {
+  const entries = {};
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eqIndex = line.indexOf("=");
+    if (eqIndex <= 0) continue;
+    const key = line.slice(0, eqIndex).trim();
+    let value = line.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries[key] = value;
+  }
+  return entries;
+}
+function renderEnvFile(entries) {
+  return [
+    "# OwnLab environment variables",
+    "# Generated by OwnLab CLI commands",
+    ...Object.entries(entries).map(([key, value]) => `${key}=${JSON.stringify(value)}`),
+    ""
+  ].join("\n");
+}
+function resolveOwnlabEnvFile(configPath) {
+  return resolveEnvFilePath(configPath);
+}
+function readOwnlabEnvEntries(filePath = resolveEnvFilePath()) {
+  if (!fs2.existsSync(filePath)) return {};
+  return parseEnvFile(fs2.readFileSync(filePath, "utf8"));
+}
+function writeOwnlabEnvEntries(entries, filePath = resolveEnvFilePath()) {
+  fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, renderEnvFile(entries), { mode: 384 });
+}
+function mergeOwnlabEnvEntries(entries, filePath = resolveEnvFilePath()) {
+  const current = readOwnlabEnvEntries(filePath);
+  const next = {
+    ...current,
+    ...Object.fromEntries(
+      Object.entries(entries).filter(([, value]) => typeof value === "string" && value.trim().length > 0)
+    )
+  };
+  writeOwnlabEnvEntries(next, filePath);
+  return next;
+}
+function loadOwnlabEnvFile(configPath) {
+  const filePath = resolveEnvFilePath(configPath);
+  if (loadedEnvFiles.has(filePath) || !fs2.existsSync(filePath)) return;
+  loadedEnvFiles.add(filePath);
+  const entries = readOwnlabEnvEntries(filePath);
+  for (const [key, value] of Object.entries(entries)) {
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+
+// src/checks/env.ts
+function envCheck(configPath) {
+  const envFile = resolveOwnlabEnvFile(configPath);
+  if (!fs3.existsSync(envFile)) {
+    return {
+      name: ".env file",
+      status: "warn",
+      message: `No .env file found at ${envFile}. It will be created during onboard.`
+    };
+  }
+  return {
+    name: ".env file",
+    status: "pass",
+    message: `.env file found at ${envFile}.`
+  };
+}
+
+// src/checks/filesystem.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+function checkPathWritable(targetPath) {
+  const parentDir = fs4.existsSync(targetPath) ? targetPath : path4.dirname(targetPath);
+  try {
+    fs4.mkdirSync(parentDir, { recursive: true });
+    fs4.accessSync(parentDir, fs4.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function filesystemCheck(config) {
+  const targets = [
+    ["OwnLab home", config.runtime.ownlabHome],
+    ["Log dir", config.runtime.logDir],
+    ["Backup dir", config.runtime.backupDir],
+    ["Cache dir", config.runtime.cacheDir],
+    ["Embedded Postgres dir", config.database.embeddedPostgresDataDir]
+  ];
+  return targets.map(([name, targetPath]) => ({
+    name,
+    status: checkPathWritable(targetPath) ? "pass" : "fail",
+    message: checkPathWritable(targetPath) ? `${name} is writable: ${targetPath}` : `${name} is not writable: ${targetPath}`
+  }));
+}
+
+// src/checks/node.ts
+function nodeCheck() {
+  const major = Number(process.versions.node.split(".")[0] ?? "0");
+  if (major < 20) {
+    return {
+      name: "Node.js version",
+      status: "fail",
+      message: `Node.js 20+ is required. Current version: ${process.versions.node}`
+    };
+  }
+  return {
+    name: "Node.js version",
+    status: "pass",
+    message: `Node.js version is supported: ${process.versions.node}`
+  };
+}
+
+// src/checks/ports.ts
+import net from "node:net";
+function checkPortFree(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.listen(port, host, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+async function portChecks(config) {
+  const serverFree = await checkPortFree(config.server.port, config.server.host);
+  const webFree = await checkPortFree(config.web.port, config.web.host);
+  return [
+    {
+      name: "Server port",
+      status: serverFree ? "pass" : "warn",
+      message: serverFree ? `Port ${config.server.port} is available.` : `Port ${config.server.port} is already in use. This may be fine if OwnLab is already running.`
+    },
+    {
+      name: "Web port",
+      status: webFree ? "pass" : "warn",
+      message: webFree ? `Port ${config.web.port} is available.` : `Port ${config.web.port} is already in use. This may be fine if the web app is already running.`
+    }
+  ];
+}
+
+// src/checks/server.ts
+async function serverCheck(options) {
+  if (options.repoRoot) {
+    const serverEntry = `${options.repoRoot}/apps/server/src/index.ts`;
+    return {
+      name: "Server runtime",
+      status: "pass",
+      message: `Found OwnLab server entry at ${serverEntry}`
+    };
+  }
+  if (options.serverPackageRoot) {
+    return {
+      name: "Server runtime",
+      status: "pass",
+      message: `Resolved packaged OwnLab server from ${options.serverPackageRoot}`
+    };
+  }
+  try {
+    await import("@ownlabai/server");
+    return {
+      name: "Server runtime",
+      status: "pass",
+      message: `Resolved packaged OwnLab server from ${options.serverPackageRoot ?? "@ownlabai/server"}`
+    };
+  } catch {
+  }
+  return {
+    name: "Server runtime",
+    status: "fail",
+    message: "Could not resolve repo or packaged OwnLab server runtime."
+  };
+}
+
+// src/runtime/paths.ts
+import fs5 from "node:fs";
+import { createRequire } from "node:module";
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
+function readPackageName(packageJsonPath) {
+  try {
+    const raw = fs5.readFileSync(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.name ?? null;
+  } catch {
+    return null;
+  }
+}
+function findCliPackageRoot(fromImportMetaUrl) {
+  let currentDir = path5.dirname(fileURLToPath(fromImportMetaUrl));
+  while (true) {
+    const packageJsonPath = path5.join(currentDir, "package.json");
+    if (fs5.existsSync(packageJsonPath) && readPackageName(packageJsonPath) === "ownlab") {
+      return currentDir;
+    }
+    const parentDir = path5.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return path5.resolve(path5.dirname(fileURLToPath(fromImportMetaUrl)), "../..");
+}
+function findRepoRoot(cliPackageRoot) {
+  const candidates = [
+    path5.resolve(cliPackageRoot, "../.."),
+    path5.resolve(cliPackageRoot, "../../.."),
+    process.cwd()
+  ];
+  for (const candidate of candidates) {
+    const serverEntry = path5.resolve(candidate, "apps/server/src/index.ts");
+    const webPackageJson = path5.resolve(candidate, "apps/web/package.json");
+    if (fs5.existsSync(serverEntry) && fs5.existsSync(webPackageJson)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function findInstalledServerPackageRoot(fromImportMetaUrl) {
+  const cliPackageRoot = findCliPackageRoot(fromImportMetaUrl);
+  const siblingCandidates = [
+    path5.resolve(cliPackageRoot, "../@ownlabai/server"),
+    path5.resolve(cliPackageRoot, "../../@ownlabai/server")
+  ];
+  for (const candidate of siblingCandidates) {
+    const packageJsonPath = path5.resolve(candidate, "package.json");
+    if (fs5.existsSync(packageJsonPath) && readPackageName(packageJsonPath) === "@ownlabai/server") {
+      return candidate;
+    }
+  }
+  try {
+    const require2 = createRequire(fromImportMetaUrl);
+    const serverEntry = require2.resolve("@ownlabai/server");
+    return path5.resolve(serverEntry, "..", "..");
+  } catch {
+    return null;
+  }
+}
+function findInstalledWebPackageRoot(fromImportMetaUrl) {
+  const cliPackageRoot = findCliPackageRoot(fromImportMetaUrl);
+  const siblingCandidates = [
+    path5.resolve(cliPackageRoot, "../@ownlabai/web"),
+    path5.resolve(cliPackageRoot, "../../@ownlabai/web")
+  ];
+  for (const candidate of siblingCandidates) {
+    const packageJsonPath = path5.resolve(candidate, "package.json");
+    if (fs5.existsSync(packageJsonPath) && readPackageName(packageJsonPath) === "@ownlabai/web") {
+      return candidate;
+    }
+  }
+  try {
+    const require2 = createRequire(fromImportMetaUrl);
+    const webPackageJson = require2.resolve("@ownlabai/web/package.json");
+    return path5.dirname(webPackageJson);
+  } catch {
+    return null;
+  }
+}
+function getInstalledWebNextBinPath(webPackageRoot) {
+  return path5.resolve(webPackageRoot, "node_modules/next/dist/bin/next");
+}
+function hasInstalledWebPackage(webPackageRoot) {
+  if (!webPackageRoot) return false;
+  return fs5.existsSync(path5.resolve(webPackageRoot, ".next/BUILD_ID")) && fs5.existsSync(getInstalledWebNextBinPath(webPackageRoot));
+}
+
+// src/checks/web.ts
+function webCheck(options) {
+  if (options.repoRoot) {
+    const webPackageJson = `${options.repoRoot}/apps/web/package.json`;
+    return {
+      name: "Web runtime",
+      status: "pass",
+      message: `Found OwnLab web app at ${webPackageJson}`
+    };
+  }
+  if (hasInstalledWebPackage(options.webPackageRoot)) {
+    return {
+      name: "Web runtime",
+      status: "pass",
+      message: `Found packaged OwnLab web runtime at ${options.webPackageRoot}`
+    };
+  }
+  return {
+    name: "Web runtime",
+    status: "fail",
+    message: "Could not find repo or installed OwnLab web runtime."
+  };
+}
+
+// src/commands/doctor.ts
+var STATUS_ICON = {
+  pass: "PASS",
+  warn: "WARN",
+  fail: "FAIL"
+};
+function printResult(result) {
+  process.stdout.write(`${STATUS_ICON[result.status]} ${result.name}: ${result.message}
+`);
+}
+async function doctor(opts) {
+  const configPath = resolveConfigPath(opts.config ?? resolveDefaultConfigPath(opts.instance));
+  loadOwnlabEnvFile(configPath);
+  const cliPackageRoot = findCliPackageRoot(import.meta.url);
+  const repoRoot = findRepoRoot(cliPackageRoot);
+  const serverPackageRoot = repoRoot ? null : findInstalledServerPackageRoot(import.meta.url);
+  const webPackageRoot = repoRoot ? null : findInstalledWebPackageRoot(import.meta.url);
+  const results = [];
+  const cfg = configCheck(opts.config);
+  results.push(cfg);
+  printResult(cfg);
+  if (cfg.status === "fail") {
+    return summarize(results);
+  }
+  const env = envCheck(opts.config);
+  results.push(env);
+  printResult(env);
+  const node = nodeCheck();
+  results.push(node);
+  printResult(node);
+  const server = await serverCheck({ serverPackageRoot, repoRoot });
+  results.push(server);
+  printResult(server);
+  const web = webCheck({ webPackageRoot, repoRoot });
+  results.push(web);
+  printResult(web);
+  const config = readConfig(opts.config);
+  if (!config) {
+    return summarize(results);
+  }
+  for (const result of filesystemCheck(config)) {
+    results.push(result);
+    printResult(result);
+  }
+  for (const result of await portChecks(config)) {
+    results.push(result);
+    printResult(result);
+  }
+  return summarize(results);
+}
+function summarize(results) {
+  const passed = results.filter((result) => result.status === "pass").length;
+  const warned = results.filter((result) => result.status === "warn").length;
+  const failed = results.filter((result) => result.status === "fail").length;
+  process.stdout.write(`Summary: ${passed} passed, ${warned} warnings, ${failed} failed
+`);
+  return { passed, warned, failed };
+}
+
+// src/commands/health.ts
+async function runHealth(opts) {
+  const base = opts.url.replace(/\/$/, "");
+  const healthUrl = `${base}/health`;
+  const res = await fetch(healthUrl, {
+    signal: AbortSignal.timeout(8e3)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    process.stderr.write(
+      `OwnLab API at ${healthUrl} returned ${res.status}: ${text.slice(0, 500)}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`OK \u2014 ${healthUrl} (${res.status})
+`);
+  if (text.trim()) {
+    process.stdout.write(`${text.trim()}
+`);
+  }
+}
+
+// src/commands/onboard.ts
+import fs6 from "node:fs";
+function toPort(value, fallback) {
+  if (value === void 0) return fallback;
+  const port = Number(value);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`Invalid port: ${value}`);
+  }
+  return port;
+}
+async function onboard(opts) {
+  const instanceId = resolveOwnlabInstanceId(opts.instance);
+  const paths = describeLocalInstancePaths(instanceId);
+  const serverPort = toPort(opts.serverPort, 3100);
+  const webPort = toPort(opts.webPort, 3e3);
+  const ownlabHome = resolveOwnlabHomeDir();
+  const configPath = opts.config ?? paths.configPath;
+  fs6.mkdirSync(paths.instanceRoot, { recursive: true });
+  fs6.mkdirSync(paths.logDir, { recursive: true });
+  fs6.mkdirSync(paths.backupDir, { recursive: true });
+  fs6.mkdirSync(paths.cacheDir, { recursive: true });
+  process.env.OWNLAB_HOME = ownlabHome;
+  process.env.OWNLAB_INSTANCE_ID = instanceId;
+  const config = {
+    version: 1,
+    server: {
+      host: "127.0.0.1",
+      port: serverPort
+    },
+    web: {
+      host: "127.0.0.1",
+      port: webPort,
+      mode: "local-next"
+    },
+    database: {
+      mode: process.env.DATABASE_URL?.trim() ? "postgres" : "embedded-postgres",
+      ...process.env.DATABASE_URL?.trim() ? { connectionString: process.env.DATABASE_URL.trim() } : {},
+      embeddedPostgresDataDir: paths.dbDir,
+      embeddedPostgresPort: Number(process.env.OWNLAB_EMBEDDED_PG_PORT) || 54329
+    },
+    runtime: {
+      ownlabHome,
+      instanceId,
+      logDir: paths.logDir,
+      backupDir: paths.backupDir,
+      cacheDir: paths.cacheDir
+    }
+  };
+  writeConfig(config, configPath);
+  const envPath = resolveOwnlabEnvFile(configPath);
+  mergeOwnlabEnvEntries(
+    {
+      OWNLAB_HOME: ownlabHome,
+      OWNLAB_INSTANCE_ID: instanceId,
+      OWNLAB_SERVER_PORT: String(serverPort),
+      OWNLAB_SERVER_URL: `http://127.0.0.1:${serverPort}`,
+      NEXT_PUBLIC_OWNLAB_SERVER_URL: `http://127.0.0.1:${serverPort}`,
+      OWNLAB_WEB_PORT: String(webPort),
+      PORT: String(serverPort),
+      HOST: "127.0.0.1",
+      OWNLAB_EMBEDDED_PG_PORT: String(config.database.embeddedPostgresPort)
+    },
+    envPath
+  );
+  process.stdout.write(
+    [
+      "OwnLab onboarding complete.",
+      `Instance: ${instanceId}`,
+      `Config: ${configPath}`,
+      `Env: ${envPath}`,
+      `Next: pnpm ownlab run --instance ${instanceId}`,
+      ""
+    ].join("\n")
+  );
+}
+
+// src/commands/run.ts
+import { spawn } from "node:child_process";
+import path6 from "node:path";
+import { pathToFileURL } from "node:url";
+function waitForUrl(url, timeoutMs = 3e4) {
+  const startedAt = Date.now();
+  return new Promise((resolve, reject) => {
+    const tick = async () => {
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+        if (response.ok || response.status < 500) {
+          resolve();
+          return;
+        }
+      } catch {
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        reject(new Error(`Timed out waiting for ${url}`));
+        return;
+      }
+      setTimeout(tick, 500);
+    };
+    void tick();
+  });
+}
+async function importServerEntry(repoRoot) {
+  if (repoRoot) {
+    const localEntry = path6.resolve(repoRoot, "apps/server/src/index.ts");
+    return await import(pathToFileURL(localEntry).href);
+  }
+  return await import("@ownlabai/server");
+}
+function spawnWeb(webPackageRoot, repoRoot, env, port) {
+  if (hasInstalledWebPackage(webPackageRoot)) {
+    const nextBinPath = getInstalledWebNextBinPath(webPackageRoot);
+    return spawn("node", [nextBinPath, "start", "--hostname", "127.0.0.1", "--port", String(port)], {
+      cwd: webPackageRoot,
+      env: {
+        ...env,
+        BASELINE_BROWSER_MAPPING_IGNORE_OLD_DATA: "1"
+      },
+      stdio: "inherit"
+    });
+  }
+  if (!repoRoot) {
+    throw new Error("Could not find packaged or repo OwnLab web runtime.");
+  }
+  return spawn(
+    "pnpm",
+    [
+      "--filter",
+      "@ownlabai/web",
+      "exec",
+      "next",
+      "dev",
+      "--hostname",
+      "127.0.0.1",
+      "--port",
+      String(port)
+    ],
+    {
+      cwd: repoRoot,
+      env: {
+        ...env,
+        BASELINE_BROWSER_MAPPING_IGNORE_OLD_DATA: "1"
+      },
+      stdio: "inherit"
+    }
+  );
+}
+async function runCommand(opts) {
+  if (opts.instance) {
+    process.env.OWNLAB_INSTANCE_ID = opts.instance;
+  }
+  const configPath = resolveConfigPath(opts.config);
+  process.env.OWNLAB_CONFIG = configPath;
+  if (!configExists(configPath)) {
+    await onboard({
+      config: configPath,
+      instance: opts.instance,
+      yes: true
+    });
+  }
+  loadOwnlabEnvFile(configPath);
+  const summary = await doctor({ config: configPath });
+  if (summary.failed > 0) {
+    throw new Error("Doctor reported blocking issues.");
+  }
+  const config = readConfig(configPath);
+  if (!config) {
+    throw new Error(`No config found at ${configPath}`);
+  }
+  const env = {
+    ...process.env,
+    OWNLAB_HOME: config.runtime.ownlabHome,
+    OWNLAB_INSTANCE_ID: config.runtime.instanceId,
+    OWNLAB_SERVER_URL: `http://${config.server.host}:${config.server.port}`,
+    NEXT_PUBLIC_OWNLAB_SERVER_URL: `http://${config.server.host}:${config.server.port}`,
+    PORT: String(config.server.port),
+    HOST: config.server.host,
+    OWNLAB_EMBEDDED_PG_PORT: String(config.database.embeddedPostgresPort),
+    ...config.database.connectionString ? { DATABASE_URL: config.database.connectionString } : {}
+  };
+  Object.assign(process.env, env);
+  const cliPackageRoot = findCliPackageRoot(import.meta.url);
+  const repoRoot = findRepoRoot(cliPackageRoot);
+  const serverPackageRoot = repoRoot ? null : findInstalledServerPackageRoot(import.meta.url);
+  const webPackageRoot = repoRoot ? null : findInstalledWebPackageRoot(import.meta.url);
+  const serverModule = await importServerEntry(repoRoot);
+  const startedServer = await serverModule.startServer({
+    host: config.server.host,
+    port: config.server.port
+  });
+  let webProcess = null;
+  let stopping = false;
+  const stopAll = async () => {
+    if (stopping) return;
+    stopping = true;
+    if (webProcess?.pid) {
+      webProcess.kill("SIGTERM");
+    }
+    await startedServer.stop();
+  };
+  process.on("SIGINT", () => {
+    void stopAll().finally(() => process.exit(0));
+  });
+  process.on("SIGTERM", () => {
+    void stopAll().finally(() => process.exit(0));
+  });
+  process.stdout.write(`OwnLab API: ${startedServer.apiUrl}
+`);
+  if (opts.noWeb) {
+    process.stdout.write("Web startup skipped (--no-web).\n");
+    return;
+  }
+  webProcess = spawnWeb(webPackageRoot, repoRoot, env, config.web.port);
+  webProcess.on("exit", (code) => {
+    if (!stopping) {
+      process.stderr.write(`OwnLab web exited with code ${code ?? 0}
+`);
+      void stopAll().finally(() => process.exit(code ?? 1));
+    }
+  });
+  const webUrl = `http://${config.web.host}:${config.web.port}`;
+  await waitForUrl(webUrl).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  });
+  process.stdout.write(`OwnLab Web: ${webUrl}
+`);
+  process.stdout.write("Press Ctrl+C to stop OwnLab.\n");
+}
+
+// src/index.ts
+var __dirname = dirname(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
+var program = new Command();
+program.name("ownlab").description("OwnLab CLI \u2014 operate and diagnose your local lab").version(pkg.version);
+program.command("health").description("Check that the OwnLab API server responds (GET /health)").option(
+  "-u, --url <baseUrl>",
+  "API base URL",
+  process.env.OWNLAB_API_URL ?? "http://localhost:3100"
+).action(async (opts) => {
+  await runHealth({ url: opts.url });
+});
+program.command("info").description("Print a short product hint (uses shared constants)").action(() => {
+  const sample = Object.entries(ADAPTER_TYPE_LABELS).slice(0, 3);
+  process.stdout.write(
+    `Adapter labels (sample): ${sample.map(([k, v]) => `${k}=${v}`).join(", ")}
+`
+  );
+});
+program.command("onboard").description("Create a local OwnLab instance config and default directories").option("-c, --config <path>", "Path to config file").option("-i, --instance <id>", "OwnLab instance id", "default").option("-y, --yes", "Accept defaults without prompts", false).option("--server-port <port>", "Server port", "3100").option("--web-port <port>", "Web port", "3000").action(async (opts) => {
+  await onboard(opts);
+});
+program.command("doctor").description("Run local OwnLab runtime checks").option("-c, --config <path>", "Path to config file").option("-i, --instance <id>", "OwnLab instance id", "default").action(async (opts) => {
+  const summary = await doctor(opts);
+  if (summary.failed > 0) {
+    process.exitCode = 1;
+  }
+});
+program.command("run").description("Ensure onboarding is complete and start the local OwnLab runtime").option("-c, --config <path>", "Path to config file").option("-i, --instance <id>", "OwnLab instance id", "default").option("--no-web", "Start only the server runtime").action(async (opts) => {
+  await runCommand({
+    config: opts.config,
+    instance: opts.instance,
+    noWeb: opts.web === false
+  });
+});
+program.parseAsync().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map