sliccy 6.226.0 → 6.226.2

package/dist/node-server/sudo/dialog-backends.d.ts

@@ -6,11 +6,13 @@
  * {@link SudoDecision}. They are deliberately injectable via {@link ExecFn} so
  * tests can assert the argv and parsing without spawning a real dialog.
  *
- * Fail-closed contract: a dismissed dialog, a non-zero exit, an unparsable
- * result, or a thrown error all resolve to `deny`. An `always` result with an
- * empty pattern falls back to the suggested default.
+ * Fail-closed contract: a dismissed dialog or Deny button is a bare `deny`
+ * (a human refused). A spawn/exec plumbing failure, or no native channel, is
+ * `{ decision: 'deny', reason: 'unavailable' }` so callers never treat infra
+ * failures as owner refusal. An `always` result with an empty pattern falls
+ * back to the suggested default.
  */
-import type { SudoApproveRequest, SudoBackend } from './types.js';
+import { type SudoApproveRequest, type SudoBackend } from './types.js';
 /** Minimal exec seam: run a binary with args, resolve its stdout. */
 export type ExecFn = (cmd: string, args: string[]) => Promise<{
     stdout: string;
@@ -33,5 +35,8 @@ export declare function createPowerShellBackend(exec?: ExecFn): SudoBackend;
 export declare function createZenityBackend(exec?: ExecFn): SudoBackend;
 /** Linux GUI: `kdialog --warningyesnocancel` (+ `--inputbox`). */
 export declare function createKdialogBackend(exec?: ExecFn): SudoBackend;
-/** A backend that always denies — used when no native channel exists. */
+/**
+ * A backend used when no native channel exists (headless, no DISPLAY/TTY).
+ * Returns `unavailable` — nobody was prompted — not a bare refuse.
+ */
 export declare function createDenyBackend(name?: string): SudoBackend;

package/dist/node-server/sudo/dialog-backends.js

@@ -6,12 +6,15 @@
  * {@link SudoDecision}. They are deliberately injectable via {@link ExecFn} so
  * tests can assert the argv and parsing without spawning a real dialog.
  *
- * Fail-closed contract: a dismissed dialog, a non-zero exit, an unparsable
- * result, or a thrown error all resolve to `deny`. An `always` result with an
- * empty pattern falls back to the suggested default.
+ * Fail-closed contract: a dismissed dialog or Deny button is a bare `deny`
+ * (a human refused). A spawn/exec plumbing failure, or no native channel, is
+ * `{ decision: 'deny', reason: 'unavailable' }` so callers never treat infra
+ * failures as owner refusal. An `always` result with an empty pattern falls
+ * back to the suggested default.
  */
 import { execFile as nodeExecFile } from 'child_process';
 import { promisify } from 'util';
+import { unavailableDecision, } from './types.js';
 const defaultExec = promisify(nodeExecFile);
 /**
  * Human-readable description of the gated action, for every native dialog.
@@ -32,6 +35,29 @@ export function describeRequest(req) {
 function fallbackPattern(req) {
     return req.suggestedPattern?.trim() || req.detail.trim();
 }
+/**
+ * Classify an exec failure from a real dialog binary.
+ *
+ * Node's `execFile` sets a **numeric** `code` when the process ran and exited
+ * non-zero (Deny / dismiss / Always-via-extra-button). A **string** errno
+ * (`ENOENT`, `EACCES`, …) or a generic `Error` without a numeric code means
+ * the binary never ran — plumbing, not a refusal.
+ */
+function denyFromDialogFailure(err) {
+    const code = err?.code;
+    if (typeof code === 'number')
+        return { decision: 'deny' };
+    return unavailableDecision();
+}
+/**
+ * True when the dialog binary did not produce a real exit code.
+ * Matches {@link denyFromDialogFailure}: only a numeric `code` means the
+ * dialog ran (Deny / Always / dismiss). String errno or a code-less Error
+ * is plumbing — never a refusal.
+ */
+function isSpawnFailure(err) {
+    return typeof err?.code !== 'number';
+}
 /** macOS: single `osascript display dialog` with 3 buttons + a text field. */
 export function createOsascriptBackend(exec = defaultExec) {
     return {
@@ -53,8 +79,10 @@ export function createOsascriptBackend(exec = defaultExec) {
                 }
                 return { decision: 'deny' };
             }
-            catch {
-                return { decision: 'deny' };
+            catch (err) {
+                // User cancel (Escape) exits non-zero with a numeric code; spawn failure
+                // is ENOENT / generic Error → unavailable.
+                return denyFromDialogFailure(err);
             }
         },
     };
@@ -86,10 +114,12 @@ export function createPowerShellBackend(exec = defaultExec) {
                         pattern: pattern && pattern.length > 0 ? pattern : suggested,
                     };
                 }
+                // MessageBox "No" prints DENY — a genuine refusal.
                 return { decision: 'deny' };
             }
-            catch {
-                return { decision: 'deny' };
+            catch (err) {
+                // PowerShell MessageBox never throws on No; a throw is spawn/plumbing.
+                return denyFromDialogFailure(err);
             }
         },
     };
@@ -116,7 +146,9 @@ export function createZenityBackend(exec = defaultExec) {
                 allowed = true;
             }
             catch (err) {
-                // Non-zero exit: either Deny (no stdout) or the extra "Always" button.
+                // Spawn failure never reached a human; numeric exit is Deny / Always.
+                if (isSpawnFailure(err))
+                    return unavailableDecision();
                 always = stdoutOf(err).trim() === 'Always';
                 allowed = always;
             }
@@ -146,6 +178,8 @@ export function createKdialogBackend(exec = defaultExec) {
                 code = 0; // Yes
             }
             catch (err) {
+                if (isSpawnFailure(err))
+                    return unavailableDecision();
                 code = exitCodeOf(err);
             }
             if (code === 0)
@@ -156,12 +190,15 @@ export function createKdialogBackend(exec = defaultExec) {
         },
     };
 }
-/** A backend that always denies — used when no native channel exists. */
+/**
+ * A backend used when no native channel exists (headless, no DISPLAY/TTY).
+ * Returns `unavailable` — nobody was prompted — not a bare refuse.
+ */
 export function createDenyBackend(name = 'none') {
     return {
         name,
         async prompt() {
-            return { decision: 'deny' };
+            return unavailableDecision();
         },
     };
 }

package/dist/node-server/sudo/electron-backend.d.ts

@@ -8,10 +8,11 @@
  * implementation runs `window.prompt` inside a transient offscreen
  * `BrowserWindow`. Both seams are injectable so tests never touch Electron.
  *
- * Fail closed: a thrown dialog call, a cancelled prompt, or an unknown button
- * resolves to `deny` / falls back to the suggested pattern.
+ * Fail closed: a cancelled prompt or Deny button is a bare `deny`; a thrown
+ * `showMessageBox` (no display / Electron gone) is `unavailable`. A cancelled
+ * Always-pattern prompt falls back to the suggested pattern.
  */
-import type { SudoBackend } from './types.js';
+import { type SudoBackend } from './types.js';
 /** Result shape of `dialog.showMessageBox`. */
 interface MessageBoxResult {
     response: number;

package/dist/node-server/sudo/electron-backend.js

@@ -8,9 +8,11 @@
  * implementation runs `window.prompt` inside a transient offscreen
  * `BrowserWindow`. Both seams are injectable so tests never touch Electron.
  *
- * Fail closed: a thrown dialog call, a cancelled prompt, or an unknown button
- * resolves to `deny` / falls back to the suggested pattern.
+ * Fail closed: a cancelled prompt or Deny button is a bare `deny`; a thrown
+ * `showMessageBox` (no display / Electron gone) is `unavailable`. A cancelled
+ * Always-pattern prompt falls back to the suggested pattern.
  */
+import { unavailableDecision, } from './types.js';
 const BUTTONS = ['Deny', 'Allow Once', 'Always'];
 /** Create the Electron backend. */
 export function createElectronBackend(deps = {}) {
@@ -45,7 +47,8 @@ export function createElectronBackend(deps = {}) {
                 response = result.response;
             }
             catch {
-                return { decision: 'deny' };
+                // Dialog never appeared — plumbing, not a refusal.
+                return unavailableDecision();
             }
             if (response === 1)
                 return { decision: 'allow' };

package/dist/node-server/sudo/endpoint.d.ts

@@ -8,11 +8,12 @@
  * (the agent's browser `node` shim can't reach this process) and returns the
  * human's decision. Loopback-only, like the other local node-server endpoints.
  *
- * Fail closed: an invalid body → 400; a backend that throws → `deny` (200).
- * Requests never auto-resolve to allow.
+ * Fail closed: an invalid body → 400; a backend that throws →
+ * `{ decision: 'deny', reason: 'unavailable' }` (200). A bare `deny` is reserved
+ * for a genuine human refusal. Requests never auto-resolve to allow.
  */
 import { type Express } from 'express';
-import type { SudoBackend } from './types.js';
+import { type SudoBackend } from './types.js';
 export interface SudoEndpointOptions {
     /**
      * Backend to use for every request. Defaults to lazy per-request selection

package/dist/node-server/sudo/endpoint.js

@@ -8,12 +8,14 @@
  * (the agent's browser `node` shim can't reach this process) and returns the
  * human's decision. Loopback-only, like the other local node-server endpoints.
  *
- * Fail closed: an invalid body → 400; a backend that throws → `deny` (200).
- * Requests never auto-resolve to allow.
+ * Fail closed: an invalid body → 400; a backend that throws →
+ * `{ decision: 'deny', reason: 'unavailable' }` (200). A bare `deny` is reserved
+ * for a genuine human refusal. Requests never auto-resolve to allow.
  */
 import express from 'express';
 import { requireLoopback } from '../cloud-status.js';
 import { selectSudoBackend } from './select.js';
+import { unavailableDecision, } from './types.js';
 // Must list EVERY `SudoKind`. An omission is not a safe default: the endpoint
 // 400s, the browser-side broker reads that as a denial, and the gate fails
 // closed forever — so a missing kind silently makes that whole approval path
@@ -68,8 +70,8 @@ export function registerSudoApproveEndpoint(app, options = {}) {
             decision = await backend.prompt(request);
         }
         catch (err) {
-            warn(`sudo-approve backend "${backend.name}" threw — denying: ${String(err)}`);
-            decision = { decision: 'deny' };
+            warn(`sudo-approve backend "${backend.name}" threw — denying as unavailable: ${String(err)}`);
+            decision = unavailableDecision();
         }
         res.json(decision);
     });

package/dist/node-server/sudo/select.d.ts

@@ -6,7 +6,7 @@
  *   3. Windows   → PowerShell
  *   4. Linux+GUI → `zenity` / `kdialog`
  *   5. headless  → editable TTY
- *   6. no channel → fail closed (deny) + log
+ *   6. no channel → fail closed (`unavailable`) + log
  *
  * The environment probe is injectable so tests can force any branch without
  * touching the real platform / spawning `which`.

package/dist/node-server/sudo/select.js

@@ -6,7 +6,7 @@
  *   3. Windows   → PowerShell
  *   4. Linux+GUI → `zenity` / `kdialog`
  *   5. headless  → editable TTY
- *   6. no channel → fail closed (deny) + log
+ *   6. no channel → fail closed (`unavailable`) + log
  *
  * The environment probe is injectable so tests can force any branch without
  * touching the real platform / spawning `which`.

package/dist/node-server/sudo/tty-backend.d.ts

@@ -4,10 +4,12 @@
  * When there's no GUI but the node-server has a controlling terminal, the
  * approval gesture is a keystroke on stdin: `[a]llow once / [d]eny / [A]lways`.
  * Choosing "Always" then reads an editable pattern line (blank keeps the
- * suggested default). Fail closed: a closed stream, EOF, or any error denies.
+ * suggested default). Fail closed: an explicit `d` / other keystroke is a bare
+ * deny; a closed stream, EOF mid-prompt, or any thrown error is `unavailable`
+ * (the request never reached an answering human).
  */
 import type { Interface as ReadlineInterface } from 'readline';
-import type { SudoBackend } from './types.js';
+import { type SudoBackend } from './types.js';
 /** Seam for tests: build a question-asking interface over arbitrary streams. */
 export interface TtyDeps {
     output?: NodeJS.WritableStream;

package/dist/node-server/sudo/tty-backend.js

@@ -4,9 +4,12 @@
  * When there's no GUI but the node-server has a controlling terminal, the
  * approval gesture is a keystroke on stdin: `[a]llow once / [d]eny / [A]lways`.
  * Choosing "Always" then reads an editable pattern line (blank keeps the
- * suggested default). Fail closed: a closed stream, EOF, or any error denies.
+ * suggested default). Fail closed: an explicit `d` / other keystroke is a bare
+ * deny; a closed stream, EOF mid-prompt, or any thrown error is `unavailable`
+ * (the request never reached an answering human).
  */
 import { createInterface } from 'readline';
+import { unavailableDecision, } from './types.js';
 export function defaultRl() {
     return createInterface({ input: process.stdin, output: process.stdout });
 }
@@ -40,7 +43,7 @@ export function createTtyBackend(deps = {}) {
                 return { decision: 'deny' };
             }
             catch {
-                return { decision: 'deny' };
+                return unavailableDecision();
             }
             finally {
                 try {

package/dist/node-server/sudo/types.d.ts

@@ -43,11 +43,39 @@ export interface SudoApproveRequest {
 export interface SudoDecision {
     decision: 'allow' | 'deny' | 'always';
     pattern?: string;
+    /**
+     * Why a `deny` was reached when nobody actually refused. Absent for a real
+     * gesture (Deny button, TTY `d`, dialog dismiss). Enforcement layers and
+     * biscotto review use it to tell a guest "unanswered", not "refused".
+     *
+     * Node-server only stamps `unavailable` (no approval surface, a dialog
+     * binary that could not be spawned, a backend that threw). Timeout reasons
+     * live in the webapp broker layer. Mirror of webapp `SudoDecision.reason`.
+     *
+     * Deliberately a field rather than a fourth `decision` value: every consumer
+     * branches on `decision === 'deny'`, so a new variant would fail OPEN.
+     */
+    reason?: SudoUnansweredReason;
 }
+/**
+ * Why a `deny` carries no human's refusal. See {@link SudoDecision.reason}.
+ * Every value means "unanswered"; only the absence of a reason means "refused".
+ * Node-server emits only `unavailable`; the timeout values are listed so the
+ * wire shape matches the webapp consumer.
+ */
+export type SudoUnansweredReason = 'user-timeout' | 'cone-timeout' | 'unavailable';
+/**
+ * The fail-closed decision for a request that never reached an approver.
+ * Use this instead of a bare `{ decision: 'deny' }` on any plumbing path: a
+ * bare deny is indistinguishable from a human pressing "Deny".
+ */
+export declare function unavailableDecision(): SudoDecision;
 /**
  * A native approval channel. `name` is for logging/selection; `prompt` raises
  * the actual gesture. Implementations MUST fail closed (resolve `deny`) on any
- * error, dismissal, or timeout — never throw to the endpoint.
+ * error, dismissal, or timeout — never throw to the endpoint. Plumbing
+ * failures MUST carry {@link unavailableDecision}'s `reason`; only a genuine
+ * human refusal is a bare deny.
  */
 export interface SudoBackend {
     readonly name: string;

package/dist/node-server/sudo/types.js

@@ -10,4 +10,11 @@
  * gesture in this process — the agent's in-browser `node` shim cannot reach
  * here.
  */
-export {};
+/**
+ * The fail-closed decision for a request that never reached an approver.
+ * Use this instead of a bare `{ decision: 'deny' }` on any plumbing path: a
+ * bare deny is indistinguishable from a human pressing "Deny".
+ */
+export function unavailableDecision() {
+    return { decision: 'deny', reason: 'unavailable' };
+}