toolroll 0.9.103 → 0.9.105

package/dist/coding-workspace.d.ts

@@ -1,141 +0,0 @@
-import { type CodingProvider } from './coding-provider.js';
-import { type CodingContext } from './coding-context.js';
-import type { CodingChanges, CodingSession, CodingSnapshot } from './coding-types.js';
-export type CodingActor = {
-    name: string;
-    generation: number;
-};
-export type CodingDelivery = 'rejected' | 'pending' | 'unknown';
-export type CodingExpected = {
-    revision: number;
-    nativeThreadId: string | null;
-    turnId: string | null;
-};
-export type CodingCommandReceipt = {
-    status: 'accepted' | 'pending' | 'rejected' | 'uncertain';
-    sessionId: string | null;
-    message: string | null;
-};
-export declare class CodingActionError extends Error {
-    readonly delivery: CodingDelivery;
-    readonly sessionId?: string | undefined;
-    constructor(message: string, delivery: CodingDelivery, sessionId?: string | undefined);
-}
-export declare class CodingStateConflictError extends CodingActionError {
-    constructor(id: string);
-}
-/** How a session's commands are confined (coding-provider.ts codingSessionPermissions): Toolroll's permission profile as
- * the thread's config overrides, or a refusal. Required: no session starts without its caller saying which. */
-export type CodingPermissions = {
-    config: Record<string, unknown>;
-} | {
-    sandbox: 'workspace-write';
-} | {
-    problem: string;
-};
-type Options = {
-    database: string;
-    worktreeRoot: string;
-    permissions: (input: {
-        repo: string;
-        worktree: string;
-    }) => CodingPermissions | Promise<CodingPermissions>;
-    provider?: () => CodingProvider;
-    admissionPaused?: () => boolean;
-    authorize?: (actor: CodingActor, repo: string) => boolean;
-    context?: (input: {
-        repo: string;
-        actor: string;
-        baseRevision: string;
-        prompt: string;
-    }) => CodingContext;
-};
-/** A native session catalog, separate from the unattended task/proof ledger. */
-export declare class CodingWorkspace {
-    private options;
-    private db;
-    private owner;
-    private provider;
-    private unsubscribe;
-    private operations;
-    private commands;
-    private commandWaiters;
-    private operationWaiters;
-    private loaded;
-    private closed;
-    private closing;
-    private closePromise;
-    private recoveryRequired;
-    private recovering;
-    private persistenceFailed;
-    private pendingItems;
-    private flushTimer;
-    constructor(options: Options);
-    private authorize;
-    private read;
-    /** Preserve legacy reads, but never mutate an unidentified row or save an unreadable record's error projection. */
-    private catalogRow;
-    private admit;
-    private releaseOperation;
-    list(actor: CodingActor): CodingSession[];
-    /** Inspect a fixed metadata window before loading admitted documents.
-     * A filtered window can be short without proving the entire list empty. */
-    listBounded(actor: CodingActor, options: {
-        limit: number;
-        repo?: string;
-        authorized: (repo: string) => boolean;
-    }): {
-        sessions: CodingSession[];
-        truncated: boolean;
-    };
-    get(id: string, actor: CodingActor): CodingSession;
-    snapshot(id: string, actor: CodingActor): CodingSnapshot;
-    /** Bounded transport read: query only the recent window plus one row
-     * for omission detection. The browser's full snapshot remains unchanged. */
-    snapshotBounded(id: string, actor: CodingActor): CodingSnapshot & {
-        truncated: boolean;
-    };
-    revision(id: string, actor: CodingActor): number;
-    assertExpected(id: string, actor: CodingActor, expected?: CodingExpected): void;
-    /** Persist acceptance before calling the native owner. Repeating a key only
-     * reads its receipt; it never repeats a mutation, including after restart. */
-    command(actor: CodingActor, key: string, request: string, check: () => void, perform: () => Promise<string>): Promise<CodingCommandReceipt>;
-    private save;
-    private byThread;
-    private putItem;
-    private flush;
-    private item;
-    /** The thread's confinement, made right before each start or resume from the plane's own records. */
-    private permissionsFor;
-    private native;
-    private request;
-    private event;
-    private git;
-    start(actor: CodingActor, input: {
-        repo: string;
-        title: string;
-        model: string | null;
-        prompt: string;
-        requestId: string;
-    }): Promise<CodingSession>;
-    private validateMessage;
-    private receiptError;
-    private load;
-    private importHistory;
-    private verifyWorktree;
-    private priorProcessesGone;
-    /** Reconnect the exact native conversation. An absent receipt never proves
-     * non-delivery, so an unmatched message requires an explicit review action. */
-    recover(id: string, actor: CodingActor, expected?: CodingExpected): Promise<void>;
-    continueSaved(id: string, actor: CodingActor): Promise<void>;
-    send(id: string, actor: CodingActor, prompt: string, requestId: string, expected?: CodingExpected): Promise<void>;
-    private sendMessage;
-    resume(id: string, actor: CodingActor, expected?: CodingExpected): Promise<void>;
-    stop(id: string, actor: CodingActor, expected?: CodingExpected): Promise<void>;
-    answer(id: string, actor: CodingActor, token: string, decision: string, answers: unknown): void;
-    private validateAnswers;
-    changes(id: string, actor: CodingActor): Promise<CodingChanges>;
-    close(): Promise<void>;
-    private closeOnce;
-}
-export {};

package/dist/commit-extract.d.ts

@@ -1,135 +0,0 @@
-export type Extraction = {
-    ok: true;
-    files: number;
-} | {
-    ok: false;
-    message: string;
-};
-/** What one extraction may hold, all checked before anything is written: the bytes written (every path, a blob shared
- * by many paths counted once per path), the files, the tree entries walked and how deep the trees nest. */
-export type ExtractionLimits = {
-    bytes: number;
-    files: number;
-    entries: number;
-    depth: number;
-};
-export declare const EXTRACTION_LIMITS: ExtractionLimits;
-/** A tree path that stays where it says: relative, no empty, `.` or `..` part, no backslash or control character. */
-export declare function normalizedTreePath(path: string): boolean;
-/** The object id Git gives `<type> <size>\0<bytes>` in this repository's object format. */
-export declare const objectIdOf: (format: "sha1" | "sha256", type: string, bytes: Buffer) => string;
-type TreeEntry = {
-    mode: string;
-    name: string;
-    id: string;
-};
-/** A tree object's entries, parsed from its verified bytes: `<mode> <name>\0<raw id>` each. Null when malformed. */
-export declare function parseTree(bytes: Buffer, idBytes: number): TreeEntry[] | null;
-/**
- * Why a commit's file paths can't all be written as separate regular files, or null: a `.git` part, a path twice, two
- * paths that are one on a case-insensitive or Unicode-normalizing file system (macOS), or a path that is both a file
- * and a folder. scripts/deploy-git.mjs writtenPathsProblem keeps the same rules (held equal by test).
- */
-export declare function writtenPathsProblem(paths: readonly string[]): string | null;
-/** Write commit `sha` of the repository whose Git directory is `gitDir` (a realpath Toolroll took from its own
- * records) into `dest`, an empty folder this process made. Every object on the way — the commit, each tree, each
- * blob — is hashed here and must be the id that names it: Git's own answer about an id is never taken on trust, so a
- * corrupted or replaced object in a store a build could write to refuses the extraction. */
-export declare function extractCommit(gitDir: string, sha: string, dest: string, limits?: ExtractionLimits): Extraction;
-/** A commit read from its verified bytes: its tree and its parents, in order. */
-export type VerifiedCommit = {
-    id: string;
-    tree: string;
-    parents: string[];
-    message: string;
-};
-/** One entry of a verified tree, at its full path: a file (100644, 100755), a symlink (120000) or a submodule (160000). */
-export type VerifiedEntry = {
-    path: string;
-    mode: string;
-    id: string;
-};
-/** One path that differs between two verified trees, with its line counts when both sides are text. */
-export type TreeChange = {
-    path: string;
-    kind: "added" | "modified" | "deleted";
-    before: VerifiedEntry | null;
-    after: VerifiedEntry | null;
-    added: number;
-    deleted: number;
-    binary: boolean;
-};
-export type Verified<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    message: string;
-};
-/** Which Git runs and with what environment: the release path's fixed absolute Git and its own environment, or by
- * default the checkout Git environment's. The hardening settings are added over either. */
-export type GitRunner = {
-    git?: string;
-    env?: NodeJS.ProcessEnv;
-    /** Each git call's time limit (default five minutes). */
-    timeoutMs?: number;
-    /** An absolute wall-clock deadline (ms): every git subprocess, setup included, gets only what is left of it, and a
-     * read past it fails (teardown-git.ts viewedGitSync). */
-    deadline?: number;
-};
-/** One commit, hashed here and parsed from its own bytes. */
-export declare function readVerifiedCommit(gitDir: string, sha: string): Verified<VerifiedCommit>;
-/**
- * The commits from `from` back to `until` along first parents, newest first, `until` itself left out. Refuses when
- * `until` isn't reached within `max` commits (it isn't an ancestor, or too much lies between), and hands back each
- * commit's full parent list so a caller can refuse merges.
- */
-export declare function verifiedFirstParentWalk(gitDir: string, from: string, until: string, max?: number): Verified<VerifiedCommit[]>;
-/** Every entry of a verified tree at its full path, symlinks and submodules included (a caller decides on them). An
- * unnormalized path, or one a tree lists twice, refuses the whole read. */
-export declare function verifiedTreeEntries(gitDir: string, tree: string, limits?: ExtractionLimits): Verified<VerifiedEntry[]>;
-/** Whether bytes look binary: a NUL in the first 8000 bytes, as Git judges. */
-export declare const looksBinary: (bytes: Buffer) => boolean;
-/** The lines added and deleted from `before` to `after`, by the shortest edit (Myers): each counted once, stopped at
- * `cap` total edits (the counts then add up to more than `cap`, which every limit here refuses). */
-export declare function lineChanges(before: Buffer, after: Buffer, cap?: number): {
-    added: number;
-    deleted: number;
-};
-/**
- * What differs between two verified trees, path by path (no rename pairing: a moved file is a deletion and an
- * addition). Text files get their added and deleted lines; a binary side, a symlink or a submodule is marked so a caller
- * can refuse it.
- */
-export declare function verifiedTreeDiff(gitDir: string, beforeTree: string, afterTree: string): Verified<TreeChange[]>;
-/** The ids of verified blobs at these paths of a tree (absent paths left out): a digest's inputs, read without
- * running anything. */
-export declare function verifiedBlobs(gitDir: string, tree: string, paths: readonly string[]): Verified<Map<string, {
-    id: string;
-    bytes: Buffer;
-}>>;
-/**
- * The commits reachable from `to` and not from `from`, as Git lists them (newest first), each read from its own verified
- * bytes: what a release card says changed (release-card.ts). Git only names them. Each is hashed here and its parents
- * checked against Git's listing; every commit the range stops at (a parent outside it) must be reached from `from`
- * through verified parents within `reach` commits, so history a build rewrote around the objects can't shorten the
- * list. A shallow boundary, grafts or replacement refs refuse (verifiedReader), as does a range longer than `max`.
- */
-export declare function verifiedRange(gitDir: string, from: string, to: string, options?: GitRunner & {
-    max?: number;
-    reach?: number;
-}): Verified<VerifiedCommit[]>;
-/**
- * Whether `until` lies on `from`'s first-parent history, within a deadline (nightly-github.ts): "yes" when the walk
- * reaches it; "no" only when it is PROVEN not to — `until` is itself a readable, verified commit and every commit from
- * `from` back to the root was read and verified without meeting it; "unknown" for anything less certain (an object
- * missing or unreadable, `max` commits walked, the deadline reached). Every git call is bounded by what is left of
- * the deadline, at most `callMs`.
- */
-export declare function verifiedFirstParentAncestry(gitDir: string, from: string, until: string, options: {
-    deadline: number;
-    now?: () => number;
-    max?: number;
-    callMs?: number;
-}): "yes" | "no" | "unknown";
-export {};

package/dist/connect-cli.d.ts

@@ -1,34 +0,0 @@
-export type ConnectOptions = {
-    fetch?: typeof fetch;
-    env?: NodeJS.ProcessEnv;
-    home?: string;
-    profileFile?: string;
-    readStdin?: () => Promise<string>;
-    stderr?: (line: string) => void;
-    signal?: AbortSignal;
-};
-export declare class UsageError extends Error {
-}
-/** Credentials are never sent to a URL with embedded authority, an API path, query, fragment or an insecure remote
- * host. Fetch cannot follow redirects. */
-export declare function serviceOrigin(raw: string): string;
-type Profile = {
-    origin: string;
-    account: string;
-    token: string;
-};
-/** An API token (so_…) is sent bare; an older saved sign-in keeps its account:secret form. */
-export declare const bearerOf: (profile: Profile) => string;
-/** The saved central profile remote commands use: the named one (or the active one), and whether it holds an API token.
- * null when nothing is saved. Reads only the private profile file — never a local login or the database. */
-export declare function hasCentralProfile(options: ConnectOptions): boolean;
-export declare function centralProfile(options: ConnectOptions, name?: string): {
-    name: string;
-    origin: string;
-    account: string;
-    token: string;
-    apiToken: boolean;
-} | null;
-/** `toolroll connect …`; null for every other command. Nothing here opens a database. */
-export declare function maybeRunConnectCommand(argv: readonly string[], write: (line: string) => void, options?: ConnectOptions): Promise<number | null>;
-export {};

package/dist/console-chrome.d.ts

@@ -1,41 +0,0 @@
-import { type BrowserProjectState } from "./browser-workspace.js";
-import type { Store } from "./store.js";
-import { type WorkIndexOptions } from "./work-index.js";
-import type { WorkSummaryAccess } from "./work-summary.js";
-import type { WorkspaceRevision } from "./workspace-revision.js";
-export type SidebarProject = {
-    path: string;
-    name: string;
-};
-/** The sidebar's projects with their states (agent-state.ts) for one reader: the page's first read and the summary
- * room's snapshots are this one function, so the two never disagree. Never marks anything seen. Work with no project
- * yet is its own entry when this reader may see it and something counts there. */
-export declare function projectSummaryOf(store: Store, now: Date, access: WorkSummaryAccess, actor: string, projects: readonly SidebarProject[], evidenceRoot: string | undefined): BrowserProjectState[];
-/** One access, canonically and in full (every field it has, so a field added later keys too): the same reader and
- * scope always spell the same key, whatever order its projects came in. */
-export declare function accessKey(access: WorkSummaryAccess): string;
-/**
- * Values read from the database, each kept while the workspace revision (workspace-revision.ts: every meaningful
- * commit, from any process, moves it) is the one it was read at, and never past the revision's own clock boundary
- * (a lease or liveness window ending) or `maxAgeMs`, whichever is first — time alone (an agent going quiet) shows
- * within that bound. A value is stored under the revision read before it was computed, so a commit that lands while it
- * is computed only makes it miss sooner. Callers must not change a value they were handed.
- */
-export declare class RevisionCache {
-    #private;
-    constructor(revision: WorkspaceRevision, clock: () => Date, options?: {
-        maxEntries?: number;
-        maxAgeMs?: number;
-    });
-    /** The value for `key` at the current revision, or undefined. */
-    peek<T>(key: string): T | undefined;
-    /** The cached value, or `compute()` now (stored for the next reader). Errors are never cached. */
-    read<T>(key: string, compute: () => T): T;
-    /** The cached value, or one read asynchronously (a read worker) and stored. A failure answers undefined and leaves
-     * the key empty, so the request thread computes it as before. */
-    fill<T>(key: string, compute: () => Promise<T>): Promise<T | undefined>;
-}
-/** The keys the console's chrome reads are kept under (serve.ts and its read-worker prefetch spell them the same). */
-export declare const countsKey: (access: WorkSummaryAccess) => string;
-export declare const summaryKey: (actor: string, access: WorkSummaryAccess, projects: readonly SidebarProject[]) => string;
-export declare const indexKey: (access: WorkSummaryAccess, options: WorkIndexOptions) => string;

package/dist/console-instance.d.ts

@@ -1,157 +0,0 @@
-import { type Socket } from "node:net";
-import type { Store } from "./store.js";
-export declare const CONSOLE_INSTANCE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS console_instance (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  secret     TEXT NOT NULL,\n  pid        INTEGER NOT NULL,\n  port       INTEGER NOT NULL,\n  build      TEXT NOT NULL,\n  socket     TEXT NOT NULL,\n  started_at TEXT NOT NULL\n);";
-/**
- * The socket's own owner-only directory beside the database's REAL file (a symlinked database resolves to the one
- * folder every spelling shares). Each console start binds a socket of its own, under a fresh random name recorded
- * with its secret: no console ever needs to remove — or can remove — another console's socket.
- */
-/** Toolroll's own name, so it never collides with a project or worktree that happens to sit beside the database. */
-export declare const INSTANCE_DIR = ".toolroll-run";
-export declare function instanceRunDir(databaseFile: string): string;
-/** The console's own answer to a challenge over HTTP (an edge route, no sign-in: it reveals nothing). */
-export declare const INSTANCE_PATH = "/__instance";
-export type InstanceRecord = {
-    secret: string;
-    pid: number;
-    port: number;
-    build: string;
-    socket: string;
-    startedAt: string;
-};
-export type HelloFacts = {
-    pid: number;
-    build: string;
-    database: string;
-    port: number;
-};
-/** The record as stored: none, one this build can't read (never taken for none), or the record. */
-export declare function readInstanceState(store: Store): {
-    state: "none";
-} | {
-    state: "invalid";
-} | {
-    state: "ok";
-    record: InstanceRecord;
-};
-export declare function readInstance(store: Store): InstanceRecord | null;
-/** v147: the key epoch the running console recorded with its claim (easy-start C2), or null: none recorded. */
-export declare function instanceKeyEpoch(store: Store): string | null;
-/** A stopping console forgets itself — only its own record, never a newer start's. */
-export declare function clearInstance(store: Store, secret: string): void;
-export declare const socketProof: (secret: string, challenge: string) => string;
-export declare const httpProof: (secret: string, challenge: string, address: string, port: number) => string;
-/** The HTTP answer: bound to the address and port THIS connection was received on, as the console saw them. */
-export declare function instanceHttpAnswer(secret: string, challenge: string | null, local: {
-    address: string | undefined;
-    port: number | undefined;
-}): {
-    status: number;
-    body: string;
-};
-/**
- * The run directory must be private to this user: a real, canonical directory owned by this user with no access for
- * anyone else (0700), inside a canonical directory owned by this user that nobody else can write. Checked before any
- * change is made, and before connecting or binding.
- */
-export declare function runDirProblem(dir: string, uid?: number, mustExist?: boolean): string | null;
-/** A socket path that binds exactly (no truncation), named as a console names its own. */
-export declare function socketPathProblem(path: string): string | null;
-/**
- * `up`: the run directory, made 0700 if it isn't there. An existing one is used only as it is (never chmodded): one
- * that isn't private to this user is refused. Everything is checked before anything is created.
- */
-export declare function prepareRunDir(dir: string, uid?: number): string | null;
-/** Ask a socket one question; null when nobody is listening (or it said nothing usable in time). */
-export declare function askSocket(socketPath: string, request: object, timeoutMs?: number, connect?: (path: string) => Socket): Promise<{
-    answer: Record<string, unknown>;
-} | {
-    none: "no-listener" | "no-answer";
-}>;
-/**
- * The console's discovery socket: one line in, one line out. `hello` (with a challenge) answers the public facts and
- * the socket proof; every other verb is refused. It reads nothing else and changes nothing. Bound under a fresh name
- * no other process has, so it never clears or replaces anything; its own listener removes it on close.
- *
- * Easy start D: the one other verb is `link`, and only when the console passes `link`. The console answers with a fresh
- * challenge of its own; the asker must answer it with HMAC(secret, "link:" + challenge) — the secret is in the database
- * (behind the agent fence), so only a process that read it can — and then gets one local owner's one-time sign-in path.
- * Each challenge is spent by the first answer on its own connection, right or wrong; the "link:" domain keeps a hello or
- * HTTP proof from ever counting here. The request names no account: what the link signs in as is the console's own
- * decision (`link` returns null unless local mode is on).
- */
-export declare function openInstanceSocket(databaseFile: string, facts: HelloFacts, secret: () => string | null, link?: () => string | null): Promise<{
-    ok: true;
-    name: string;
-    close: () => void;
-} | {
-    ok: false;
-    problem: string;
-}>;
-/** The `link` verb's answer to the console's challenge: bound to this verb, so no other proof ever counts for it. */
-export declare const linkProof: (secret: string, challenge: string) => string;
-/**
- * Ask the console on `socketPath` for a local owner's one-time sign-in path with the record's secret: `link`, the
- * console's challenge, then the proof. Null when it gives none (local mode off, a wrong or late answer, anything
- * malformed). The caller proves the console live first (proveLiveConsole) and opens the path on its proved address.
- */
-export declare function askLink(socketPath: string, secret: string, timeoutMs?: number, connect?: (path: string) => Socket): Promise<string | null>;
-/**
- * A local owner's one-time sign-in address from this installation's live console (easy start D, `toolroll open`): the
- * console is proved live on both channels first, then asked over its socket with the record's secret. The address is
- * always the proved console's own; null when there is no proved console or it gives no link.
- */
-export declare function requestLocalLink(databaseFile: string, store: Store, build: string, seams?: AttachSeams & {
-    askLink?: typeof askLink;
-}): Promise<{
-    ok: true;
-    url: string;
-    console: string;
-} | {
-    ok: false;
-    message: string;
-}>;
-/**
- * A record's console: "live" (its socket answers a fresh challenge with the record's secret and pid), "gone" (nobody
- * is listening on its socket, or the socket isn't there), or "unknown" (anything else: slow, malformed, a wrong proof).
- * Only "gone" lets another start take the record.
- */
-export declare function recordLiveness(databaseFile: string, record: InstanceRecord, ask?: typeof askSocket): Promise<"live" | "gone" | "unknown">;
-/**
- * `up` claims the record for its socket — unless a live console already holds it (another start on the same
- * database, by any spelling of its path). The write is a compare-and-set on the record it checked: two starts racing
- * can't both win. Null: not claimed (this console runs, but `toolroll` won't attach to it).
- */
-export declare function claimInstance(store: Store, databaseFile: string, facts: {
-    pid: number;
-    port: number;
-    build: string;
-    socket: string;
-    keyEpoch?: string;
-}, now: Date, liveness?: (record: InstanceRecord) => Promise<"live" | "gone" | "unknown">): Promise<string | null>;
-export type AttachProof = {
-    ok: true;
-    url: string;
-    port: number;
-    pid: number;
-    build: string;
-} | {
-    ok: false;
-    state: "none";
-    message: string;
-} | {
-    ok: false;
-    state: "refused";
-    message: string;
-};
-export type AttachSeams = {
-    ask?: typeof askSocket;
-    fetch?: typeof fetch;
-    challenge?: () => string;
-};
-/**
- * Prove the console this installation's database names is live, on both channels, before anything is shown or
- * opened. "none": no console runs (no record, or nobody on the socket); "refused": something answers that can't
- * prove it is the console (or a different build) — the person restarts it.
- */
-export declare function proveLiveConsole(databaseFile: string, store: Store, build: string, seams?: AttachSeams): Promise<AttachProof>;

package/dist/container-state.d.ts

@@ -1,5 +0,0 @@
-export type ContainerEmptiness = "empty" | "populated" | "unknown";
-export declare function captureCgroupIdentity(container: string): string;
-export declare function parseCgroupEvents(events: string): ContainerEmptiness;
-export declare function cgroupEmptiness(container: string, identity: string | null | undefined): ContainerEmptiness;
-export declare function containerEmptiness(backend: string, container: string, platform?: NodeJS.Platform, identity?: string | null): ContainerEmptiness;