everything-dev 0.3.3 → 1.3.3

package/src/process-registry.ts

@@ -0,0 +1,154 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Effect, Ref } from "effect";
+import { getBosDir } from "./dev-logs";
+
+export interface TrackedProcess {
+  pid: number;
+  name: string;
+  port: number;
+  startedAt: number;
+  command: string;
+}
+
+export interface ProcessRegistry {
+  readonly tracked: Ref.Ref<Map<number, TrackedProcess>>;
+  track: (proc: TrackedProcess) => Effect.Effect<void>;
+  untrack: (pid: number) => Effect.Effect<void>;
+  getAll: () => Effect.Effect<TrackedProcess[]>;
+  killAll: (force?: boolean) => Effect.Effect<{ killed: number[]; failed: number[] }>;
+  persist: () => Effect.Effect<void>;
+  restore: () => Effect.Effect<void>;
+}
+
+export function getPidFilePath(configDir: string): string {
+  return join(getBosDir(configDir), "pids.json");
+}
+
+const isProcessAlive = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const killProcess = (pid: number, signal: NodeJS.Signals): boolean => {
+  try {
+    // Try process group first (covers spawned child trees)
+    try {
+      process.kill(-pid, signal);
+    } catch {}
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const makeProcessRegistry = (configDir: string) =>
+  Effect.gen(function* () {
+    const tracked = yield* Ref.make(new Map<number, TrackedProcess>());
+    const pidFile = getPidFilePath(configDir);
+
+    const getAll: ProcessRegistry["getAll"] = () =>
+      Ref.get(tracked).pipe(Effect.map((m) => Array.from(m.values())));
+
+    const persist: ProcessRegistry["persist"] = () =>
+      Effect.gen(function* () {
+        const procs = yield* getAll();
+        const dir = dirname(pidFile);
+        yield* Effect.tryPromise({
+          try: async () => {
+            if (!existsSync(dir)) {
+              await mkdir(dir, { recursive: true });
+            }
+            await writeFile(pidFile, JSON.stringify(procs, null, 2));
+          },
+          catch: () => new Error("Failed to persist PIDs"),
+        }).pipe(Effect.catchAll(() => Effect.void));
+      });
+
+    const track: ProcessRegistry["track"] = (proc) =>
+      Effect.gen(function* () {
+        yield* Ref.update(tracked, (m) => new Map(m).set(proc.pid, proc));
+        yield* persist();
+      });
+
+    const untrack: ProcessRegistry["untrack"] = (pid) =>
+      Effect.gen(function* () {
+        yield* Ref.update(tracked, (m) => {
+          const copy = new Map(m);
+          copy.delete(pid);
+          return copy;
+        });
+        yield* persist();
+      });
+
+    const restore: ProcessRegistry["restore"] = () =>
+      Effect.gen(function* () {
+        if (!existsSync(pidFile)) return;
+
+        const content = yield* Effect.tryPromise({
+          try: () => readFile(pidFile, "utf8"),
+          catch: () => new Error("Failed to read PID file"),
+        }).pipe(Effect.catchAll(() => Effect.succeed("")));
+
+        if (!content) return;
+
+        let procs: TrackedProcess[];
+        try {
+          procs = JSON.parse(content) as TrackedProcess[];
+        } catch {
+          return;
+        }
+
+        const alive = procs.filter((p) => isProcessAlive(p.pid));
+        yield* Ref.set(tracked, new Map(alive.map((p) => [p.pid, p])));
+      });
+
+    yield* restore();
+
+    const killAll: ProcessRegistry["killAll"] = (force = false) =>
+      Effect.gen(function* () {
+        const procs = yield* getAll();
+        const killed: number[] = [];
+        const failed: number[] = [];
+
+        for (const proc of procs) {
+          if (!isProcessAlive(proc.pid)) {
+            yield* untrack(proc.pid);
+            continue;
+          }
+
+          const signal = force ? "SIGKILL" : "SIGTERM";
+          if (killProcess(proc.pid, signal)) {
+            killed.push(proc.pid);
+            yield* untrack(proc.pid);
+          } else {
+            failed.push(proc.pid);
+          }
+        }
+
+        if (!force && failed.length > 0) {
+          yield* Effect.sleep("500 millis");
+          for (const pid of [...failed]) {
+            if (killProcess(pid, "SIGKILL")) {
+              const idx = failed.indexOf(pid);
+              if (idx !== -1) {
+                failed.splice(idx, 1);
+                killed.push(pid);
+              }
+              yield* untrack(pid);
+            }
+          }
+        }
+
+        yield* persist();
+        return { killed, failed };
+      });
+
+    return { tracked, track, untrack, getAll, killAll, persist, restore };
+  });

package/src/scripts/sync-api-contract.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { dirname } from "node:path";
+import { syncApiContractBridge } from "../api-contract";
+import { loadConfig } from "../config";
+
+async function main() {
+  const result = await loadConfig({ cwd: process.cwd(), env: "development" });
+  if (!result) {
+    throw new Error("No bos.config.json found");
+  }
+
+  const configDir = dirname(result.source.path);
+  await syncApiContractBridge({
+    configDir,
+    runtimeConfig: result.runtime,
+    apiBaseUrl: result.runtime.api.url,
+  });
+}
+
+main().catch((error) => {
+  console.error("[sync-api-contract]", error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/src/sdk.ts

@@ -0,0 +1,14 @@
+export {
+  createPlugin,
+  createPluginRuntime,
+  type LoadedPluginWithBinding,
+  type Plugin,
+  PluginRuntime,
+} from "every-plugin";
+export { Context, Effect, Layer, Scope } from "every-plugin/effect";
+export {
+  type AnyContractRouter,
+  type AnySchema,
+  oc,
+} from "every-plugin/orpc";
+export { z } from "every-plugin/zod";

package/src/shared.ts

@@ -0,0 +1,206 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { BosConfig, SharedDepConfig } from "./types";
+
+export interface SharedUiResolvedDep {
+  name: string;
+  version: string;
+  requiredVersion: string;
+  shareScope: string;
+  singleton: boolean;
+  eager: boolean;
+  strictVersion: boolean;
+}
+
+export interface SharedUiResolved {
+  deps: Record<string, SharedUiResolvedDep>;
+  fingerprintSha256: string;
+}
+
+export interface SharedSyncResult {
+  mode: "catalog->bos" | "bos->catalog";
+  hostMode: "local" | "remote";
+  bosConfigChanged: boolean;
+  catalogChanged: boolean;
+  generatedChanged: boolean;
+  resolved: SharedUiResolved;
+}
+
+function sha256(input: string): string {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+function extractSemverExact(input: unknown): string | null {
+  if (typeof input !== "string") return null;
+  const match = input.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match ? match[0] : null;
+}
+
+function caretRange(version: string): string {
+  return `^${version}`;
+}
+
+function stableDepsObject(
+  deps: Record<string, SharedUiResolvedDep>,
+): Record<string, SharedUiResolvedDep> {
+  const keys = Object.keys(deps).sort((a, b) => a.localeCompare(b));
+  const out: Record<string, SharedUiResolvedDep> = {};
+  for (const k of keys) out[k] = deps[k]!;
+  return out;
+}
+
+function writeFileIfChanged(filePath: string, nextContent: string): boolean {
+  try {
+    const current = readFileSync(filePath, "utf-8");
+    if (current === nextContent) return false;
+  } catch {
+    // ignore
+  }
+
+  writeFileSync(filePath, nextContent);
+  return true;
+}
+
+function fingerprintResolved(deps: Record<string, SharedUiResolvedDep>): string {
+  const stable = stableDepsObject(deps);
+  return sha256(JSON.stringify(stable));
+}
+
+function getSharedUiDeps(bosConfig: BosConfig): Record<string, SharedDepConfig> {
+  const shared = bosConfig.shared ?? {};
+  const ui = shared.ui ?? {};
+  return ui;
+}
+
+export async function syncAndGenerateSharedUi(opts: {
+  configDir: string;
+  hostMode: "local" | "remote";
+  bosConfig?: BosConfig;
+}): Promise<SharedSyncResult> {
+  const bosConfigPath = join(opts.configDir, "bos.config.json");
+  const packageJsonPath = join(opts.configDir, "package.json");
+  const generatedPath = join(opts.configDir, ".bos", "generated", "shared-ui.json");
+
+  const bosConfig: BosConfig = opts.bosConfig ?? JSON.parse(readFileSync(bosConfigPath, "utf-8"));
+  let pkgJson: any = {};
+  try {
+    pkgJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  } catch {
+    // package.json might not exist
+  }
+
+  const originalBos = JSON.stringify(bosConfig);
+  const originalPkg = JSON.stringify(pkgJson);
+
+  const catalog = pkgJson?.workspaces?.catalog ?? {};
+  const sharedUi = getSharedUiDeps(bosConfig);
+
+  const mode = opts.hostMode === "local" ? "catalog->bos" : "bos->catalog";
+
+  if (mode === "catalog->bos") {
+    for (const [name, cfg] of Object.entries(sharedUi)) {
+      const dep = cfg as SharedDepConfig;
+      const version =
+        catalog[name] ?? extractSemverExact(dep.version) ?? extractSemverExact(dep.requiredVersion);
+      if (!version) continue;
+      dep.version = version;
+      dep.requiredVersion = caretRange(version);
+      dep.shareScope = dep.shareScope ?? "default";
+    }
+  } else {
+    for (const [name, cfg] of Object.entries(sharedUi)) {
+      const dep = cfg as SharedDepConfig;
+      const version = extractSemverExact(dep.version) ?? extractSemverExact(dep.requiredVersion);
+      if (!version) continue;
+      dep.version = version;
+      dep.requiredVersion = caretRange(version);
+      dep.shareScope = dep.shareScope ?? "default";
+      if (catalog[name] !== version) {
+        catalog[name] = version;
+      }
+    }
+    if (!pkgJson.workspaces) pkgJson.workspaces = { packages: [], catalog: {} };
+    pkgJson.workspaces.catalog = catalog;
+  }
+
+  const nextBos = JSON.stringify(bosConfig);
+  const nextPkg = JSON.stringify(pkgJson);
+  const bosConfigChanged = nextBos !== originalBos;
+  const catalogChanged = nextPkg !== originalPkg;
+
+  if (bosConfigChanged) {
+    writeFileIfChanged(bosConfigPath, `${JSON.stringify(bosConfig, null, 2)}\n`);
+  }
+  if (catalogChanged) {
+    writeFileIfChanged(packageJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`);
+  }
+
+  const resolvedDeps: Record<string, SharedUiResolvedDep> = {};
+  for (const [name, cfg] of Object.entries(getSharedUiDeps(bosConfig))) {
+    const version =
+      catalog[name] ?? extractSemverExact(cfg.version) ?? extractSemverExact(cfg.requiredVersion);
+    if (!version) continue;
+    resolvedDeps[name] = {
+      name,
+      version,
+      requiredVersion: caretRange(version),
+      shareScope: cfg.shareScope ?? "default",
+      singleton: cfg.singleton ?? false,
+      eager: cfg.eager ?? false,
+      strictVersion: cfg.strictVersion ?? false,
+    };
+  }
+
+  const stableResolvedDeps = stableDepsObject(resolvedDeps);
+  const resolved: SharedUiResolved = {
+    deps: stableResolvedDeps,
+    fingerprintSha256: fingerprintResolved(stableResolvedDeps),
+  };
+
+  const nextGenerated = {
+    schemaVersion: 1,
+    kind: "everything-dev/shared-ui",
+    generatedAt: new Date().toISOString(),
+    ui: {
+      deps: stableResolvedDeps,
+      fingerprintSha256: resolved.fingerprintSha256,
+    },
+    inputs: {
+      mode,
+      hostMode: opts.hostMode,
+    },
+  };
+
+  let prevFingerprint: string | null = null;
+  try {
+    const prev = JSON.parse(readFileSync(generatedPath, "utf-8"));
+    prevFingerprint = prev?.ui?.fingerprintSha256 ?? null;
+  } catch {
+    // ignore
+  }
+
+  mkdirSync(dirname(generatedPath), { recursive: true });
+  writeFileIfChanged(generatedPath, `${JSON.stringify(nextGenerated, null, 2)}\n`);
+
+  const generatedChanged = prevFingerprint !== nextGenerated.ui.fingerprintSha256;
+
+  return {
+    mode,
+    hostMode: opts.hostMode,
+    bosConfigChanged,
+    catalogChanged,
+    generatedChanged,
+    resolved,
+  };
+}
+
+export function loadGeneratedSharedUi(configDir: string): SharedUiResolved | null {
+  const generatedPath = join(configDir, ".bos", "generated", "shared-ui.json");
+  try {
+    const content = JSON.parse(readFileSync(generatedPath, "utf-8"));
+    return content?.ui ?? null;
+  } catch {
+    return null;
+  }
+}