toolroll 0.9.103 → 0.9.105

package/dist/checkout-cleanup.d.ts

@@ -1,157 +0,0 @@
-import { type CheckoutCleanup, type CheckoutIdle } from "./storage.js";
-import { type Store, type WorktreeRow } from "./store.js";
-import { type WorktreePool } from "./worktree.js";
-/** A release candidate's checkout holds the build a deploy installs: the newest complete one waits at most a week for it. */
-export declare const CANDIDATE_KEEP_MS: number;
-/** The worker's pass removes at most this many; a clean-up by hand has no cap. */
-export declare const AUTO_MAX = 20;
-export type KeepWhy = "in use" | "task not finished" | "waiting for review" | "release candidate" | "has changes" | "has commits" | "not on its branch" | "unreadable" | "git refused" | "not due yet" | "cleanup is off" | "no task"
-/** A clean-up by hand leaves it; the next sweep takes it. */
- | "idle";
-export type CheckoutItem = {
-    path: string;
-    repo: string;
-    branch: string;
-    taskId: string | null;
-    bytes: number;
-    releasedAt: string | null;
-    /** null: it goes. */
-    why: KeepWhy | null;
-    /** With "not due yet" or "release candidate": when it may go. */
-    dueAt?: string;
-    /** Past the idle limit: when its task last saw any activity. */
-    idleSince?: string;
-};
-export type CheckoutPlan = {
-    at: string;
-    cleanup: CheckoutCleanup;
-    idle: CheckoutIdle;
-    manual: boolean;
-    go: CheckoutItem[];
-    stay: CheckoutItem[];
-    /** Every checkout on disk. */
-    count: number;
-    totalBytes: number;
-    freeBytes: number;
-    waitingReview: number;
-    withChanges: number;
-    /** What the next sweep's idle cleanup takes. */
-    idleCount: number;
-    idleBytes: number;
-};
-type Status = {
-    keep: KeepWhy | null;
-    taskId: string;
-    finishedAt: string | null;
-    dueAt?: string;
-    atOnce?: boolean;
-};
-/** The release a deploy installed last (staged-upgrades/<stage>/deployment.json at phase "deployed"): its commit and
- * builder run. A deploy runs from the gate's checkout, so that checkout stays while it is what runs. */
-export type Deployed = {
-    head: string | null;
-    run: number | null;
-    at?: string | null;
-};
-export declare function deployedRelease(stateDir: string | null): Deployed | null;
-/**
- * Which release a gate belongs to: a failed gate is re-filed as the same name plus a letter (`release-x`, then
- * `release-xb`, `release-xc` …), so a gate whose name is another gate's in the same project plus one letter is that
- * release's.
- */
-export declare function releaseOf(id: string, gates: ReadonlySet<string>): string;
-/** Where every task stands for cleanup, by task_ref id and by each branch it or its runs used. */
-export declare function taskStatuses(store: Store, now: Date, deployed?: Deployed | null): {
-    byRef: Map<number, Status>;
-    byBranch: Map<string, Status>;
-};
-/** The let-go checkouts whose task is complete or cancelled, and when it finished. Not a release candidate's that
- * stays: a deploy runs from it. */
-export declare function finishedCheckouts(store: Store, now: Date, repo?: string): {
-    row: WorktreeRow;
-    taskId: string | null;
-    finishedAt: string;
-}[];
-/** The newest activity of a task's whole family, and whether something rules idle cleanup out for it. */
-type IdleFact = {
-    activeAt: string;
-    blocked: boolean;
-};
-export type IdleFacts = {
-    byRef: Map<number, IdleFact>;
-    byBranch: Map<string, IdleFact>;
-};
-/**
- * When each task family last saw a run, a person's act or a lease, read in one pass. A revision builds on what it
- * revises, so a family is idle together. `blocked`: an open run, an unreleased claim, a release gate, or a task only an
- * external tracker knows, in the family.
- */
-export declare function idleFacts(store: Store): IdleFacts;
-/** Why a checkout stays as a clean-up by hand reads it (in use, or its task not done with it), before its files; null: it may go. */
-export declare function checkoutKeepWhy(pool: WorktreePool, row: WorktreeRow, statuses: ReturnType<typeof taskStatuses>, now: Date): KeepWhy | null;
-/**
- * What a clean-up would remove now, how much space it would free, and what stays and why. `manual` is a clean-up by
- * hand (it doesn't wait for the setting); otherwise it is the worker's pass under the setting. Reads only.
- */
-export declare function checkoutPlan(store: Store, pool: WorktreePool, now: Date, options: {
-    manual: boolean;
-    repo?: string;
-}): Promise<CheckoutPlan>;
-/** Names exactly what a preview would remove, so a confirmation removes that and nothing else. */
-export declare function previewDigest(plan: Pick<CheckoutPlan, "go">): string;
-export type CleanResult = {
-    removed: CheckoutItem[];
-    kept: {
-        path: string;
-        why: KeepWhy;
-    }[];
-    freed: number;
-    /** The worker's pass stopped at AUTO_MAX: more may be due, and the sweep comes back an hour later. */
-    more?: boolean;
-};
-/**
- * Remove what may go: the worker's pass (`manual` false: under the setting, at most AUTO_MAX, one repository) or a
- * clean-up by hand (no cap, every repository). Each checkout is asked again right before it goes; each removal is in
- * the ledger. Idle checkouts go only with `idle`, the storage sweep's child (never the service's own pass, whose git
- * and du must not hold up its heartbeats): each is judged again from a fresh read of its task and its family's
- * activity, `spare` (live work), the OS's list of what runs in the folder, and `proveRecreatable`, inside its reservation.
- */
-export declare function cleanCheckouts(store: Store, pool: WorktreePool, now: () => Date, options: {
-    manual: boolean;
-    actor: string;
-    repo?: string;
-    only?: ReadonlySet<string>;
-    spare?: (path: string) => boolean;
-    /** The storage sweep's child only: idle checkouts go too. `occupied` asks the OS whether any process works in a folder. */
-    idle?: {
-        occupied: (path: string) => boolean;
-    };
-}): Promise<CleanResult>;
-export type SlimResult = {
-    slimmed: {
-        path: string;
-        taskId: string | null;
-        dropped: string[];
-        bytes: number;
-    }[];
-};
-/**
- * A kept checkout (its result waiting for review, or with changes) drops its dependencies and build output once its
- * run has ended; the next run's setup restores them (node_modules only goes where the project has a setup to restore
- * it). Never one in use or a release candidate (a deploy installs from it). Each in the ledger.
- */
-export declare function slimKeptCheckouts(store: Store, pool: WorktreePool, now: () => Date, options: {
-    actor: string;
-    repo?: string;
-}): Promise<SlimResult>;
-/** Throw away a checkout kept for its changes, on purpose; its branch stays. In the ledger. */
-export declare function discardCheckout(store: Store, pool: WorktreePool, path: string, now: Date, actor: string): Promise<{
-    ok: true;
-    bytes: number;
-} | {
-    ok: false;
-    message: string;
-}>;
-/** "Waiting for review", "Has changes" … as a sentence fragment for a person. */
-export declare function whyWords(item: Pick<CheckoutItem, "why" | "dueAt" | "idleSince">): string;
-export {};

package/dist/checkout-proof.d.ts

@@ -1,28 +0,0 @@
-import type { Store } from "./store.js";
-export type CheckoutProof = {
-    ok: true;
-    path: string;
-} | {
-    ok: false;
-    reason: string;
-};
-export declare function localCheckoutOf(store: Store, runId: number, local: {
-    runner?: string | undefined;
-    poolRoot?: string | undefined;
-}, now: Date): CheckoutProof;
-/** How Finder is asked: the system's own `open` by absolute path (never found through PATH), from the root directory,
- * with a minimal environment, one argument. True only when it answered success before the deadline: at the deadline
- * the answer is "not shown", the child is killed outright, and anything it says later is ignored. */
-export type RevealExec = (file: string, args: readonly string[], options: {
-    cwd: string;
-    env: Record<string, string>;
-}, done: (error: Error | null) => void) => {
-    kill: (signal: NodeJS.Signals) => unknown;
-} | undefined;
-export declare const REVEAL_COMMAND = "/usr/bin/open";
-export declare const REVEAL_DEADLINE_MS = 10000;
-export declare function revealInFinder(path: string, run?: RevealExec, deadlineMs?: number, clock?: () => number): Promise<boolean>;
-/** Whether this console can ask Finder at all (a Mac, or a test's own revealer). */
-export declare const canReveal: (injected: boolean) => boolean;
-/** The command to paste into a terminal: `cd` to the path as one single-quoted shell word (a quote inside escaped). */
-export declare function cdCommandOf(path: string): string;

package/dist/child-database.d.ts

@@ -1,12 +0,0 @@
-import type { ExecResult, RunOptions } from "./exec.js";
-export declare const CHILD_DATABASE_ENV = "TOOLROLL_DB";
-/** Both names, so neither an ambient TOOLROLL_DB nor an older tool reading STANDING_ORDERS_DB reaches the live store. */
-export declare function childDatabaseEnv(file: string): Record<string, string>;
-/** Self-hosted agents and project commands must not open their supervisor's store. */
-export declare function isolatedChildDatabase(label: string): {
-    dir: string;
-    file: string;
-};
-export declare function removeChildDatabase(dir: string): void;
-/** Override after environment filtering, even if an ambient override names the live DB. */
-export declare function runWithIsolatedDatabase(runner: (file: string, args: readonly string[], options: RunOptions) => Promise<ExecResult>, file: string, args: readonly string[], options: RunOptions): Promise<ExecResult>;