@adelie/server 0.0.0-stage → 0.5.0

package/dist/api/types.js

@@ -0,0 +1,10 @@
+import {
+  MACHINE_PHASES,
+  TICKET_SLUG_PATTERN
+} from "../chunk-IZEMORXV.js";
+import "../chunk-B5IP37ZQ.js";
+export {
+  MACHINE_PHASES,
+  TICKET_SLUG_PATTERN
+};
+//# sourceMappingURL=types.js.map

package/dist/api/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/auth-token.d.ts

@@ -0,0 +1,50 @@
+/** How a session was established, as stored. NULL on rows formed before the column existed. */
+type SessionViaValue = "password" | "desktop" | "setup" | "cli";
+
+/** An hour: long enough for a controller to finish, short enough to forget. */
+declare const CLI_TOKEN_TTL_MS: number;
+/**
+ * Ceiling on a caller-supplied `--ttl-seconds`, matching the default session TTL (config.ts):
+ * a token that lives in a file must not outlive an ordinary browser session.
+ */
+declare const CLI_TOKEN_MAX_TTL_MS: number;
+/**
+ * What a minted row records about how its session was established.
+ *
+ * `cli` is the default and what `penguin auth token` writes: a session that behaves like a
+ * password one in every way. `desktop` is for the desktop shell signing its own window in
+ * against a server it did not spawn, and says the same thing its one-shot claim token says —
+ * with as much backing, since only an account that can write this file can mint at all.
+ *
+ * The distinction is not cosmetic: a desktop session may set a password without supplying the
+ * current one, because the account the shell created has a password that was generated,
+ * hashed and discarded unseen — there is nothing to supply, and whoever can write to this
+ * data root can already reset that password offline (`penguin server reset-admin-password`).
+ * That allowance is granted by a server running in desktop mode; against any other server the
+ * value records what the session is without widening what it may do (routes/me.ts).
+ */
+type MintedVia = Extract<SessionViaValue, "cli" | "desktop">;
+type MintTokenResult = {
+    outcome: "minted";
+    token: string;
+    userId: string;
+    expiresAt: string;
+}
+/** No web.db on this root — the server has never run here, so there is no account to mint for. */
+ | {
+    outcome: "no_server";
+} | {
+    outcome: "failed";
+    detail: string;
+};
+/** Issues an API session token for the data root at `root`. */
+declare function mintApiToken(root: string, opts?: {
+    userId?: string;
+    ttlMs?: number;
+    dbPath?: string;
+    now?: Date;
+    /** How the session records its own establishment; `cli` unless told otherwise. */
+    via?: MintedVia;
+}): MintTokenResult;
+
+export { CLI_TOKEN_MAX_TTL_MS, CLI_TOKEN_TTL_MS, type MintTokenResult, type MintedVia, mintApiToken };

package/dist/auth-token.js

@@ -0,0 +1,55 @@
+import {
+  AuthSessionsRepo,
+  UsersRepo
+} from "./chunk-WPYTS7TI.js";
+import {
+  openExistingDatabase
+} from "./chunk-ZZUQGQD6.js";
+import "./chunk-B5IP37ZQ.js";
+
+// src/auth-token.ts
+import path from "path";
+import fs from "fs";
+import { wire } from "@adelie/core/kernel";
+var CLI_TOKEN_TTL_MS = 60 * 6e4;
+var CLI_TOKEN_MAX_TTL_MS = 30 * 24 * 60 * 6e4;
+function explain(err, dbPath) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("no column named via")) {
+    return `${dbPath} predates this release \u2014 start the server once (\`penguin web\`) to upgrade it`;
+  }
+  if (message.includes("unable to open database")) {
+    return `cannot open ${dbPath} \u2014 minting needs the data root's own OS account; otherwise sign in with \`penguin auth login --server <url>\``;
+  }
+  return message;
+}
+function mintApiToken(root, opts = {}) {
+  const userId = opts.userId ?? "admin";
+  const dbPath = opts.dbPath ?? path.join(root, "web.db");
+  if (!fs.existsSync(dbPath)) return { outcome: "no_server" };
+  let db = null;
+  try {
+    db = openExistingDatabase(dbPath);
+    if (wire(UsersRepo, { db }).findById(userId) === null) {
+      return { outcome: "failed", detail: `no such account: ${userId}` };
+    }
+    const { token, expiresAt } = wire(AuthSessionsRepo, { db }).issue({
+      userId,
+      via: opts.via ?? "cli",
+      now: opts.now ?? /* @__PURE__ */ new Date(),
+      ttlMs: opts.ttlMs ?? CLI_TOKEN_TTL_MS,
+      maxTtlMs: CLI_TOKEN_MAX_TTL_MS
+    });
+    return { outcome: "minted", token, userId, expiresAt };
+  } catch (err) {
+    return { outcome: "failed", detail: explain(err, dbPath) };
+  } finally {
+    db?.close();
+  }
+}
+export {
+  CLI_TOKEN_MAX_TTL_MS,
+  CLI_TOKEN_TTL_MS,
+  mintApiToken
+};
+//# sourceMappingURL=auth-token.js.map

package/dist/auth-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auth-token.ts"],"sourcesContent":["/**\n * Mints an API session by inserting a row into the root's `web.db` — no running server needed.\n * Authorized by being able to read and write that root, which already holds every credential\n * the token could reach. On a multi-user box that means the OS account running the server;\n * everyone else signs in with `penguin auth login --server <url>`.\n */\nimport path from \"node:path\";\nimport fs from \"node:fs\";\nimport { openExistingDatabase } from \"./db/database.js\";\nimport { AuthSessionsRepo } from \"./db/repos/auth-sessions.js\";\nimport type { SessionViaValue } from \"./db/repos/auth-sessions.js\";\nimport { UsersRepo } from \"./db/repos/users.js\";\nimport { wire } from \"@adelie/core/kernel\";\n\n/** An hour: long enough for a controller to finish, short enough to forget. */\nexport const CLI_TOKEN_TTL_MS = 60 * 60_000;\n\n/**\n * Ceiling on a caller-supplied `--ttl-seconds`, matching the default session TTL (config.ts):\n * a token that lives in a file must not outlive an ordinary browser session.\n */\nexport const CLI_TOKEN_MAX_TTL_MS = 30 * 24 * 60 * 60_000;\n\n/**\n * What a minted row records about how its session was established.\n *\n * `cli` is the default and what `penguin auth token` writes: a session that behaves like a\n * password one in every way. `desktop` is for the desktop shell signing its own window in\n * against a server it did not spawn, and says the same thing its one-shot claim token says —\n * with as much backing, since only an account that can write this file can mint at all.\n *\n * The distinction is not cosmetic: a desktop session may set a password without supplying the\n * current one, because the account the shell created has a password that was generated,\n * hashed and discarded unseen — there is nothing to supply, and whoever can write to this\n * data root can already reset that password offline (`penguin server reset-admin-password`).\n * That allowance is granted by a server running in desktop mode; against any other server the\n * value records what the session is without widening what it may do (routes/me.ts).\n */\nexport type MintedVia = Extract<SessionViaValue, \"cli\" | \"desktop\">;\n\nexport type MintTokenResult =\n  | { outcome: \"minted\"; token: string; userId: string; expiresAt: string }\n  /** No web.db on this root — the server has never run here, so there is no account to mint for. */\n  | { outcome: \"no_server\" }\n  | { outcome: \"failed\"; detail: string };\n\n/**\n * Turns a failure into something the person at the terminal can act on. Both cases are\n * ordinary situations, not crashes: a database owned by another OS account, and one written\n * by an older release (minting deliberately does not migrate — see openExistingDatabase).\n */\nfunction explain(err: unknown, dbPath: string): string {\n  const message = err instanceof Error ? err.message : String(err);\n  if (message.includes(\"no column named via\")) {\n    return `${dbPath} predates this release — start the server once (\\`penguin web\\`) to upgrade it`;\n  }\n  if (message.includes(\"unable to open database\")) {\n    return (\n      `cannot open ${dbPath} — minting needs the data root's own OS account; ` +\n      \"otherwise sign in with `penguin auth login --server <url>`\"\n    );\n  }\n  return message;\n}\n\n/** Issues an API session token for the data root at `root`. */\nexport function mintApiToken(\n  root: string,\n  opts: {\n    userId?: string;\n    ttlMs?: number;\n    dbPath?: string;\n    now?: Date;\n    /** How the session records its own establishment; `cli` unless told otherwise. */\n    via?: MintedVia;\n  } = {},\n): MintTokenResult {\n  const userId = opts.userId ?? \"admin\";\n  const dbPath = opts.dbPath ?? path.join(root, \"web.db\");\n  // Existence check first: openExistingDatabase would otherwise create an empty file, and a\n  // root with no web.db has no account to mint for.\n  if (!fs.existsSync(dbPath)) return { outcome: \"no_server\" };\n\n  let db: ReturnType<typeof openExistingDatabase> | null = null;\n  try {\n    db = openExistingDatabase(dbPath);\n    if (wire(UsersRepo, { db: db }).findById(userId) === null) {\n      return { outcome: \"failed\", detail: `no such account: ${userId}` };\n    }\n    // The repo is the single minting point (token shape, hash, TTL ceiling), so a CLI-minted\n    // row cannot drift from one the server issues itself.\n    const { token, expiresAt } = wire(AuthSessionsRepo, { db: db }).issue({\n      userId,\n      via: opts.via ?? \"cli\",\n      now: opts.now ?? new Date(),\n      ttlMs: opts.ttlMs ?? CLI_TOKEN_TTL_MS,\n      maxTtlMs: CLI_TOKEN_MAX_TTL_MS,\n    });\n    return { outcome: \"minted\", token, userId, expiresAt };\n  } catch (err) {\n    return { outcome: \"failed\", detail: explain(err, dbPath) };\n  } finally {\n    db?.close();\n  }\n}\n"],"mappings":";;;;;;;;;;AAMA,OAAO,UAAU;AACjB,OAAO,QAAQ;AAKf,SAAS,YAAY;AAGd,IAAM,mBAAmB,KAAK;AAM9B,IAAM,uBAAuB,KAAK,KAAK,KAAK;AA8BnD,SAAS,QAAQ,KAAc,QAAwB;AACrD,QAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,MAAI,QAAQ,SAAS,qBAAqB,GAAG;AAC3C,WAAO,GAAG,MAAM;AAAA,EAClB;AACA,MAAI,QAAQ,SAAS,yBAAyB,GAAG;AAC/C,WACE,eAAe,MAAM;AAAA,EAGzB;AACA,SAAO;AACT;AAGO,SAAS,aACd,MACA,OAOI,CAAC,GACY;AACjB,QAAM,SAAS,KAAK,UAAU;AAC9B,QAAM,SAAS,KAAK,UAAU,KAAK,KAAK,MAAM,QAAQ;AAGtD,MAAI,CAAC,GAAG,WAAW,MAAM,EAAG,QAAO,EAAE,SAAS,YAAY;AAE1D,MAAI,KAAqD;AACzD,MAAI;AACF,SAAK,qBAAqB,MAAM;AAChC,QAAI,KAAK,WAAW,EAAE,GAAO,CAAC,EAAE,SAAS,MAAM,MAAM,MAAM;AACzD,aAAO,EAAE,SAAS,UAAU,QAAQ,oBAAoB,MAAM,GAAG;AAAA,IACnE;AAGA,UAAM,EAAE,OAAO,UAAU,IAAI,KAAK,kBAAkB,EAAE,GAAO,CAAC,EAAE,MAAM;AAAA,MACpE;AAAA,MACA,KAAK,KAAK,OAAO;AAAA,MACjB,KAAK,KAAK,OAAO,oBAAI,KAAK;AAAA,MAC1B,OAAO,KAAK,SAAS;AAAA,MACrB,UAAU;AAAA,IACZ,CAAC;AACD,WAAO,EAAE,SAAS,UAAU,OAAO,QAAQ,UAAU;AAAA,EACvD,SAAS,KAAK;AACZ,WAAO,EAAE,SAAS,UAAU,QAAQ,QAAQ,KAAK,MAAM,EAAE;AAAA,EAC3D,UAAE;AACA,QAAI,MAAM;AAAA,EACZ;AACF;","names":[]}

package/dist/chunk-B5IP37ZQ.js

@@ -0,0 +1,56 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __decoratorStart,
+  __runInitializers,
+  __decorateElement,
+  __publicField
+};
+//# sourceMappingURL=chunk-B5IP37ZQ.js.map

package/dist/chunk-B5IP37ZQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-BQZC56BR.js

@@ -0,0 +1,78 @@
+// src/lock.ts
+import fs from "fs";
+import net from "net";
+import path from "path";
+var PROBE_TIMEOUT_MS = 500;
+function serverLockPath(root) {
+  return path.join(root, "server.lock");
+}
+function parseServerLock(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || typeof parsed.port !== "number" || !Number.isInteger(parsed.port)) {
+      return null;
+    }
+    return { pid: parsed.pid, port: parsed.port, startedAt: String(parsed.startedAt ?? "") };
+  } catch {
+    return null;
+  }
+}
+function readServerLock(root) {
+  try {
+    return parseServerLock(fs.readFileSync(serverLockPath(root), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function portAccepts(port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: "127.0.0.1", port, timeout: PROBE_TIMEOUT_MS });
+    const done = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+  });
+}
+async function isServerLockAlive(lock) {
+  return pidAlive(lock.pid) && await portAccepts(lock.port);
+}
+async function liveServerLock(root) {
+  const lock = readServerLock(root);
+  if (!lock) return null;
+  return await isServerLockAlive(lock) ? lock : null;
+}
+function acquireServerLock(root, lock) {
+  const target = serverLockPath(root);
+  const tmp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(lock) + "\n");
+  fs.renameSync(tmp, target);
+}
+function releaseServerLock(root) {
+  try {
+    const lock = readServerLock(root);
+    if (lock && lock.pid === process.pid) fs.rmSync(serverLockPath(root));
+  } catch {
+  }
+}
+
+export {
+  serverLockPath,
+  parseServerLock,
+  readServerLock,
+  isServerLockAlive,
+  liveServerLock,
+  acquireServerLock,
+  releaseServerLock
+};
+//# sourceMappingURL=chunk-BQZC56BR.js.map

package/dist/chunk-BQZC56BR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lock.ts"],"sourcesContent":["/**\n * Root-level server instance lock (`<root>/server.lock`).\n *\n * web.db is single-process / single-writer (see db/database.ts), and two servers on one\n * data root would also double-run the schedule scheduler — so a data root admits one\n * server at a time. The lock records {pid, port, startedAt}; liveness requires BOTH the\n * pid to be alive AND the recorded port to accept a TCP connection, because either signal\n * alone false-positives (pids get recycled, ports get taken by unrelated processes). A\n * lock that fails the liveness check is stale and is simply overwritten by the next\n * server.\n *\n * Published as `@adelie/server/lock` (side-effect-free) so the CLI and the\n * desktop shell can pre-check a root without importing the package entry, which starts\n * listening.\n */\nimport fs from \"node:fs\";\nimport net from \"node:net\";\nimport path from \"node:path\";\n\nexport interface ServerLock {\n  pid: number;\n  port: number;\n  startedAt: string;\n}\n\n/** TCP probe budget: loopback either connects immediately or the port is dead. */\nconst PROBE_TIMEOUT_MS = 500;\n\nexport function serverLockPath(root: string): string {\n  return path.join(root, \"server.lock\");\n}\n\n/**\n * The lock's text, parsed; anything that is not one reads as \"no lock\".\n *\n * Exported because a lock is also read where the file is not: a controller looking at\n * ANOTHER machine gets this same text back from an ssh `cat` (machines/server-state.ts). The\n * shape is defined once here so the two readers cannot drift apart.\n */\nexport function parseServerLock(raw: string): ServerLock | null {\n  try {\n    const parsed = JSON.parse(raw) as Partial<ServerLock>;\n    if (\n      typeof parsed.pid !== \"number\" ||\n      !Number.isInteger(parsed.pid) ||\n      typeof parsed.port !== \"number\" ||\n      !Number.isInteger(parsed.port)\n    ) {\n      return null;\n    }\n    return { pid: parsed.pid, port: parsed.port, startedAt: String(parsed.startedAt ?? \"\") };\n  } catch {\n    return null;\n  }\n}\n\n/** Reads the lock file; a missing or malformed file reads as \"no lock\". */\nexport function readServerLock(root: string): ServerLock | null {\n  try {\n    return parseServerLock(fs.readFileSync(serverLockPath(root), \"utf8\"));\n  } catch {\n    return null;\n  }\n}\n\nfunction pidAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (err) {\n    // EPERM = the process exists but belongs to another user — still alive.\n    return (err as NodeJS.ErrnoException).code === \"EPERM\";\n  }\n}\n\nfunction portAccepts(port: number): Promise<boolean> {\n  return new Promise((resolve) => {\n    // 127.0.0.1 rather than localhost: this is a raw TCP liveness probe, not an App\n    // request, and the server binds 127.0.0.1 (plus ::1) on loopback setups.\n    const socket = net.connect({ host: \"127.0.0.1\", port, timeout: PROBE_TIMEOUT_MS });\n    const done = (ok: boolean) => {\n      socket.destroy();\n      resolve(ok);\n    };\n    socket.once(\"connect\", () => done(true));\n    socket.once(\"timeout\", () => done(false));\n    socket.once(\"error\", () => done(false));\n  });\n}\n\n/** True when the lock's process is alive AND its port accepts connections. */\nexport async function isServerLockAlive(lock: ServerLock): Promise<boolean> {\n  return pidAlive(lock.pid) && (await portAccepts(lock.port));\n}\n\n/** Convenience for pre-checks: the live lock on this root, or null (absent or stale). */\nexport async function liveServerLock(root: string): Promise<ServerLock | null> {\n  const lock = readServerLock(root);\n  if (!lock) return null;\n  return (await isServerLockAlive(lock)) ? lock : null;\n}\n\n/** Writes the lock atomically (tmp + rename; the parent directory must already exist). */\nexport function acquireServerLock(root: string, lock: ServerLock): void {\n  const target = serverLockPath(root);\n  const tmp = `${target}.${process.pid}.tmp`;\n  fs.writeFileSync(tmp, JSON.stringify(lock) + \"\\n\");\n  fs.renameSync(tmp, target);\n}\n\n/** Removes the lock if it is still ours (best-effort; never throws on shutdown paths). */\nexport function releaseServerLock(root: string): void {\n  try {\n    const lock = readServerLock(root);\n    if (lock && lock.pid === process.pid) fs.rmSync(serverLockPath(root));\n  } catch {\n    // Best-effort: a stale leftover is overwritten by the next server anyway.\n  }\n}\n"],"mappings":";AAeA,OAAO,QAAQ;AACf,OAAO,SAAS;AAChB,OAAO,UAAU;AASjB,IAAM,mBAAmB;AAElB,SAAS,eAAe,MAAsB;AACnD,SAAO,KAAK,KAAK,MAAM,aAAa;AACtC;AASO,SAAS,gBAAgB,KAAgC;AAC9D,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,QACE,OAAO,OAAO,QAAQ,YACtB,CAAC,OAAO,UAAU,OAAO,GAAG,KAC5B,OAAO,OAAO,SAAS,YACvB,CAAC,OAAO,UAAU,OAAO,IAAI,GAC7B;AACA,aAAO;AAAA,IACT;AACA,WAAO,EAAE,KAAK,OAAO,KAAK,MAAM,OAAO,MAAM,WAAW,OAAO,OAAO,aAAa,EAAE,EAAE;AAAA,EACzF,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGO,SAAS,eAAe,MAAiC;AAC9D,MAAI;AACF,WAAO,gBAAgB,GAAG,aAAa,eAAe,IAAI,GAAG,MAAM,CAAC;AAAA,EACtE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,SAAS,KAAsB;AACtC,MAAI;AACF,YAAQ,KAAK,KAAK,CAAC;AACnB,WAAO;AAAA,EACT,SAAS,KAAK;AAEZ,WAAQ,IAA8B,SAAS;AAAA,EACjD;AACF;AAEA,SAAS,YAAY,MAAgC;AACnD,SAAO,IAAI,QAAQ,CAAC,YAAY;AAG9B,UAAM,SAAS,IAAI,QAAQ,EAAE,MAAM,aAAa,MAAM,SAAS,iBAAiB,CAAC;AACjF,UAAM,OAAO,CAAC,OAAgB;AAC5B,aAAO,QAAQ;AACf,cAAQ,EAAE;AAAA,IACZ;AACA,WAAO,KAAK,WAAW,MAAM,KAAK,IAAI,CAAC;AACvC,WAAO,KAAK,WAAW,MAAM,KAAK,KAAK,CAAC;AACxC,WAAO,KAAK,SAAS,MAAM,KAAK,KAAK,CAAC;AAAA,EACxC,CAAC;AACH;AAGA,eAAsB,kBAAkB,MAAoC;AAC1E,SAAO,SAAS,KAAK,GAAG,KAAM,MAAM,YAAY,KAAK,IAAI;AAC3D;AAGA,eAAsB,eAAe,MAA0C;AAC7E,QAAM,OAAO,eAAe,IAAI;AAChC,MAAI,CAAC,KAAM,QAAO;AAClB,SAAQ,MAAM,kBAAkB,IAAI,IAAK,OAAO;AAClD;AAGO,SAAS,kBAAkB,MAAc,MAAwB;AACtE,QAAM,SAAS,eAAe,IAAI;AAClC,QAAM,MAAM,GAAG,MAAM,IAAI,QAAQ,GAAG;AACpC,KAAG,cAAc,KAAK,KAAK,UAAU,IAAI,IAAI,IAAI;AACjD,KAAG,WAAW,KAAK,MAAM;AAC3B;AAGO,SAAS,kBAAkB,MAAoB;AACpD,MAAI;AACF,UAAM,OAAO,eAAe,IAAI;AAChC,QAAI,QAAQ,KAAK,QAAQ,QAAQ,IAAK,IAAG,OAAO,eAAe,IAAI,CAAC;AAAA,EACtE,QAAQ;AAAA,EAER;AACF;","names":[]}

package/dist/chunk-C2S2LVQ7.js

@@ -0,0 +1,14 @@
+import {
+  readHarnessInfo
+} from "./chunk-GO6G445C.js";
+
+// src/version-report.ts
+import { buildInfo } from "@adelie/core";
+async function versionReport(root) {
+  return { ...buildInfo(), harness: await readHarnessInfo(root) };
+}
+
+export {
+  versionReport
+};
+//# sourceMappingURL=chunk-C2S2LVQ7.js.map

package/dist/chunk-C2S2LVQ7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/version-report.ts"],"sourcesContent":["/**\n * The one assembler behind `penguin version --json` and GET /api/version.\n *\n * The report has two halves that no single layer can produce. Core knows the artifact this\n * process is executing and nothing about data roots; the HMR store knows what harness was\n * pushed to a root and nothing about the process reading it. Joining them here — rather\n * than in each caller — is what makes \"the CLI and the API report the same thing\" a\n * structural fact instead of two spreads that have to be kept in step.\n *\n * It lives in the server package because that is where the harness.json format is owned\n * (see ./hmr/manifest.ts), and is exported as its own entry point so the CLI can reach it\n * without pulling in a server: the module graph here is core plus a `node:fs` read.\n */\nimport { buildInfo } from \"@adelie/core\";\nimport type { VersionReport } from \"@adelie/core\";\nimport { readHarnessInfo } from \"./hmr/manifest.js\";\n\n/**\n * The running build's identity plus the harness committed to `root`'s HMR store.\n *\n * Never throws: an unreadable or malformed store reports `harness: null`, which is also\n * what a root with nothing ever pushed to it reports. Version reporting degrades to fewer\n * facts, never to a failure.\n */\nexport async function versionReport(root: string): Promise<VersionReport> {\n  return { ...buildInfo(), harness: await readHarnessInfo(root) };\n}\n"],"mappings":";;;;;AAaA,SAAS,iBAAiB;AAW1B,eAAsB,cAAc,MAAsC;AACxE,SAAO,EAAE,GAAG,UAAU,GAAG,SAAS,MAAM,gBAAgB,IAAI,EAAE;AAChE;","names":[]}