waterplane 0.0.1 → 0.1.11

package/packages/host/dist/branchrules.js

@@ -0,0 +1,47 @@
+/**
+ * What the remote's own rules demand of the default branch, read async off
+ * `gh api` and cached per worktree. Failure of any kind (no gh, no auth, 403,
+ * non-GitHub origin) is ABSENT — the caller behaves as direct. Never on a
+ * request's hot path: routes use `cachedBranchRules`, which returns what it has
+ * and kicks a refresh.
+ */
+import { classifyBranchRules } from "@waterplane/shared";
+import { forgeFor } from "./forge/index.js";
+const TTL_MS = 10 * 60_000;
+const cache = new Map();
+const inflight = new Map();
+async function read(wt) {
+    const forge = await forgeFor(wt);
+    const raw = await forge?.rules();
+    return raw ? classifyBranchRules(raw.rules, raw.classic, raw.repo) : undefined;
+}
+/** The rules for this worktree's origin, cached ~10 min; concurrent calls share one read. */
+export function branchRules(wt) {
+    const hit = cache.get(wt);
+    if (hit && Date.now() - hit.at < TTL_MS)
+        return Promise.resolve(hit.value);
+    const running = inflight.get(wt);
+    if (running)
+        return running;
+    const p = read(wt)
+        .catch(() => undefined)
+        .then((value) => {
+        cache.set(wt, { at: Date.now(), value });
+        return value;
+    })
+        .finally(() => { inflight.delete(wt); });
+    inflight.set(wt, p);
+    return p;
+}
+/** Non-blocking: the cached value (even stale) or undefined, and a refresh kicked when it is stale. */
+export function cachedBranchRules(wt) {
+    const hit = cache.get(wt);
+    if (!hit || Date.now() - hit.at >= TTL_MS)
+        void branchRules(wt);
+    return hit?.value;
+}
+/** Forget this worktree's reading (a refused push says the rules changed). */
+export function invalidateBranchRules(wt) {
+    cache.delete(wt);
+}
+//# sourceMappingURL=branchrules.js.map

package/packages/host/dist/branchrules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"branchrules.js","sourceRoot":"","sources":["../src/branchrules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,mBAAmB,EAAoB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,CAAC;AAG3B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAiB,CAAC;AACvC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA4C,CAAC;AAErE,KAAK,UAAU,IAAI,CAAC,EAAU;IAC5B,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,MAAM,KAAK,EAAE,KAAK,EAAE,CAAC;IACjC,OAAO,GAAG,CAAC,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACjF,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,WAAW,CAAC,EAAU;IACpC,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1B,IAAI,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,MAAM;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC3E,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjC,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;SACf,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC;SACtB,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACzC,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;SACD,OAAO,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IACpB,OAAO,CAAC,CAAC;AACX,CAAC;AAED,uGAAuG;AACvG,MAAM,UAAU,iBAAiB,CAAC,EAAU;IAC1C,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1B,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,EAAE,IAAI,MAAM;QAAE,KAAK,WAAW,CAAC,EAAE,CAAC,CAAC;IAChE,OAAO,GAAG,EAAE,KAAK,CAAC;AACpB,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,qBAAqB,CAAC,EAAU;IAC9C,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACnB,CAAC"}

package/packages/host/dist/branddirs.d.ts

@@ -0,0 +1,223 @@
+import { type RootPicked, type StateDirSource } from "@waterplane/shared";
+export type { RootPicked };
+/** What `adoptLegacyDir` did, for the boot log and for tests. */
+export interface AdoptResult {
+    /** The directory to use from now on. */
+    dir: string;
+    /**
+     * `current` — the current dir already existed and no legacy one held anything.
+     * `fresh` — neither existed; nothing was created.
+     * `renamed` — a legacy dir was renamed to the current name.
+     * `merged` — both existed; the legacy dir's missing entries were moved in.
+     * `legacy` — a legacy dir exists but could not be moved; use it as it is.
+     */
+    action: "current" | "fresh" | "renamed" | "merged" | "legacy";
+    /** The legacy path that was moved, merged or is in use. */
+    from?: string;
+    /** Entries present under both names, left in the legacy dir untouched. */
+    kept?: string[];
+    /** One sentence for the log, when anything happened or went wrong. */
+    note?: string;
+}
+/**
+ * Make `current` the directory in use, adopting the first of `legacy` that
+ * exists. Idempotent: once the legacy path is a symlink to `current`, every
+ * later call answers `current` and touches nothing. Never throws.
+ */
+export declare function adoptLegacyDir(current: string, legacy: readonly string[]): AdoptResult;
+/**
+ * The fixed per-user dir for the daemon's own config and secrets, independent
+ * of the root: `<PREFIX>CONFIG_DIR` → `$XDG_CONFIG_HOME/<name>` →
+ * `~/.config/<name>`, falling back to a legacy name only when the boot
+ * migration could not move it.
+ */
+export declare function configDir(): string;
+/** `$XDG_DATA_HOME/<name>` or `~/.local/share/<name>` (whisper models, kept clips). */
+export declare function dataDir(): string;
+/** `<root>/<state dir>` — every host store and ledger. After the boot
+ *  migration this is the current name; a legacy dir is answered only when that
+ *  migration could not move it, so the stores still find their data. */
+export declare function rootStateDir(root: string): string;
+/**
+ * `<repo>/<state dir>` for per-repo config (`builds.json`, `capture.json`,
+ * `artifacts.json`, `autopull.json`). The current name when it exists, else a
+ * legacy one that exists, else the current name (created by the first writer).
+ * Never moves anything — see the header.
+ */
+export declare function repoStateDir(repo: string): string;
+/** `<repo>/<shared dir>` — per-repo config meant to be COMMITTED with the checkout
+ *  (`builds.json`), beside the gitignored state dir. A new name with no legacy
+ *  spelling, so there is nothing to resolve: always the current name. */
+export declare function repoSharedDir(repo: string): string;
+/** The legacy state dirs this repo still has as real directories (not our own
+ *  symlink back), newest first — what the setup row reports. */
+export declare function legacyRepoStateDirs(repo: string): string[];
+/** Adopt a repo's legacy state dir into the current name — the setup fix, a
+ *  person's tap. Same rules as the boot move: rename when the current dir is
+ *  absent, merge-without-overwrite when both exist, symlink back. */
+export declare function adoptRepoStateDir(repo: string): AdoptResult;
+/**
+ * The boot move, called by `env.ts` before any `.env` file is read and before
+ * any store opens. Config (unless overridden by env), data, and the root state
+ * dir. Returns what happened; logging is the caller's.
+ */
+export declare function migrateHostDirs(root: string): AdoptResult[];
+/** The code root when nothing names one: `~/dev` (`@waterplane/shared`'s `defaultRootOf`, the ONE spelling). */
+export declare function defaultRoot(home?: string): string;
+/** The usual code folders under a home, in the order they are tried. `~/dev` first: it is the
+ *  fallback too. The last two are what Visual Studio and GitHub Desktop create. */
+export declare const CODE_FOLDERS: readonly string[];
+/** The two disk questions the pick asks, injectable so it is testable with no disk. */
+export interface RootFs {
+    isDir(p: string): boolean;
+    /** One level only: is any child directory of `p` a checkout (has a `.git`)? */
+    hasGitChild(p: string): boolean;
+}
+export declare const realRootFs: RootFs;
+export interface RootChoice {
+    root: string;
+    defaulted: boolean;
+    /** `named` — the knob. `chosen` — the person picked it (`rootchoice.ts`). `found` — an existing
+     *  usual folder. `fallback` — none existed, `~/dev` assumed. */
+    picked: RootPicked;
+    /** The candidates looked at, in order (empty when the knob named the root). */
+    tried: string[];
+}
+/**
+ * The code root with the knob unset: the first usual folder holding a repo, else the first that
+ * exists, else `<home>/dev`. Pure over `fs`; does NOT `resolve()` (a Windows-style home stays
+ * testable anywhere) — `resolveRoot` makes it absolute. Cheap sync checks: this runs at import.
+ */
+export declare function pickCodeRoot(home: string, fs?: RootFs, platform?: NodeJS.Platform): {
+    root: string;
+    picked: "found" | "fallback";
+    tried: string[];
+};
+/** Running under WSL — the kernel says so. Read once; false anywhere `/proc` is not. */
+export declare const RUNNING_IN_WSL: boolean;
+/**
+ * A Windows path (`c:/dev`, `C:\dev`) as WSL mounts it (`/mnt/c/dev`); anything else unchanged.
+ * On Windows the host runs inside WSL from the Windows checkout, so the repo `.env` is shared by
+ * both sides and its `<PREFIX>ROOT` is naturally written the Windows way — which `resolve()` would
+ * otherwise turn into `<cwd>/c:/dev`, a folder nobody has.
+ */
+export declare function wslMountPath(p: string): string;
+/** `<PREFIX>ROOT`, else the folder the person chose (`chosen`, from `rootchoice.ts`), else the first
+ *  usual code folder that exists (`pickCodeRoot`), else `~/dev`; absolute. `defaulted` = nobody named
+ *  or chose it. Under WSL a Windows-style path is its `/mnt/<drive>` mount (`wslMountPath`). */
+export declare function resolveRoot(e?: NodeJS.ProcessEnv, home?: string, fs?: RootFs, chosen?: string, inWsl?: boolean): RootChoice;
+/** Where the daemon's global state belongs — `@waterplane/shared`'s `stateDirPick`, made absolute. Touches no disk. */
+export declare function resolveStateDir(e?: NodeJS.ProcessEnv, home?: string): {
+    dir: string;
+    source: StateDirSource;
+};
+/** The note left at the old place when a symlink could not be. */
+export declare const STATE_MOVED_NOTE = "MOVED.txt";
+/** Written into the old dir just before the move, so it travels with it: names
+ *  where the state came from, so a crash between the rename and the pointer can
+ *  be finished on the next boot — and so a pointer is only ever recreated at a
+ *  place state really was, never invented in a fresh install's code folder. */
+export declare const STATE_MOVED_FROM = "moved-from.json";
+/**
+ * Entries that are not state: our own markers, the desktop's droppings, and an
+ * entry a cross-device merge renamed aside (`<name>.moved-<ts>`, kept, no longer
+ * read). A `.DS_Store` must never make a new dir count as "already holding state".
+ */
+export declare function isStateNoise(name: string): boolean;
+/** A directory (or a link to one) holding anything that is not noise. */
+export declare function hasState(dir: string): boolean;
+/**
+ * The sentence for a state move refused because another host for this root is
+ * still answering (`env.ts`). How to stop it depends on how this host was
+ * installed, and the sentence cannot know which, so it says both: a git checkout
+ * restarts with `npm run restart`; a release install restarts its service
+ * (launchd / systemd, `<slug> service status` says which) or ends the foreground
+ * `<slug> start`.
+ */
+export declare function stateMoveRefusedSentence(from: string, to: string, other: string): string;
+/** The old dir a boot move would act on, or null when there is nothing to move
+ *  (the new dir IS the old place, or no old dir holds state). For `env.ts`' guard. */
+export declare function pendingStateMove(root: string, stateDir: string): string | null;
+/**
+ * The state dir a process that does NOT migrate (a test, a tool, `--doctor`)
+ * should read: the new dir once it holds state, else an old under-root dir
+ * still holding it (the move has not happened yet), else the new dir.
+ */
+export declare function liveStateDir(root: string, stateDir: string): string;
+/** `env.ts` names the daemon's root and its state dir, once, at import. */
+export declare function bindHostStateDir(root: string, dir: string): void;
+/**
+ * THE directory every global store opens under. For the daemon's own root it
+ * is the bound state dir; for any other root — a unit test's mkdtemp, a tool
+ * handed a fixture — it is `<root>/<state dir>` as before, so a test that
+ * builds a store on a scratch root can never reach a person's real
+ * `~/.local/state`.
+ *
+ * Why the root is still an argument (and not a no-argument read of the
+ * binding): dozens of unit tests build stores on their own mkdtemp roots and
+ * read `<root>/<state dir>/x.json` back, each root its own world. A
+ * no-argument resolver would put every one of them in ONE shared dir. The
+ * compare is REALPATH, so `/var/…` vs `/private/var/…` or a symlinked root is
+ * still the daemon's root; the plain-resolve compare is only the fast path.
+ */
+export declare function hostStateDir(root: string): string;
+/** What `migrateStateDir` did. */
+export interface StateMoveResult {
+    /** The directory to bind: the new dir, or the old one when a move failed. */
+    dir: string;
+    /**
+     * `same` — the new dir IS the under-root dir (e2e pins it there); nothing to do.
+     * `fresh` — nothing anywhere. `current` — the new dir holds state, no old one does.
+     * `moved` — renamed. `copied` — cross-device: copied, verified, old renamed aside.
+     * `merged` — both held state: what the new dir lacked was moved in entry by
+     *   entry, never overwriting; `kept` names what was in both and stayed behind.
+     * `failed` — the move did not happen; the old dir is used as it is.
+     */
+    action: "same" | "fresh" | "current" | "moved" | "copied" | "merged" | "failed";
+    from?: string;
+    /** The old dir's new name after a cross-device copy. */
+    aside?: string;
+    /** Entries present in both dirs, left in the old one untouched (the new dir's copy is used). */
+    kept?: string[];
+    note?: string;
+}
+/** The fs calls the move makes, injectable so the cross-device path is testable. */
+export interface StateMoveOps {
+    rename(from: string, to: string): void;
+    copy(from: string, to: string): void;
+}
+/** null when `b` holds exactly what `a` holds (names, kinds, sizes, bytes); else what differs. */
+export declare function treeMismatch(a: string, b: string): string | null;
+/**
+ * The one-time move of `<root>/<state dir>` (or a legacy-named one) to the
+ * global state dir. Daemon boot only (`env.ts`), after `migrateHostDirs`,
+ * before any store opens, and only after `env.ts` has made sure no OTHER
+ * daemon for this root is still running (one writing the old path between the
+ * rename and the pointer would recreate a real dir there: split brain). Never
+ * deletes a file of the person's:
+ *
+ *  - stale `<new>.incoming-<ts>` staging copies of an interrupted cross-device
+ *    move are removed (ours; the old dir is never touched by that);
+ *  - nothing old to move ⇒ if a crash left the old path with no pointer, the
+ *    pointer is put back (only where `moved-from.json` says state came from);
+ *  - the new dir already holds state ⇒ `mergeInto` (above);
+ *  - else rename old → new (an EMPTY or noise-only new dir is set aside first,
+ *    never a full one);
+ *  - EXDEV ⇒ copy to `<new>.incoming-<ts>`, verify byte-for-byte, rename that
+ *    into place, rename the old dir aside to `<old>.moved-<ts>`;
+ *  - then a symlink at the old path (else a dir with `MOVED.txt`);
+ *  - any failure before the new dir is complete ⇒ `failed`, bind the OLD dir:
+ *    `acks.json` is the at-most-once memory, and booting on an empty one would
+ *    let a queued prompt run twice.
+ *
+ * Idempotent: once the old path is our symlink (or a noise-only dir), every
+ * later call answers `current`.
+ */
+export declare function migrateStateDir(root: string, stateDir: string, ops?: StateMoveOps, now?: () => number): StateMoveResult;
+/** For the doctor: where state lives, why, and whether an old under-root dir still holds some. */
+export declare function stateDirReport(root: string, e?: NodeJS.ProcessEnv): {
+    dir: string;
+    source: StateDirSource;
+    live: string;
+    old: string | null;
+};