@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/repos/reportCheck.js

@@ -0,0 +1,268 @@
+import {
+  runHelperFile
+} from "../chunks/chunk-WT3XUFWU.js";
+
+// repos/reportCheck.js
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { commandEnv, gitRaw, gitText } from "./git.js";
+var SHA_RE = /^[0-9a-f]{7,40}$/;
+var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var DIFF_OPTS = ["--no-color", "--no-ext-diff", "--no-renames", "--no-textconv"];
+function assertSha(sha) {
+  if (!SHA_RE.test(sha))
+    throw new Error(`\u65E0\u6548\u7684\u63D0\u4EA4 ${sha}`);
+}
+function assertRef(ref) {
+  if (!ref || ref.startsWith("-"))
+    throw new Error(`\u65E0\u6548\u7684\u5F15\u7528 ${ref}`);
+}
+async function resolveCommit(repoPath, sha, helpers) {
+  try {
+    await gitText(repoPath, ["cat-file", "-e", `${sha}^{commit}`], void 0, helpers);
+    return await gitText(repoPath, ["rev-parse", "--verify", `${sha}^{commit}`], void 0, helpers);
+  } catch {
+    return null;
+  }
+}
+async function isAncestor(repoPath, sha, ref, helpers) {
+  try {
+    await gitText(repoPath, ["merge-base", "--is-ancestor", sha, ref], void 0, helpers);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function patchIds(repoPath, input, helpers) {
+  if (input.length === 0)
+    return Promise.resolve([]);
+  if (helpers)
+    return runHelperFile("git", ["-C", repoPath, "patch-id", "--stable"], {
+      env: commandEnv(),
+      timeout: 6e4,
+      maxBuffer: 64 * 1024 * 1024,
+      encoding: "buffer",
+      input
+    }, helpers).then((result) => {
+      if (result.error)
+        throw new Error(result.stderr.toString("utf8").trim() || `git patch-id exited ${result.code}`);
+      return parsePatchIds(result.stdout);
+    });
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", ["-C", repoPath, "patch-id", "--stable"], { env: commandEnv(), shell: false, stdio: ["pipe", "pipe", "pipe"] });
+    const out = [];
+    const err = [];
+    const timer = setTimeout(() => child.kill("SIGKILL"), 6e4);
+    child.stdout.on("data", (b) => out.push(b));
+    child.stderr.on("data", (b) => err.push(b));
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(Buffer.concat(err).toString("utf8").trim() || `git patch-id exited ${code}`));
+        return;
+      }
+      resolve(parsePatchIds(Buffer.concat(out)));
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(input);
+  });
+}
+function parsePatchIds(output) {
+  const rows = [];
+  for (const line of output.toString("utf8").split("\n")) {
+    const [patchId, commit] = line.trim().split(/\s+/);
+    if (patchId && commit)
+      rows.push({ patchId, commit });
+  }
+  return rows;
+}
+async function combinedPatchId(repoPath, oldest, newest, helpers) {
+  const parent = await gitText(repoPath, ["rev-parse", "--verify", "--quiet", `${oldest}^`], void 0, helpers).catch(() => EMPTY_TREE);
+  const diff = await gitRaw(repoPath, ["diff", ...DIFF_OPTS, parent, newest, "--"], void 0, helpers);
+  return (await patchIds(repoPath, diff, helpers))[0]?.patchId ?? null;
+}
+async function logPatchIds(repoPath, args, helpers) {
+  const log = await gitRaw(repoPath, ["log", "-p", ...DIFF_OPTS, "--no-merges", "--format=commit %H", ...args, "--"], 12e4, helpers);
+  const byCommit = /* @__PURE__ */ new Map();
+  for (const row of await patchIds(repoPath, log, helpers))
+    byCommit.set(row.commit, row.patchId);
+  return byCommit;
+}
+async function chainEnds(repoPath, shas, helpers) {
+  let oldest = shas[0];
+  let newest = shas[shas.length - 1];
+  for (const a of shas) {
+    let isOldest = true;
+    let isNewest = true;
+    for (const b of shas) {
+      if (a === b)
+        continue;
+      if (isOldest && !await isAncestor(repoPath, a, b, helpers))
+        isOldest = false;
+      if (isNewest && !await isAncestor(repoPath, b, a, helpers))
+        isNewest = false;
+    }
+    if (isOldest)
+      oldest = a;
+    if (isNewest)
+      newest = a;
+  }
+  return [oldest, newest];
+}
+async function parentsOf(repoPath, shas, helpers) {
+  const parents = /* @__PURE__ */ new Map();
+  if (shas.length === 0)
+    return parents;
+  const text = await gitText(repoPath, ["rev-list", "--no-walk=unsorted", "--parents", ...shas, "--"], void 0, helpers);
+  for (const line of text.split("\n")) {
+    const [sha, ...rest] = line.trim().split(/\s+/);
+    if (sha)
+      parents.set(sha, rest);
+  }
+  return parents;
+}
+function normalizeClaim(file) {
+  return path.posix.normalize(file.replace(/\\/g, "/")).replace(/^\.\//, "").replace(/\/$/, "");
+}
+async function checkReport(repoPath, mainRefName, commits, files, helpers) {
+  assertRef(mainRefName);
+  for (const sha of commits)
+    assertSha(sha);
+  const mainSha = await gitText(repoPath, ["rev-parse", "--verify", `${mainRefName}^{commit}`], void 0, helpers);
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const resolved = [];
+  const missingCommits = [];
+  for (const sha of commits) {
+    const full = await resolveCommit(repoPath, sha, helpers);
+    if (full === null)
+      missingCommits.push(sha);
+    else if (!resolved.includes(full))
+      resolved.push(full);
+  }
+  const commitsExist = missingCommits.length === 0 && resolved.length > 0;
+  let onMain = "not-yet";
+  if (commitsExist) {
+    let all = true;
+    for (const sha of resolved) {
+      if (!await isAncestor(repoPath, sha, mainSha, helpers)) {
+        all = false;
+        break;
+      }
+    }
+    if (all)
+      onMain = "yes";
+    else {
+      const [oldest, newest] = await chainEnds(repoPath, resolved, helpers);
+      const combined = await combinedPatchId(repoPath, oldest, newest, helpers);
+      const base = await gitText(repoPath, ["merge-base", resolved[0], mainSha], void 0, helpers).catch(() => null);
+      if (combined !== null && base !== null) {
+        const mainIds = new Set((await logPatchIds(repoPath, [`${base}..${mainSha}`], helpers)).values());
+        if (mainIds.has(combined))
+          onMain = "yes";
+        else {
+          const parents2 = await parentsOf(repoPath, resolved, helpers);
+          const own = await logPatchIds(repoPath, ["--no-walk=unsorted", ...resolved], helpers);
+          let every = true;
+          let matched = 0;
+          for (const sha of resolved) {
+            if ((parents2.get(sha)?.length ?? 0) > 1)
+              continue;
+            if (await isAncestor(repoPath, sha, mainSha, helpers))
+              continue;
+            const id = own.get(sha);
+            if (id === void 0)
+              continue;
+            if (!mainIds.has(id)) {
+              every = false;
+              break;
+            }
+            matched++;
+          }
+          if (every && matched > 0)
+            onMain = "yes";
+        }
+      }
+    }
+  }
+  const touched = /* @__PURE__ */ new Set();
+  const parents = await parentsOf(repoPath, resolved, helpers);
+  for (const sha of resolved) {
+    if ((parents.get(sha)?.length ?? 0) > 1)
+      continue;
+    const out = await gitRaw(repoPath, ["diff-tree", "--no-commit-id", "--name-only", "-r", "-M", "--root", "-z", sha, "--"], void 0, helpers);
+    for (const name of out.toString("utf8").split("\0"))
+      if (name)
+        touched.add(name);
+  }
+  const untouchedFiles = files.filter((file) => !touched.has(normalizeClaim(file)));
+  return { commitsExist, missingCommits, onMain, filesOk: untouchedFiles.length === 0, untouchedFiles, touchedFiles: [...touched], checkedAt, mainSha };
+}
+async function uncoveredCommits(repoPath, mainRefName, from, to, covered, helpers) {
+  assertRef(mainRefName);
+  for (const rev of [from, to]) {
+    if (rev === mainRefName)
+      continue;
+    assertSha(rev);
+    if (!await isAncestor(repoPath, rev, mainRefName, helpers))
+      throw new Error(`\u63D0\u4EA4 ${rev} \u4E0D\u5728\u4E3B\u5206\u652F\u4E0A`);
+  }
+  for (const sha of covered)
+    assertSha(sha);
+  const listed = await gitText(repoPath, ["rev-list", "--no-merges", "--reverse", `${from}..${to}`, "--"], void 0, helpers);
+  const candidates = listed.split("\n").filter(Boolean);
+  if (candidates.length === 0)
+    return [];
+  const coveredSet = /* @__PURE__ */ new Set();
+  for (const sha of covered) {
+    const full = await resolveCommit(repoPath, sha, helpers);
+    if (full !== null)
+      coveredSet.add(full);
+  }
+  const coveredList = [...coveredSet];
+  const coveredIds = /* @__PURE__ */ new Set();
+  if (coveredList.length > 0) {
+    for (const id of (await logPatchIds(repoPath, ["--no-walk=unsorted", ...coveredList], helpers)).values())
+      coveredIds.add(id);
+    const offMain = [];
+    for (const sha of coveredList)
+      if (!await isAncestor(repoPath, sha, to, helpers))
+        offMain.push(sha);
+    const parents = await parentsOf(repoPath, offMain, helpers);
+    const offSet = new Set(offMain.filter((sha) => (parents.get(sha)?.length ?? 0) <= 1));
+    const childOf = /* @__PURE__ */ new Map();
+    for (const sha of offSet) {
+      const parent = parents.get(sha)?.[0];
+      if (parent && offSet.has(parent))
+        childOf.set(parent, sha);
+    }
+    for (const start of offSet) {
+      const parent = parents.get(start)?.[0];
+      if (parent && offSet.has(parent))
+        continue;
+      let end = start;
+      while (childOf.has(end))
+        end = childOf.get(end);
+      if (end === start)
+        continue;
+      const combined = await combinedPatchId(repoPath, start, end, helpers);
+      if (combined !== null)
+        coveredIds.add(combined);
+    }
+  }
+  const idOf = await logPatchIds(repoPath, [`${from}..${to}`], helpers);
+  return candidates.filter((sha) => {
+    if (coveredSet.has(sha))
+      return false;
+    const id = idOf.get(sha);
+    return id === void 0 || !coveredIds.has(id);
+  });
+}
+export {
+  checkReport,
+  uncoveredCommits
+};

package/dist/repos/watcher.d.ts

@@ -0,0 +1,64 @@
+import type { GraphifyOpts } from "./graphify.js";
+export type WatchedRepo = {
+    workspaceId: string;
+    repoId: string;
+    path: string;
+    mainBranch: string;
+    lastMainSha: string | null;
+};
+export type RepoMoved = {
+    repoId: string;
+    mainRef: string;
+    from: string | null;
+    to: string;
+};
+export type RepoFetched = {
+    repoId: string;
+    ok: boolean;
+    error?: string;
+    at: string;
+};
+export declare class RepoWatcher {
+    private readonly nemaHome;
+    private readonly intervalMs;
+    private readonly onMoved;
+    private readonly onFetch;
+    private readonly graphify;
+    private repos;
+    /** Last sha this process has recorded. `null` means the first tick still has to baseline. */
+    private readonly known;
+    private timer;
+    private inflight;
+    /** Tasks that already refreshed a repo. Capped so a long-lived daemon does not keep every id. */
+    private readonly prepared;
+    /** Full ticks and single-repo ticks run one at a time, so one move is never reported twice. */
+    private queue;
+    private stopped;
+    private stopping?;
+    constructor(opts: {
+        nemaHome: string;
+        intervalMs?: number;
+        /** `false` means the move was not sent. The sha stays put and the next tick retries. */
+        onMoved: (move: RepoMoved) => boolean | void;
+        onFetch: (report: RepoFetched) => void;
+        /** For tests: production passes nothing and runs `graphify` from PATH. */
+        graphify?: GraphifyOpts;
+    });
+    setRepos(list: WatchedRepo[]): void;
+    private serial;
+    tick(): Promise<void>;
+    /**
+     * Fetches one watched repo. The same task id does this once; a missing task id fetches every call.
+     * An unknown repo id is a no-op.
+     */
+    prepare(repoId: string, taskId?: string): Promise<void>;
+    /** Ticks one watched repo now (a coding agent's hook fired). An unknown repo id is a no-op. */
+    tickRepo(repoId: string): Promise<void>;
+    private runTick;
+    /** False once `setRepos` dropped this repo, for example after an unbind while its tick ran. */
+    private isWatched;
+    private tickOne;
+    start(): void;
+    stop(): Promise<void>;
+}
+export declare function parseReposSync(params: unknown): WatchedRepo[];

package/dist/repos/watcher.js

@@ -0,0 +1,202 @@
+// repos/watcher.js
+import { removeSnapshot, snapshotDir } from "./handlers.js";
+import { fetchMain, mainRef, revParse } from "./git.js";
+import { syncIndex, withIndexLock } from "./indexState.js";
+var DEFAULT_INTERVAL_MS = 3e5;
+var RepoWatcher = class {
+  nemaHome;
+  intervalMs;
+  onMoved;
+  onFetch;
+  graphify;
+  repos = [];
+  /** Last sha this process has recorded. `null` means the first tick still has to baseline. */
+  known = /* @__PURE__ */ new Map();
+  timer = null;
+  inflight = null;
+  /** Tasks that already refreshed a repo. Capped so a long-lived daemon does not keep every id. */
+  prepared = /* @__PURE__ */ new Set();
+  /** Full ticks and single-repo ticks run one at a time, so one move is never reported twice. */
+  queue = Promise.resolve();
+  stopped = false;
+  stopping;
+  constructor(opts) {
+    this.graphify = opts.graphify;
+    this.nemaHome = opts.nemaHome;
+    this.intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.onMoved = opts.onMoved;
+    this.onFetch = opts.onFetch;
+  }
+  setRepos(list) {
+    if (this.stopped)
+      return;
+    const keep = new Set(list.map((repo) => repo.repoId));
+    for (const id of this.known.keys()) {
+      if (!keep.has(id))
+        this.known.delete(id);
+    }
+    for (const repo of list) {
+      const recorded = this.known.get(repo.repoId);
+      this.known.set(repo.repoId, repo.lastMainSha === null && recorded !== void 0 ? recorded : repo.lastMainSha);
+    }
+    this.repos = list;
+  }
+  serial(fn) {
+    const run = this.queue.then(fn);
+    this.queue = run.catch(() => {
+    });
+    return run;
+  }
+  tick() {
+    if (this.stopped)
+      return this.stopping ?? Promise.resolve();
+    if (this.inflight)
+      return this.inflight;
+    const run = this.serial(() => this.runTick()).finally(() => {
+      this.inflight = null;
+    });
+    this.inflight = run;
+    return run;
+  }
+  /**
+   * Fetches one watched repo. The same task id does this once; a missing task id fetches every call.
+   * An unknown repo id is a no-op.
+   */
+  prepare(repoId, taskId) {
+    if (!taskId)
+      return this.tickRepo(repoId);
+    const key = `${taskId}\0${repoId}`;
+    if (this.prepared.has(key))
+      return Promise.resolve();
+    return this.serial(async () => {
+      if (this.stopped || this.prepared.has(key))
+        return;
+      const repo = this.repos.find((row) => row.repoId === repoId);
+      if (!repo || !this.isWatched(repo))
+        return;
+      try {
+        await this.tickOne(repo);
+      } catch (error) {
+        console.error(`[nema] repo watch failed for ${repo.repoId}`, error);
+        return;
+      }
+      if (this.stopped || !this.isWatched(repo))
+        return;
+      this.prepared.add(key);
+      if (this.prepared.size > 500)
+        this.prepared.clear();
+    });
+  }
+  /** Ticks one watched repo now (a coding agent's hook fired). An unknown repo id is a no-op. */
+  tickRepo(repoId) {
+    if (this.stopped)
+      return this.stopping ?? Promise.resolve();
+    return this.serial(async () => {
+      if (this.stopped)
+        return;
+      const repo = this.repos.find((row) => row.repoId === repoId);
+      if (!repo)
+        return;
+      try {
+        await this.tickOne(repo);
+      } catch (error) {
+        console.error(`[nema] repo watch failed for ${repo.repoId}`, error);
+      }
+    });
+  }
+  async runTick() {
+    for (const repo of this.repos) {
+      if (this.stopped)
+        return;
+      try {
+        await this.tickOne(repo);
+      } catch (error) {
+        console.error(`[nema] repo watch failed for ${repo.repoId}`, error);
+      }
+    }
+  }
+  /** False once `setRepos` dropped this repo, for example after an unbind while its tick ran. */
+  isWatched(repo) {
+    return this.repos.some((row) => row.repoId === repo.repoId && row.workspaceId === repo.workspaceId);
+  }
+  async tickOne(repo) {
+    if (this.stopped || !this.isWatched(repo))
+      return;
+    const fetched = await fetchMain(repo.path, repo.mainBranch, this.graphify?.ownedHelpers);
+    if (this.stopped || !this.isWatched(repo))
+      return;
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    if (fetched.ok)
+      this.onFetch({ repoId: repo.repoId, ok: true, at });
+    else
+      this.onFetch({ repoId: repo.repoId, ok: false, error: fetched.error, at });
+    const ref = await mainRef(repo.path, repo.mainBranch, this.graphify?.ownedHelpers);
+    const sha = await revParse(repo.path, ref, this.graphify?.ownedHelpers);
+    const root = snapshotDir(this.nemaHome, repo.workspaceId, repo.repoId);
+    try {
+      await withIndexLock(root, () => syncIndex(root, repo.path, sha, this.graphify));
+    } catch (error) {
+      console.error(`[nema] repo index failed for ${repo.repoId}`, error);
+    }
+    if (this.stopped)
+      return;
+    if (!this.isWatched(repo)) {
+      await withIndexLock(root, () => removeSnapshot(root));
+      return;
+    }
+    const last = this.known.get(repo.repoId) ?? null;
+    if (last === null) {
+      this.known.set(repo.repoId, sha);
+      return;
+    }
+    if (sha === last)
+      return;
+    if (this.onMoved({ repoId: repo.repoId, mainRef: ref, from: last, to: sha }) === false)
+      return;
+    this.known.set(repo.repoId, sha);
+  }
+  start() {
+    if (this.stopped || this.intervalMs < 0)
+      return;
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+  }
+  stop() {
+    if (this.stopping)
+      return this.stopping;
+    this.stopped = true;
+    if (this.timer)
+      clearInterval(this.timer);
+    this.timer = null;
+    this.stopping = Promise.all([this.inflight ?? Promise.resolve(), this.queue]).then(() => {
+    });
+    return this.stopping;
+  }
+};
+function parseReposSync(params) {
+  if (!params || typeof params !== "object" || !Array.isArray(params.repos)) {
+    throw new Error("invalid repo params");
+  }
+  return params.repos.map((row) => {
+    if (!row || typeof row !== "object")
+      throw new Error("invalid repo params");
+    const repo = row;
+    const workspaceId = repo.workspaceId;
+    const repoId = repo.repoId;
+    const repoPath = repo.path;
+    const mainBranch = repo.mainBranch;
+    const lastMainSha = repo.lastMainSha;
+    if (typeof workspaceId !== "string" || typeof repoId !== "string" || typeof repoPath !== "string" || typeof mainBranch !== "string" || !workspaceId || !repoId || !repoPath || !mainBranch) {
+      throw new Error("invalid repo params");
+    }
+    if (!(lastMainSha === null || typeof lastMainSha === "string" && lastMainSha !== "")) {
+      throw new Error("invalid repo params");
+    }
+    return { workspaceId, repoId, path: repoPath, mainBranch, lastMainSha };
+  });
+}
+export {
+  RepoWatcher,
+  parseReposSync
+};

package/dist/room/client.d.ts

@@ -0,0 +1,26 @@
+/** Tool output returned to the model is capped at this many UTF-8 bytes (marker included). */
+export declare const MAX_TOOL_OUTPUT_BYTES: number;
+/** Caps `text` at `maxBytes` UTF-8 bytes (never splitting a character), appending a truncation marker. */
+export declare function capText(text: string, maxBytes?: number): string;
+export type RoomResult = {
+    ok: true;
+    json: unknown;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare class RoomClient {
+    private readonly runToken;
+    private readonly signal?;
+    private readonly base;
+    /** `signal` (optional) aborts in-flight requests, e.g. when the run times out. */
+    constructor(hubUrl: string, runToken: string, signal?: AbortSignal | undefined);
+    listEntries(): Promise<RoomResult>;
+    readEntry(id: string): Promise<RoomResult>;
+    upsertEntry(input: unknown): Promise<RoomResult>;
+    openThread(args: unknown): Promise<RoomResult>;
+    listPluginTools(): Promise<RoomResult>;
+    callPlugin(name: string, args: unknown): Promise<RoomResult>;
+    private call;
+}

package/dist/room/client.js

@@ -0,0 +1,76 @@
+// room/client.js
+var MAX_TOOL_OUTPUT_BYTES = 64 * 1024;
+function capText(text, maxBytes = MAX_TOOL_OUTPUT_BYTES) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes)
+    return text;
+  const marker = `\u2026[\u5DF2\u622A\u65AD\uFF1A\u539F\u59CB ${buf.length} \u5B57\u8282\uFF0C\u4EC5\u4FDD\u7559\u524D 64KB]`;
+  let end = Math.max(0, maxBytes - Buffer.byteLength(marker));
+  while (end > 0 && (buf[end] & 192) === 128)
+    end--;
+  return buf.subarray(0, end).toString("utf8") + marker;
+}
+var RoomClient = class {
+  runToken;
+  signal;
+  base;
+  /** `signal` (optional) aborts in-flight requests, e.g. when the run times out. */
+  constructor(hubUrl, runToken, signal) {
+    this.runToken = runToken;
+    this.signal = signal;
+    this.base = hubUrl.replace(/\/+$/, "");
+  }
+  listEntries() {
+    return this.call("GET", "/entries");
+  }
+  readEntry(id) {
+    return this.call("GET", `/entries/${encodeURIComponent(id)}`);
+  }
+  upsertEntry(input) {
+    return this.call("POST", "/entries", input);
+  }
+  openThread(args) {
+    return this.call("POST", "/threads", args);
+  }
+  listPluginTools() {
+    return this.call("GET", "/plugins");
+  }
+  callPlugin(name, args) {
+    return this.call("POST", `/plugins/${encodeURIComponent(name)}`, args);
+  }
+  async call(method, path, body) {
+    let res;
+    let text;
+    try {
+      res = await fetch(`${this.base}/room${path}`, {
+        method,
+        headers: {
+          authorization: `Bearer ${this.runToken}`,
+          ...body !== void 0 ? { "content-type": "application/json" } : {}
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: this.signal
+      });
+      text = await res.text();
+    } catch (e) {
+      return { ok: false, status: 0, error: `\u65E0\u6CD5\u8FDE\u63A5 hub\uFF1A${e instanceof Error ? e.message : String(e)}` };
+    }
+    let parsed;
+    let isJson = false;
+    try {
+      parsed = JSON.parse(text);
+      isJson = true;
+    } catch {
+    }
+    if (!res.ok) {
+      const err = isJson && parsed && typeof parsed === "object" ? parsed.error : void 0;
+      return { ok: false, status: res.status, error: capText(typeof err === "string" ? err : text || `hub returned HTTP ${res.status}`) };
+    }
+    return { ok: true, json: isJson ? parsed : capText(text) };
+  }
+};
+export {
+  MAX_TOOL_OUTPUT_BYTES,
+  RoomClient,
+  capText
+};

package/dist/secrets/file.d.ts

@@ -0,0 +1,12 @@
+export type SecretFileErrorKind = "invalid" | "symlink" | "mode";
+/** Errors from the secret-file helpers. Messages name the file, never its contents. */
+export declare class SecretFileError extends Error {
+    readonly kind: SecretFileErrorKind;
+    constructor(kind: SecretFileErrorKind, message: string);
+}
+/** Atomically writes one line to `file` with mode 0600. Refuses a symlink; on reject the existing file is untouched. */
+export declare function saveSecretLine(file: string, value: string, dirMode?: number): void;
+/** Reads one line from a 0600 regular file without following symlinks. The value is never echoed in errors. */
+export declare function readSecretLine(file: string, missingMessage: string, invalidMessage: string): string;
+/** Reads the first line of stdin, trimmed. */
+export declare function readStdinLine(stdin: NodeJS.ReadableStream): Promise<string>;