@gaunt-sloth/core 2.0.0-alpha.8 → 2.0.0-beta.0

package/dist/core/approvals/grants.js

@@ -0,0 +1,469 @@
+/**
+ * @module core/approvals/grants
+ *
+ * EXT-71 (spec §3, §3.1, §6) — **what the escalation menu remembers**, in the one entry grammar.
+ *
+ * A grant is an {@link ApprovalEntry} plus the metadata §3 requires a list to be able to show:
+ * **when** it was made and **at what scope**. Two stores hold them — an in-memory
+ * {@link ApprovalGrantStore} for the life of one runner instance, and a
+ * {@link PersistedApprovalGrants} backed by the project's JSON file for `always` — and neither
+ * decides anything. They hold entries; `core/approvals/matcher.ts` compares them. There is exactly
+ * one comparison engine and it is not here.
+ *
+ * ## The menu never widens
+ *
+ * §3.1/§6: *always approve* and *always reject* write **the command the human saw**, as a
+ * fully-explicit `exact` entry ({@link shellGrantEntry}) — never a prefix, never a pattern, never a
+ * generalization. Breadth is always something a human typed into a config file. The other half of
+ * that rule is equally load-bearing: **there is no second-guessing layer on top of a match**, so a
+ * user's own entry naming a flag someone once thought dangerous (`curl -o out.txt`) is honored like
+ * any other. Overruling it would be a control offered and then refused.
+ *
+ * **A tool grant records identity, not arguments** ({@link toolGrantEntry}, §4.7.4) — the tool, its
+ * server where it has one, and the host where the call carries one. That is knowingly broader than
+ * the shell's exact-command grant, because a repeat shell command usually is identical and a repeat
+ * tool call usually is not; the host is the bound that keeps "broader" from meaning "every
+ * counterparty, forever". A tool grant additionally carries the effective annotation set it was made
+ * under, and weakening that set invalidates it ({@link annotationWeakenings}).
+ *
+ * The one thing {@link shellGrantEntry} does to the command is {@link normalizeCommand} it, because
+ * that is the form every comparison runs over (§3.1: *"spacing and quoting spellings of one command
+ * are therefore one command"*). Storing the raw string instead would mean the most ordinary grant
+ * imaginable — `always approve` on the `"npm test\n"` a tool argument routinely carries — never
+ * matching the command that produced it, which is the same "offered and then refused" failure with
+ * the evidence hidden.
+ *
+ * ## The persisted file
+ *
+ * ```jsonc
+ * {
+ *   "version": 2,
+ *   "grants": [
+ *     { "entry": { "type": "shell", "matcher": "exact", "pattern": "npm test" },
+ *       "grantedAt": "2026-08-02T09:15:00.000Z", "scope": "always" },
+ *     { "entry": { "type": "mcpTool", "server": "fetcher", "matcher": "exact",
+ *                  "pattern": "fetch_url", "host": "docs.internal.example" },
+ *       "grantedAt": "2026-08-02T09:16:00.000Z", "scope": "always",
+ *       "annotations": { "readOnlyHint": true, "destructiveHint": false,
+ *                        "idempotentHint": true, "openWorldHint": true } }
+ *   ]
+ * }
+ * ```
+ *
+ * `annotations` is absent on a `shell` grant and on any grant written before it existed; a grant
+ * without one simply has nothing to invalidate it and stands as it did.
+ *
+ * Reads stay fail-closed-on-auto-approval: a missing, unreadable, malformed or partly-malformed
+ * file yields fewer grants (at worst none) rather than throwing, because an empty allow-list only
+ * ever means *prompt*.
+ */
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { approvalEntrySchema, renderApprovalEntryObject } from '#src/config/schema.js';
+import { TOOL_ANNOTATION_HINTS } from '#src/config/shell-policy.js';
+import { describeApprovalEntry, MCP_FAIL_CLOSED_ANNOTATIONS, } from '#src/core/approvals/matcher.js';
+import { UNRESOLVED_MCP_SERVER } from '#src/core/approvals/mcpSubjects.js';
+import { normalizeCommand } from '#src/core/shell/normalize.js';
+import { StatusLevel } from '#src/core/types.js';
+/** The version this module writes. */
+const PERSISTED_VERSION = 2;
+/**
+ * §3.1/§6 — the entry the escalation menu writes for a shell command: **that command, and only
+ * that command**.
+ *
+ * The single place a menu grant's entry is built, so the line the prompt shows the human ("this is
+ * what will be stored") and the line that lands in the store cannot drift apart.
+ */
+export function shellGrantEntry(command) {
+    return { type: 'shell', matcher: 'exact', pattern: normalizeCommand(command) };
+}
+/**
+ * §4.7.4/§6 — the entry the escalation menu writes for a **tool** call: the tool's identity, plus
+ * the host where the call carries one.
+ *
+ * The counterpart of {@link shellGrantEntry} and the single place a tool grant's entry is built, so
+ * the line the prompt shows the human and the line that lands in the store cannot drift apart.
+ *
+ * **Identity, never arguments.** A grant recording a full argument signature would never match a
+ * second time — not a narrower grant, a useless one. That is knowingly broader than the shell's
+ * exact-command grant, with one bound: on the shell path §4.6's escape carries the host inside the
+ * command string, so it is host-scoped by construction, while a tool-identity-only grant on a fetch
+ * tool would be every host, forever.
+ *
+ * `server` on an `mcpTool` grant is the user's own `mcpServers` config key (§4.7.5). Nothing a
+ * server declares about its own name participates, and a grant for one server's tool can never be
+ * claimed by another server's same-named tool because the other server sits under a different key.
+ *
+ * **Returns `null` for a call whose server could not be resolved.** {@link UNRESOLVED_MCP_SERVER}
+ * is the empty string, which `server` (`z.string().min(1)`) cannot hold: such an entry would be
+ * written to the file and then silently dropped by the grammar's own validator on the next read, so
+ * the human would be told their approval was remembered when it was not. A call nobody can attribute
+ * to a server is not one anything can remember.
+ */
+export function toolGrantEntry(subject) {
+    const host = subject.host !== undefined && subject.host.length > 0 ? subject.host : undefined;
+    if (subject.kind === 'mcpTool') {
+        if (subject.server === UNRESOLVED_MCP_SERVER)
+            return null;
+        return {
+            type: 'mcpTool',
+            server: subject.server,
+            matcher: 'exact',
+            pattern: subject.name,
+            ...(host !== undefined ? { host } : {}),
+        };
+    }
+    return {
+        type: 'tool',
+        matcher: 'exact',
+        pattern: subject.name,
+        ...(host !== undefined ? { host } : {}),
+    };
+}
+/**
+ * §4.7.4 — **the three moves that weaken an effective annotation set**, and the whole of what
+ * invalidates a grant. Each names the hint and the transition, so the notice a human reads can say
+ * which one moved.
+ *
+ * They are exactly the moves that make a tool a more dangerous proposition than the one that was
+ * approved. The mirror images — a tool becoming read-only, closing to the open world, or ceasing to
+ * destroy — are strengthenings and change nothing: a grant is a permission, and a tool that has
+ * become safer is still covered by it.
+ */
+const WEAKENING_MOVES = [
+    { hint: 'readOnlyHint', from: true, to: false },
+    { hint: 'openWorldHint', from: false, to: true },
+    { hint: 'destructiveHint', from: false, to: true },
+];
+/**
+ * §4.7.4 — which hints moved in the weakening direction between the set a grant was made under and
+ * the set that holds now. Empty means the grant still stands.
+ *
+ * **Only the four booleans are compared, so schema and description changes invalidate nothing** —
+ * not by a rule that exempts them, but because a snapshot is four booleans and a description is not
+ * one of them. Descriptions churn on every server release, and a grant that dissolved on churn
+ * would teach users that grants are worthless.
+ *
+ * **An untrusted server's declaration change likewise invalidates nothing**, again by construction:
+ * §4.7.1 makes an untrusted server's effective set the constant fail-closed default, so both sides
+ * of this comparison are that constant however the server re-declares itself. Only a **trusted**
+ * server can move an effective value — which is exactly where invalidation matters, since the
+ * trusted server is the one whose rug-pull would otherwise ride an existing grant.
+ */
+export function annotationWeakenings(snapshot, current) {
+    return WEAKENING_MOVES.filter(({ hint, from, to }) => snapshot[hint] === from && current[hint] === to).map(({ hint }) => hint);
+}
+/**
+ * §4.7.1/§4.7.4 — **can WITHDRAWING trust in this hint weaken an effective set?**
+ *
+ * Withdrawing trust pushes a hint back to its MCP fail-closed default, and every weakening move
+ * *ends* at that default, so the answer does not depend on what a server declared: it is exactly
+ * whether the move (not-the-default → the default) is one of {@link WEAKENING_MOVES}. Three of the
+ * four hints answer yes — `readOnlyHint`, `openWorldHint` and `destructiveHint`, whose fail-closed
+ * default is `true`, so a server whose `destructiveHint: false` was believed becomes destructive
+ * again the moment it is not. `idempotentHint` is the only one that answers no, because no
+ * weakening move names it.
+ *
+ * **It asks {@link annotationWeakenings} rather than restating the table.** A second statement of
+ * which moves weaken is how a warning comes to describe a rule the gate no longer has — which
+ * matters most here, since this decides whether the human is told their saved approvals are about
+ * to be withdrawn.
+ */
+export function trustWithdrawalWeakens(hint) {
+    const untrusted = { ...MCP_FAIL_CLOSED_ANNOTATIONS };
+    const trusted = { ...untrusted, [hint]: !untrusted[hint] };
+    return annotationWeakenings(trusted, untrusted).includes(hint);
+}
+/**
+ * §4.7.4 — the notice a weakened grant is removed with. **It names the tool, the server and the
+ * hint that moved**, because the human approved a tool *as annotated*: a tool that re-annotates
+ * itself into a more dangerous shape is a different proposition wearing the same name, and a notice
+ * that did not say which name changed would be indistinguishable from the gate malfunctioning.
+ *
+ * It takes the **entry** rather than the call's subject, so it describes the grant that was actually
+ * withdrawn — including its host bound, where it had one. One call may withdraw both a host-bound
+ * grant and a tool-only one, and two notices that could not be told apart would be worse than one.
+ * The entry is rendered by {@link describeApprovalEntry}, the same one-liner every other provenance
+ * message uses.
+ */
+export function describeWeakenedGrant(entry, weakened, snapshot, current) {
+    const moves = weakened
+        .map((hint) => `${hint} changed from ${snapshot[hint]} to ${current[hint]}`)
+        .join(', ');
+    return (`Your saved approval for ${describeApprovalEntry(entry)} was removed: the tool now describes ` +
+        `itself as more dangerous than when you approved it (${moves}). You will be asked about the ` +
+        'next call.');
+}
+/**
+ * Identity of an entry, for **de-duplication only** — never a match decision. Two grants are the
+ * same grant when they would be the same line in a config file; whether an entry matches a call is
+ * `resolveApprovalRules`'s alone, and nothing in this module may answer that question.
+ */
+function grantKey(entry) {
+    return renderApprovalEntryObject(entry);
+}
+/**
+ * The `always` timestamp for entries migrated from the v1 file, which recorded none: the file's own
+ * last-write time, which is when the last of those grants was actually made. Falls back to now when
+ * the file cannot be stat'd.
+ */
+function fileWriteTime(filePath) {
+    try {
+        return new Date(statSync(filePath).mtimeMs).toISOString();
+    }
+    catch {
+        return new Date().toISOString();
+    }
+}
+/**
+ * Read a persisted {@link ApprovalGrant.annotations} snapshot.
+ *
+ * Three outcomes, and the middle one is the point: `undefined` when the field is absent (a `shell`
+ * grant, or a tool grant written before the field existed — nothing to compare, so the grant
+ * stands), the set when it is four booleans, and `null` when it is **present and malformed**, which
+ * drops the whole grant.
+ *
+ * That last case is deliberately harsher than the rest of {@link readGrant}, and for a reason that
+ * does not apply to the other metadata: **this field decides something.** `grantedAt` and `scope`
+ * are display, so coercing them costs nothing; a snapshot is what invalidation compares against, so
+ * a coerced one (a string `"true"` read as truthy) would feed a wrong comparison into the check and
+ * could conclude that a weakened tool had not weakened. Between dropping the snapshot — which leaves
+ * a rug-pull free to ride the grant — and dropping the grant, which costs a re-prompt, the field
+ * exists to fail closed and so does this.
+ */
+function readAnnotationSnapshot(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const snapshot = {};
+    for (const hint of TOOL_ANNOTATION_HINTS) {
+        if (typeof record[hint] !== 'boolean')
+            return null;
+        snapshot[hint] = record[hint];
+    }
+    return snapshot;
+}
+/**
+ * Read one persisted grant defensively. The **entry is validated by the config grammar's own
+ * schema** — one grammar, one validator — so a malformed entry is dropped here and can never reach
+ * the matcher. Timestamp and scope are coerced rather than validated: they decide nothing, and
+ * discarding a real grant over a missing timestamp would cost an approval the human already gave.
+ * The annotation snapshot is the exception ({@link readAnnotationSnapshot}), because it decides.
+ */
+function readGrant(value, fallbackTime) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    const parsed = approvalEntrySchema.safeParse(record.entry);
+    if (!parsed.success)
+        return null;
+    const annotations = readAnnotationSnapshot(record.annotations);
+    if (annotations === null)
+        return null;
+    return {
+        entry: parsed.data,
+        grantedAt: typeof record.grantedAt === 'string' ? record.grantedAt : fallbackTime,
+        scope: record.scope === 'session' ? 'session' : 'always',
+        ...(annotations !== undefined ? { annotations } : {}),
+    };
+}
+/**
+ * A set of grants with entry-identity semantics. Pure data + membership: it holds what the human
+ * granted and answers *is this the same grant*, never *does this grant cover that command*.
+ */
+export class ApprovalGrantStore {
+    grants = [];
+    constructor(initial = []) {
+        for (const grant of initial)
+            this.add(grant);
+    }
+    /**
+     * Add a grant. Returns whether it was new — an identical entry is not stored twice.
+     *
+     * The {@link ApprovalGrant.annotations} snapshot is **copied on the way in**, so what the store
+     * holds is private to this grant whatever the caller passed: the effective set may be a live
+     * object the caller keeps, or (were a source ever to regress) the shared fail-closed constant, and
+     * a store aliasing either would let one grant's record be rewritten from outside it. Copying here
+     * rather than at each call site makes that structural instead of a habit every caller must keep.
+     */
+    add(grant) {
+        const key = grantKey(grant.entry);
+        if (this.grants.some((held) => grantKey(held.entry) === key))
+            return false;
+        this.grants.push(grant.annotations ? { ...grant, annotations: { ...grant.annotations } } : grant);
+        return true;
+    }
+    /**
+     * The grant stored under this entry's identity, or `undefined`.
+     *
+     * **Identity, never a match decision** — the same de-duplication question {@link add} asks. It
+     * answers *"is this the same grant"*, and whether a grant covers a call remains
+     * `resolveApprovalRules`'s alone.
+     */
+    find(entry) {
+        const key = grantKey(entry);
+        return this.grants.find((held) => grantKey(held.entry) === key);
+    }
+    /**
+     * Drop the grant stored under this entry's identity. Returns whether one was there.
+     *
+     * §4.7.4's invalidation is a **removal** rather than a skip, and that is load-bearing: {@link add}
+     * de-duplicates by entry identity, so a grant left in place while being ignored would silently
+     * swallow the human's re-approval of the same tool — the grant would appear to be re-made and the
+     * stale snapshot would keep invalidating it.
+     */
+    remove(entry) {
+        const key = grantKey(entry);
+        const index = this.grants.findIndex((held) => grantKey(held.entry) === key);
+        if (index < 0)
+            return false;
+        this.grants.splice(index, 1);
+        return true;
+    }
+    /** Every grant, in the order they were made. */
+    list() {
+        return [...this.grants];
+    }
+    /** Just the entries, for handing to the matcher as one of its rule lists. */
+    entries() {
+        return this.grants.map((grant) => grant.entry);
+    }
+    /** How many grants are held. */
+    size() {
+        return this.grants.length;
+    }
+}
+/**
+ * The persisted (`always`) grant store, backed by a JSON file whose path is injected (the runner
+ * resolves it via fileUtils → `.gsloth/.gsloth-settings/shell-allowlist.json`) so tests can point it
+ * at a temp dir.
+ *
+ * ## The v1 migration, and the direction it goes
+ *
+ * The shipped v1 file held `prefixes: string[]` — classified command PREFIXES, so a stored
+ * `npm test` also auto-approved `npm test --watch`. Each prefix migrates to an **`exact` entry for
+ * the same string**, with **one** notice naming the file.
+ *
+ * That narrows what the file grants, on purpose: a v1 prefix was broader than what the human was
+ * actually shown when they answered the prompt, so narrowing it costs at worst a re-prompt and
+ * never an execution — the direction every ambiguity in this design resolves. The migrated file is
+ * rewritten as v2 immediately, so the notice is a one-time event rather than a per-session one; a
+ * write that fails (read-only checkout) is not fatal — the grants are in force for this session and
+ * the notice simply appears again next time.
+ */
+export class PersistedApprovalGrants {
+    store;
+    filePath;
+    constructor(filePath, options) {
+        this.filePath = filePath;
+        const { grants, migrated } = PersistedApprovalGrants.load(filePath, options?.onNotice);
+        this.store = new ApprovalGrantStore(grants);
+        if (migrated)
+            this.tryPersist();
+    }
+    static load(filePath, onNotice) {
+        try {
+            if (!existsSync(filePath))
+                return { grants: [], migrated: false };
+            const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+            if (!parsed || typeof parsed !== 'object')
+                return { grants: [], migrated: false };
+            const record = parsed;
+            if (Array.isArray(record.grants)) {
+                const fallbackTime = fileWriteTime(filePath);
+                const grants = record.grants
+                    .map((value) => readGrant(value, fallbackTime))
+                    .filter((grant) => grant !== null);
+                return { grants, migrated: false };
+            }
+            if (Array.isArray(record.prefixes)) {
+                return PersistedApprovalGrants.migrateFromV1(record.prefixes, filePath, onNotice);
+            }
+            return { grants: [], migrated: false };
+        }
+        catch {
+            // Corrupt / unreadable → behave as empty. Fail-closed on auto-approval: an empty store only
+            // ever means "prompt", so there is nothing to gain by throwing at a user mid-run.
+            return { grants: [], migrated: false };
+        }
+    }
+    /** Each v1 prefix → an `exact` entry for the same string, with ONE notice naming the file. */
+    static migrateFromV1(prefixes, filePath, onNotice) {
+        const grantedAt = fileWriteTime(filePath);
+        const migrated = new ApprovalGrantStore();
+        for (const prefix of prefixes) {
+            if (typeof prefix !== 'string')
+                continue;
+            const entry = shellGrantEntry(prefix);
+            if (entry.pattern.length === 0)
+                continue;
+            migrated.add({ entry, grantedAt, scope: 'always' });
+        }
+        if (migrated.size() > 0) {
+            // ONE notice for the whole file, not one per entry: the user needs to know their saved
+            // approvals changed meaning, once, and a line per entry would bury that in its own repetition.
+            onNotice?.({
+                level: StatusLevel.INFO,
+                message: `Your saved shell approvals (${filePath}) were stored in an older format that remembered ` +
+                    'a command PREFIX, which also approved longer commands starting with it. Each is now ' +
+                    'remembered as exactly the command it was, so a variant with extra arguments will ask ' +
+                    'again. Nothing was removed; some commands may prompt once more.',
+            });
+        }
+        return { grants: migrated.list(), migrated: true };
+    }
+    /** Every grant. */
+    list() {
+        return this.store.list();
+    }
+    /** Just the entries, for handing to the matcher as one of its rule lists. */
+    entries() {
+        return this.store.entries();
+    }
+    /** How many grants are persisted. */
+    size() {
+        return this.store.size();
+    }
+    /** Add a grant and persist the whole store. A duplicate entry rewrites nothing. */
+    add(grant) {
+        if (!this.store.add(grant))
+            return;
+        this.tryPersist();
+    }
+    /** The grant held under this entry's identity, or `undefined`. */
+    find(entry) {
+        return this.store.find(entry);
+    }
+    /**
+     * Drop the grant held under this entry's identity and rewrite the file. Returns whether one was
+     * there.
+     *
+     * The write is what makes §4.7.4's invalidation a one-time event: a removal held only in memory
+     * would be undone by the next session reloading the same stale snapshot, so the user would be
+     * told their grant had been withdrawn once per session, forever.
+     */
+    remove(entry) {
+        if (!this.store.remove(entry))
+            return false;
+        this.tryPersist();
+        return true;
+    }
+    /**
+     * Write the file. Never throws: the grants are already in force for this session, and a
+     * read-only checkout must not end a run over a bookkeeping write.
+     */
+    tryPersist() {
+        const file = {
+            version: PERSISTED_VERSION,
+            grants: this.store.list(),
+        };
+        try {
+            writeFileSync(this.filePath, JSON.stringify(file, null, 2) + '\n', 'utf8');
+        }
+        catch {
+            // Intentionally swallowed — see the doc comment.
+        }
+    }
+}
+//# sourceMappingURL=grants.js.map

package/dist/core/approvals/grants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grants.js","sourceRoot":"","sources":["../../../src/core/approvals/grants.ts"],"names":[],"mappings":"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"}