@ovrdev/cli 0.1.0-alpha.16

package/dist/index-3kvnzs8b.js

@@ -0,0 +1,340 @@
+// src/plugins/shell.ts
+import { spawn } from "node:child_process";
+
+// src/util/ready.ts
+import { connect } from "node:net";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitUntil(probe, opts = {}) {
+  const timeout = opts.timeoutMs ?? 60000;
+  const interval = opts.intervalMs ?? 500;
+  const deadline = Date.now() + timeout;
+  for (;; ) {
+    try {
+      if (await probe())
+        return;
+    } catch {}
+    if (Date.now() >= deadline) {
+      throw new Error(`readiness timed out after ${timeout}ms${opts.label ? `: ${opts.label}` : ""}`);
+    }
+    await sleep(interval);
+  }
+}
+function waitHttp(url, opts = {}) {
+  return waitUntil(async () => {
+    const res = await fetch(url, { redirect: "manual" }).catch(() => null);
+    if (!res)
+      return false;
+    return opts.status ? res.status === opts.status : res.status < 500;
+  }, { label: `GET ${url}`, ...opts });
+}
+function waitTcp(port, opts = {}) {
+  const host = opts.host ?? "127.0.0.1";
+  return waitUntil(() => new Promise((resolve) => {
+    const sock = connect({ host, port });
+    const done = (ok) => {
+      sock.destroy();
+      resolve(ok);
+    };
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+    sock.setTimeout(2000, () => done(false));
+  }), { label: `tcp ${host}:${port}`, ...opts });
+}
+// src/util/random.ts
+import { randomBytes } from "node:crypto";
+var ALNUM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var SYMBOLS = "!#$%*+-_=?@.";
+function randomString(length = 24, alphabet = ALNUM) {
+  if (length <= 0 || alphabet.length === 0)
+    return "";
+  const max = Math.floor(256 / alphabet.length) * alphabet.length;
+  let out = "";
+  while (out.length < length) {
+    for (const byte of randomBytes(length * 2)) {
+      if (byte >= max)
+        continue;
+      out += alphabet[byte % alphabet.length];
+      if (out.length === length)
+        break;
+    }
+  }
+  return out;
+}
+function randomPassword(length = 24, opts = {}) {
+  return randomString(length, opts.symbols === false ? ALNUM : ALNUM + SYMBOLS);
+}
+function randomHex(bytes = 24) {
+  return randomBytes(bytes).toString("hex");
+}
+
+// src/core/core.ts
+var REF = Symbol.for("ovr.ref");
+var isRef = (v) => typeof v === "object" && v !== null && (REF in v);
+var refTarget = (r) => r[REF];
+var makeRef = (repo, service, key) => ({ [REF]: { repo, service, key } });
+function collectRefTargets(spec, out = []) {
+  if (isRef(spec)) {
+    out.push(refTarget(spec));
+    return out;
+  }
+  if (Array.isArray(spec)) {
+    for (const v of spec)
+      collectRefTargets(v, out);
+    return out;
+  }
+  if (spec && typeof spec === "object") {
+    for (const v of Object.values(spec))
+      collectRefTargets(v, out);
+  }
+  return out;
+}
+function resolveRefs(spec, resolve) {
+  if (isRef(spec))
+    return resolve(refTarget(spec));
+  if (Array.isArray(spec))
+    return spec.map((v) => resolveRefs(v, resolve));
+  if (spec && typeof spec === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(spec)) {
+      if (isRef(v)) {
+        const r = resolve(refTarget(v));
+        if (r !== undefined)
+          out[k] = r;
+      } else {
+        out[k] = resolveRefs(v, resolve);
+      }
+    }
+    return out;
+  }
+  return spec;
+}
+var sym = (p) => typeof p === "symbol";
+function buildWorkspace(name, ownRepo, leaf) {
+  const services = (repo) => new Proxy({}, { get: (_t, s) => sym(s) ? undefined : new Proxy({}, { get: (_t2, k) => sym(k) ? undefined : leaf(repo, s, k) }) });
+  const repos = new Proxy({}, { get: (_t, r) => sym(r) ? undefined : { services: services(r) } });
+  return { name, services: services(ownRepo), repos };
+}
+function makeContext(workspaceName, repo) {
+  return {
+    workspace: buildWorkspace(workspaceName, repo, (r, s, k) => makeRef(r, s, k)),
+    kind: buildKinds([])
+  };
+}
+function resolvingWorkspace(name, ownRepo, resolve) {
+  return buildWorkspace(name, ownRepo, (repo, service, key) => resolve({ repo, service, key }));
+}
+function recordingWorkspace(name, ownRepo) {
+  const rec = [];
+  const workspace = buildWorkspace(name, ownRepo, (repo, service, key) => {
+    rec.push({ repo, service, key });
+    return "";
+  });
+  return { workspace, taken: () => rec };
+}
+var input = {
+  text: (label, opts = {}) => ({
+    kind: "text",
+    label,
+    ...opts
+  }),
+  choice: (label, options, opts = {}) => ({
+    kind: "choice",
+    label,
+    options,
+    ...opts
+  }),
+  confirm: (label, opts = {}) => ({ kind: "confirm", label, ...opts })
+};
+var ask = {
+  choice: (question, options, opts = {}) => ({
+    kind: "choice",
+    question,
+    options,
+    ...opts
+  }),
+  confirm: (question, opts = {}) => ({
+    kind: "confirm",
+    question,
+    ...opts
+  })
+};
+function applyAskDefaults(asks, answers, repo) {
+  const out = { ...answers };
+  for (const [key, spec] of Object.entries(asks)) {
+    if (out[key] !== undefined)
+      continue;
+    if (spec.default !== undefined) {
+      out[key] = spec.default;
+      continue;
+    }
+    const hint = spec.kind === "choice" ? spec.options.join("|") : "true|false";
+    throw new Error(`${repo}: '${key}' needs an answer — pass --answer ${key}=<${hint}> (or run interactively)`);
+  }
+  return out;
+}
+var FACTORY = Symbol.for("ovr.factory");
+var HEAD = Symbol.for("ovr.head");
+var configAsks = (mod) => isConfigModule(mod) ? mod[HEAD]?.asks ?? {} : {};
+function buildKinds(plugins) {
+  const kind = { shell };
+  for (const p of plugins)
+    if (p.kinds)
+      kind[p.name] = p.kinds;
+  return kind;
+}
+function defineConfig(a, b) {
+  if (b) {
+    const head = a;
+    const asks = { ...head.asks ?? {} };
+    if (head.modes?.length) {
+      asks.mode = {
+        kind: "choice",
+        question: "How should services run?",
+        options: head.modes,
+        ...head.defaultMode !== undefined ? { default: head.defaultMode } : {}
+      };
+    }
+    return {
+      [HEAD]: { asks },
+      [FACTORY]: ({ workspace, repo, dir, answers }) => {
+        const plugins = typeof head.plugins === "function" ? head.plugins({ workspace: { name: workspace }, repo, dir }) : head.plugins ?? [];
+        const resolved = applyAskDefaults(asks, answers ?? {}, repo);
+        const { workspace: proj } = makeContext(workspace, repo);
+        const body = b({
+          workspace: proj,
+          kind: buildKinds(plugins),
+          mode: resolved.mode ?? "default",
+          answers: resolved
+        });
+        return { ...body, plugins: [...plugins] };
+      }
+    };
+  }
+  const input2 = a;
+  const factory = typeof input2 === "function" ? input2 : () => input2;
+  return { [FACTORY]: ({ workspace, repo }) => factory(makeContext(workspace, repo)) };
+}
+var isConfigModule = (v) => typeof v === "object" && v !== null && (FACTORY in v);
+function evalConfig(mod, workspace, repo, dir = "", answers) {
+  if (isConfigModule(mod))
+    return mod[FACTORY]({ workspace, repo, dir, answers });
+  const isPlain = mod && typeof mod === "object" && (("services" in mod) || ("setup" in mod));
+  const factory = typeof mod === "function" ? mod : isPlain ? () => ({ services: {}, ...mod }) : null;
+  if (!factory)
+    throw new Error("config default export must be defineConfig(...) or { services: … }");
+  return factory(makeContext(workspace, repo));
+}
+async function serviceRefs(def, tools) {
+  return def.plugin.refs ? await def.plugin.refs(def.spec, tools) : collectRefTargets(def.spec);
+}
+
+// src/engine/localbin.ts
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+var LOCAL_BIN_DIRS = [["node_modules", ".bin"]];
+function withLocalBins(dir, env) {
+  const bins = LOCAL_BIN_DIRS.map((p) => join(dir, ...p)).filter(existsSync);
+  if (!bins.length)
+    return env;
+  return { ...env, PATH: [...bins, env.PATH ?? ""].join(delimiter) };
+}
+
+// src/plugins/shell.ts
+var placeholderBag = () => new Proxy(() => {
+  return;
+}, {
+  get: (_t, p) => p === Symbol.toPrimitive ? () => "" : placeholderBag(),
+  apply: () => placeholderBag()
+});
+function spawnArgs(cmd) {
+  if (Array.isArray(cmd))
+    return { command: cmd[0], args: cmd.slice(1), shell: false };
+  return { command: cmd, args: [], shell: true };
+}
+var shellPlugin = {
+  name: "shell",
+  refs(spec) {
+    const env = typeof spec.env === "function" ? spec.env(placeholderBag()) : spec.env ?? {};
+    return collectRefTargets(env);
+  },
+  async plan(spec, ctx) {
+    const bag = spec.prepare ? await spec.prepare({
+      workspace: ctx.workspace,
+      scope: ctx.scope,
+      ports: { alloc: ctx.allocPort },
+      secrets: { get: ctx.secret },
+      ...ctx.caps
+    }) : undefined;
+    const exp = spec.exports?.(bag) ?? {};
+    const clean = {};
+    for (const [k, v] of Object.entries(exp)) {
+      const s = String(v);
+      if (!s.includes(ctx.pending))
+        clean[k] = s;
+    }
+    return clean;
+  },
+  async start(spec, ctx) {
+    const bag = ctx.bag;
+    const cmd = typeof spec.command === "function" ? spec.command(bag) : spec.command;
+    const { command, args, shell: useShell } = spawnArgs(cmd);
+    const rawEnv = typeof spec.env === "function" ? spec.env(bag) : spec.env ?? {};
+    const ownEnv = resolveRefs(rawEnv, ctx.resolve);
+    const env = withLocalBins(ctx.scope.dir, { ...ctx.env, ...ownEnv });
+    const child = spawn(command, args, {
+      cwd: ctx.scope.dir,
+      env,
+      shell: useShell,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    ctx.pipe(child.stdout);
+    ctx.pipe(child.stderr);
+    let killTimer = null;
+    const killGroup = (sig) => {
+      try {
+        if (child.pid)
+          process.kill(-child.pid, sig);
+      } catch {
+        try {
+          child.kill(sig);
+        } catch {}
+      }
+    };
+    const onProcExit = () => killGroup("SIGKILL");
+    process.once("exit", onProcExit);
+    child.on("exit", () => {
+      process.removeListener("exit", onProcExit);
+      if (killTimer)
+        clearTimeout(killTimer);
+    });
+    const exports = spec.exports?.(bag) ?? {};
+    ctx.log(`▶ ${Array.isArray(cmd) ? cmd.join(" ") : cmd}${exports.url ? `  (${exports.url})` : ""}`);
+    const exited = new Promise((resolve) => child.on("exit", () => resolve()));
+    const ready = (spec.ready ? spec.ready(bag) : Promise.resolve()).then(() => spec.onReady?.(bag));
+    const actions = [
+      {
+        id: "shell",
+        label: "shell here (service env)",
+        command: process.env.SHELL || "/bin/sh",
+        cwd: ctx.scope.dir,
+        env
+      }
+    ];
+    return {
+      exports,
+      info: exports.url ?? (exports.port ? `:${exports.port}` : undefined),
+      actions,
+      ready,
+      exited,
+      stop: () => {
+        killGroup("SIGTERM");
+        killTimer = setTimeout(() => killGroup("SIGKILL"), 3000);
+        killTimer.unref?.();
+      }
+    };
+  }
+};
+var shell = (spec) => ({ plugin: shellPlugin, spec });
+
+export { withLocalBins, shellPlugin, shell, waitUntil, waitHttp, waitTcp, randomString, randomPassword, randomHex, isRef, refTarget, collectRefTargets, resolveRefs, makeContext, resolvingWorkspace, recordingWorkspace, input, ask, applyAskDefaults, configAsks, defineConfig, isConfigModule, evalConfig, serviceRefs };