procdeck 0.1.0

package/dist/chunk-SBVZ6G4G.js

@@ -0,0 +1,187 @@
+// src/config.ts
+import { pathToFileURL } from "url";
+import * as path from "path";
+import { Effect, Schema } from "effect";
+var regexSource = Schema.String.pipe(
+  Schema.check(
+    Schema.makeFilter((pattern) => {
+      try {
+        new RegExp(pattern);
+        return void 0;
+      } catch {
+        return "expected a valid regular expression";
+      }
+    })
+  )
+);
+var PreflightSchema = Schema.Struct({
+  /** Shell command; exit 0 lets the proc spawn. */
+  shell: Schema.String.pipe(Schema.check(Schema.isMinLength(1))),
+  /**
+   * Regex that must also match the check's output. For checks that exit 0
+   * either way — `wrangler whoami` reports "not authenticated" with exit 0 —
+   * so the config doesn't need `| grep` pipelines.
+   */
+  expect: Schema.optionalKey(regexSource),
+  /** What the human should do when the check fails. */
+  hint: Schema.optionalKey(Schema.String)
+});
+var AlertSchema = Schema.Struct({
+  pattern: regexSource,
+  /** Badge text. */
+  label: Schema.String.pipe(Schema.check(Schema.isMinLength(1)))
+});
+var ProcSpecSchema = Schema.Struct({
+  /** Stable identifier, also the tab label. */
+  id: Schema.String.pipe(Schema.check(Schema.isMinLength(1))),
+  /** Command line handed to `$SHELL -c`. */
+  shell: Schema.optionalKey(Schema.String),
+  /** argv, executed without a shell. */
+  cmd: Schema.optionalKey(Schema.Array(Schema.String).pipe(Schema.check(Schema.isMinLength(1)))),
+  /** Working directory; defaults to the config file's directory. */
+  cwd: Schema.optionalKey(Schema.String),
+  /** Extra environment on top of the inherited one. */
+  env: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+  /** Spawn on startup. Defaults to true. */
+  autostart: Schema.optionalKey(Schema.Boolean),
+  /** URL this process serves, shown in the UI as a link. */
+  url: Schema.optionalKey(Schema.String),
+  /**
+   * Names of procs that must be ready before this one spawns. Declarative:
+   * readiness is auto-detected, no port numbers in the config.
+   */
+  needs: Schema.optionalKey(Schema.Array(Schema.String)),
+  /**
+   * What "ready" means for dependents: "listening" (default) — the process
+   * tree opened a TCP port; "started" — it merely spawned (for procs that
+   * never listen).
+   */
+  readyWhen: Schema.optionalKey(Schema.Literals(["listening", "started"])),
+  /** Check that must pass before this proc spawns; failure shows as "blocked". */
+  preflight: Schema.optionalKey(PreflightSchema),
+  /** Output patterns that raise a badge when they appear in the pane. */
+  alerts: Schema.optionalKey(Schema.Array(AlertSchema))
+}).pipe(
+  Schema.check(
+    Schema.makeFilter(
+      (spec) => spec.shell === void 0 === (spec.cmd === void 0) ? "expected exactly one of `shell` or `cmd`" : void 0
+    )
+  )
+);
+var DEFAULT_UI_PORT = 4820;
+var PORT_TEMPLATE = /\$\{port(?::([^}]+))?\}/g;
+var templatedStrings = (spec) => [spec.shell, ...spec.cmd ?? [], ...Object.values(spec.env ?? {}), spec.url].filter(
+  (text) => text !== void 0
+);
+var usesOwnPort = (spec) => templatedStrings(spec).some(
+  (text) => [...text.matchAll(PORT_TEMPLATE)].some((match) => match[1] === void 0)
+);
+var portRefs = (spec) => templatedStrings(spec).flatMap(
+  (text) => [...text.matchAll(PORT_TEMPLATE)].flatMap((match) => match[1] === void 0 ? [] : [match[1]])
+);
+var resolveSpec = (spec, assigned) => {
+  const sub = (text) => text.replace(PORT_TEMPLATE, (whole, ref) => {
+    const port = assigned.get(ref ?? spec.id);
+    return port === void 0 ? whole : String(port);
+  });
+  return {
+    ...spec,
+    ...spec.shell === void 0 ? {} : { shell: sub(spec.shell) },
+    ...spec.cmd === void 0 ? {} : { cmd: spec.cmd.map(sub) },
+    ...spec.env === void 0 ? {} : { env: Object.fromEntries(Object.entries(spec.env).map(([key, value]) => [key, sub(value)])) },
+    ...spec.url === void 0 ? {} : { url: sub(spec.url) }
+  };
+};
+var validateGraph = (procs) => {
+  const ids = new Set(procs.map((proc) => proc.id));
+  if (ids.size !== procs.length) return "duplicate proc ids";
+  for (const proc of procs) {
+    for (const need of proc.needs ?? []) {
+      if (!ids.has(need)) return `proc "${proc.id}" needs unknown proc "${need}"`;
+    }
+  }
+  const needsOf = new Map(procs.map((proc) => [proc.id, proc.needs ?? []]));
+  const done = /* @__PURE__ */ new Set();
+  const onPath = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (done.has(id)) return void 0;
+    if (onPath.has(id)) return `dependency cycle through "${id}"`;
+    onPath.add(id);
+    for (const need of needsOf.get(id) ?? []) {
+      const cycle = visit(need);
+      if (cycle !== void 0) return cycle;
+    }
+    onPath.delete(id);
+    done.add(id);
+    return void 0;
+  };
+  for (const proc of procs) {
+    const cycle = visit(proc.id);
+    if (cycle !== void 0) return cycle;
+  }
+  return void 0;
+};
+var validatePortTemplates = (procs) => {
+  const byId = new Map(procs.map((proc) => [proc.id, proc]));
+  for (const proc of procs) {
+    for (const ref of portRefs(proc)) {
+      const target = byId.get(ref);
+      if (target === void 0) {
+        return `proc "${proc.id}" references \${port:${ref}} but there is no proc "${ref}"`;
+      }
+      if (!usesOwnPort(target)) {
+        return `proc "${proc.id}" references \${port:${ref}} but "${ref}" does not use \${port} itself`;
+      }
+    }
+  }
+  return void 0;
+};
+var ProcdeckConfigSchema = Schema.Struct({
+  /**
+   * Deck name — the tab title and the name of the installed web app.
+   * Defaults to the config directory's basename.
+   */
+  name: Schema.optionalKey(Schema.String),
+  /** Port for the web UI. Defaults to 4820. */
+  port: Schema.optionalKey(Schema.Number),
+  procs: Schema.Array(ProcSpecSchema)
+}).pipe(
+  Schema.check(
+    Schema.makeFilter(
+      (config) => validateGraph(config.procs) ?? validatePortTemplates(config.procs)
+    )
+  )
+);
+var defineConfig = (config) => config;
+var ConfigError = class extends Schema.TaggedError()("ConfigError", {
+  file: Schema.String,
+  message: Schema.String
+}) {
+};
+var loadConfig = Effect.fn("procdeck.loadConfig")(function* (file) {
+  const absolute = path.resolve(file);
+  const module = yield* Effect.tryPromise({
+    try: () => import(pathToFileURL(absolute).href),
+    catch: (cause) => new ConfigError({ file: absolute, message: String(cause) })
+  });
+  const config = yield* Effect.try({
+    try: () => Schema.decodeUnknownSync(ProcdeckConfigSchema)(module.default),
+    catch: (cause) => new ConfigError({ file: absolute, message: String(cause) })
+  });
+  const root = path.dirname(absolute);
+  const loaded = { config, root, name: config.name ?? path.basename(root) };
+  return loaded;
+});
+
+export {
+  PreflightSchema,
+  AlertSchema,
+  ProcSpecSchema,
+  DEFAULT_UI_PORT,
+  usesOwnPort,
+  resolveSpec,
+  ProcdeckConfigSchema,
+  defineConfig,
+  ConfigError,
+  loadConfig
+};