@ovrdev/cli 0.1.0-alpha.16

package/dist/index-x4hj4et6.js

@@ -0,0 +1,393 @@
+// 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;
+}
+function coerceEnv(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === undefined || v === null)
+      continue;
+    out[k] = typeof v === "object" ? JSON.stringify(v) : String(v);
+  }
+  return out;
+}
+var sym = (p) => typeof p === "symbol";
+function buildWorkspace(name, ownRepo, leaf) {
+  const serviceNode = (repo, s) => new Proxy({ [REF]: { repo, service: s, key: "" } }, {
+    get: (t, k) => {
+      if (k === REF)
+        return t[REF];
+      if (k === "announce")
+        return (payload) => ({ to: `${repo}.${s}`, payload });
+      return sym(k) ? undefined : leaf(repo, s, k);
+    }
+  });
+  const services = (repo) => new Proxy({}, { get: (_t, s) => sym(s) ? undefined : serviceNode(repo, s) });
+  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));
+}
+var action = {
+  session: (spec) => ({ mode: "session", ...spec }),
+  fn: (spec) => ({ mode: "function", ...spec }),
+  handover: (spec) => ({ mode: "handover", ...spec })
+};
+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",
+  status(handle) {
+    const pid = handle?.pid;
+    if (!pid)
+      return "down";
+    try {
+      process.kill(pid, 0);
+      return "up";
+    } catch (e) {
+      return e.code === "EPERM" ? "up" : "down";
+    }
+  },
+  stop(handle) {
+    const pid = handle?.pid;
+    if (!pid)
+      return;
+    const sig = (s) => {
+      try {
+        process.kill(-pid, s);
+      } catch {
+        try {
+          process.kill(pid, s);
+        } catch {}
+      }
+    };
+    sig("SIGTERM");
+    const t = setTimeout(() => sig("SIGKILL"), 3000);
+    t.unref?.();
+  },
+  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 },
+      paths: { get: ctx.path },
+      ...ctx.caps
+    }) : undefined;
+    const exp = spec.exports?.(bag) ?? {};
+    const clean = {};
+    for (const [k, v] of Object.entries(exp)) {
+      if (v !== undefined && !JSON.stringify(v).includes(ctx.pending))
+        clean[k] = v;
+    }
+    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 = coerceEnv(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 {}
+      }
+    };
+    child.on("exit", () => {
+      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 != null ? String(exports.url) : exports.port != null ? `:${exports.port}` : undefined,
+      actions,
+      ready,
+      exited,
+      handle: { pid: child.pid ?? 0 },
+      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, coerceEnv, makeContext, resolvingWorkspace, recordingWorkspace, input, ask, applyAskDefaults, configAsks, defineConfig, isConfigModule, evalConfig, action, serviceRefs };

package/dist/plugins/shell.d.ts

@@ -0,0 +1,57 @@
+import { type Announcement, type DiscoveryFn, type EnvMap, type JsonValue, type OvrPlugin, type Plugin, type PrepareCtx, type ReadyFn, type Ref, type ServiceAction, type ServiceDef } from "../core/core.js";
+/** A command: a shell string (`sh -c`, so pipes/globs work) or an argv array (exec'd, no shell). */
+export type Cmd = string | string[];
+export type ShellServiceDef<P = void> = {
+    /** Service-scoped plugins — provided at this service's start, torn down with it. */
+    plugins?: readonly OvrPlugin[];
+    /** Reserve ports/resources before the command runs; its return is the bag passed below. */
+    prepare?: (ctx: never) => P | Promise<P>;
+    /** The command to run — value or a (pure) function of the bag. */
+    command: Cmd | ((bag: P) => Cmd);
+    /**
+     * This service's process env. Static (Refs + literals) or a (pure) function of the bag —
+     * the function form lets you inject prepare-derived values (a provisioned bucket name)
+     * alongside cross-service Refs (`workspace.repos[...].url`).
+     */
+    env?: EnvMap | ((bag: P) => EnvMap);
+    /** Named values this service publishes for others to reference — a function of the bag (any JSON value). */
+    exports?: (bag: P) => Record<string, JsonValue>;
+    /** Run after the service is healthy. */
+    onReady?: (bag: P) => void | Promise<void>;
+    /** Config-declared actions for this service's menu (cwd defaults to the repo dir). */
+    actions?: ServiceAction[];
+    /** Resolves when up (gates dependents); e.g. `({ port }) => waitHttp(...)`. Default: immediate. */
+    ready?: ReadyFn<P>;
+    /** Services that must be UP before this one starts — typed readiness refs (`x.ready`). */
+    waitFor?: readonly Ref[];
+    /** Announce payloads to other services: `({ url }) => [other.services.x.announce({ redirect: url })]`. */
+    announce?: (bag: P) => Announcement[];
+    /** Reconcile the live set of announcements targeting this service (e.g. rewrite an allowlist). */
+    discovery?: DiscoveryFn;
+};
+/**
+ * The `kind.shell` constructor, generic over the config's prepare context (base ctx +
+ * whatever the registered plugins contribute). Bag + service-level plugin types infer
+ * from the call.
+ */
+export interface ShellKind<Ctx> {
+    <Bag = void, const SP extends readonly OvrPlugin[] = readonly []>(spec: {
+        plugins?: SP;
+        prepare?: (ctx: Ctx & import("../core/core.js").ContextOf<SP>) => Bag;
+        command: Cmd | ((bag: NoInfer<Awaited<Bag>>) => Cmd);
+        env?: EnvMap | ((bag: NoInfer<Awaited<Bag>>) => EnvMap);
+        exports?: (bag: NoInfer<Awaited<Bag>>) => Record<string, JsonValue>;
+        onReady?: (bag: NoInfer<Awaited<Bag>>) => void | Promise<void>;
+        actions?: ServiceAction[];
+        ready?: ReadyFn<NoInfer<Awaited<Bag>>>;
+        waitFor?: readonly Ref[];
+        announce?: (bag: NoInfer<Awaited<Bag>>) => Announcement[];
+        discovery?: DiscoveryFn;
+    }): ServiceDef;
+}
+export declare const shellPlugin: Plugin<ShellServiceDef<unknown>>;
+/**
+ * Declare a plain process service. Canonically reached as `kind.shell` in the two-arg
+ * defineConfig (typed with your plugins' capabilities); this export is the plugin-less form.
+ */
+export declare const shell: ShellKind<PrepareCtx>;

package/dist/plugins/shell.js

@@ -0,0 +1,8 @@
+import {
+  shell,
+  shellPlugin
+} from "../index-4m3gj5te.js";
+export {
+  shellPlugin,
+  shell
+};

package/dist/plugins/supabase.d.ts

@@ -0,0 +1,79 @@
+import type { OvrPlugin, Plugin, ServiceAction, ServiceDef } from "../core/core.js";
+export type ConfigPatch = {
+    projectId: string;
+    /** section → key → value ("" = top level). Existing keys rewritten, missing ones inserted. */
+    set?: Record<string, Record<string, string | number | boolean>>;
+    /** Entries merged (deduped) into [auth].additional_redirect_urls; block created if missing. */
+    redirectUrls?: string[];
+    /** Retarget `redirect_uri` localhost ports to this stack's api port (OAuth ignores it). */
+    apiPort?: number;
+};
+/**
+ * Patch a supabase config.toml TEXTUALLY — comments, ordering, and everything ovr doesn't
+ * own survive verbatim (the repo's file stays the source of truth for auth/OAuth/etc.).
+ * Section-aware line rewriting: keys are only touched inside their `[section]`.
+ */
+export declare function patchSupabaseConfig(text: string, patch: ConfigPatch): string;
+/** Starter config for repos without a supabase/config.toml (patched like any other). */
+export declare const DEFAULT_CONFIG = "project_id = \"ovr\"\n\n[api]\nenabled = true\nport = 54321\n\n[db]\nport = 54322\nshadow_port = 54320\nmajor_version = 17\n\n[db.seed]\nenabled = false\n\n[realtime]\nenabled = true\n\n[storage]\nenabled = true\n\n[auth]\nenabled = true\nsite_url = \"http://localhost:3000\"\n\n[studio]\nenabled = false\n\n[inbucket]\nenabled = false\n\n[analytics]\nenabled = false\n";
+/** Map `supabase status -o json` output to ovr exports (sb_* key names only). */
+export declare function statusExports(s: Record<string, string>): Record<string, string>;
+/**
+ * What a migration set needs from the stack. Baselines captured from a full instance
+ * reference storage tables (`storage.objects`) and realtime-owned roles — replay breaks
+ * if those services are disabled (learned the hard way; see module doc).
+ */
+export declare function migrationNeeds(sql: string): {
+    storage: boolean;
+    realtime: boolean;
+};
+/** Toggleable stack members. Core services default ON; UI/observability default OFF. */
+export type StackServices = Partial<Record<"realtime" | "storage" | "studio" | "inbucket" | "analytics", boolean>>;
+export type SupabaseExportsCtx = {
+    /** Raw `supabase status -o json` variables. */
+    status: Record<string, string>;
+    ports: {
+        api: number;
+        db: number;
+    };
+};
+type StackSpec = {
+    services?: StackServices;
+    /**
+     * Pin ports instead of sticky allocation. Pin `api` when OAuth is in play — the
+     * provider's redirect-URI allowlist registers an exact port (e.g. :54321 for Azure).
+     */
+    ports?: {
+        api?: number;
+        db?: number;
+    };
+    /** Extra [auth].additional_redirect_urls entries (deduped into the repo's list). */
+    redirectUrls?: string[];
+    exports?: (ctx: SupabaseExportsCtx) => Record<string, string>;
+    onReady?: () => void | Promise<void>;
+    plugins?: readonly OvrPlugin[];
+    /** Config-declared actions for this service's menu (cwd defaults to the repo dir). */
+    actions?: ServiceAction[];
+    /** Extra readiness beyond `supabase start` (which already blocks until healthy). */
+    ready?: (ctx: SupabaseExportsCtx) => Promise<void>;
+    waitFor?: readonly import("../core/core.js").Ref[];
+};
+export declare const supabasePlugin: Plugin<StackSpec>;
+/** The `kind.supabase.*` constructors. `stack` today; `functions`/`db` are natural later kinds. */
+export interface SupabaseKinds<Ctx> {
+    /** The whole local stack (`supabase start`) from a generated shadow workdir. */
+    stack(opts?: StackSpec & {
+        prepare?: (ctx: Ctx) => unknown;
+    }): ServiceDef;
+}
+declare module "../core/core.js" {
+    interface KindRegistry<Ctx> {
+        supabase: SupabaseKinds<Ctx>;
+    }
+}
+declare const kinds: {
+    stack: (opts?: Record<string, unknown>) => ServiceDef;
+};
+/** Register `kind.supabase.stack` + environment diagnostics (docker daemon, CLI presence). */
+export declare function supabase(): import("../core/core.js").KindsPlugin<"supabase", typeof kinds>;
+export {};