fullcourtdefense-cli 1.35.8 → 1.35.9

package/dist/commandNarrative.js

@@ -110,12 +110,12 @@ const GCLOUD_SERVICE_NAMES = {
     secrets: 'Secret Manager', iam: 'IAM', projects: 'project', functions: 'Cloud Functions', container: 'GKE', logging: 'Cloud Logging',
     artifacts: 'Artifact Registry', scheduler: 'Cloud Scheduler', tasks: 'Cloud Tasks', kms: 'Cloud KMS', builds: 'Cloud Build', auth: 'auth', config: 'config',
 };
-const GCLOUD_READ = /^(?:describe|list|ls|get-iam-policy|get-value|get-ancestors|read|check|versions)$/;
+const GCLOUD_READ = /^(?:describe|list|ls|get-iam-policy|get-value|get-ancestors|read|check)$/;
 const GCLOUD_WRITE = /^(?:create|update|patch|replace|enable|disable|deploy|apply|start|stop|restart|resume|suspend|scale|promote|migrate|rollback|add-[a-z-]+|remove-[a-z-]+|set-[a-z-]+|unset|clear|activate|revoke|copy)$/;
 function humanVerb(verb) {
     const map = {
         describe: 'Reads details of', list: 'Lists', ls: 'Lists', 'get-iam-policy': 'Reads the access policy of', 'get-value': 'Reads the setting',
-        read: 'Reads', check: 'Checks', versions: 'Lists versions of',
+        read: 'Reads', check: 'Checks',
         create: 'Creates', update: 'Updates', patch: 'Updates', replace: 'Replaces', enable: 'Enables', disable: 'Disables', deploy: 'Deploys',
         apply: 'Applies', start: 'Starts', stop: 'Stops', restart: 'Restarts', resume: 'Resumes', suspend: 'Suspends', scale: 'Scales',
         promote: 'Promotes', migrate: 'Migrates', rollback: 'Rolls back', unset: 'Unsets', clear: 'Clears', activate: 'Activates', revoke: 'Revokes', copy: 'Copies',
@@ -135,12 +135,39 @@ function humanVerb(verb) {
         return `Sets ${verb.slice(4).replace(/-/g, ' ')} on`;
     return `Runs \`${verb}\` on`;
 }
+/** `gcloud secrets versions <verb>`: `access` reads the secret VALUE, `list` lists versions, `add` stores a new value. */
+function describeSecretVersions(toks, verbAt, where) {
+    const verb = toks[verbAt] || '';
+    const ops = operandsAfter(toks, verbAt + 1);
+    const flagSecret = flagValue(toks, '--secret');
+    const secret = (name) => (name ? `secret ${shortValue(name, 60)}` : 'a secret');
+    if (verb === 'access') {
+        return `Reads the value of ${secret(flagSecret)} (version ${shortValue(ops[0] || 'latest', 20)}) from Secret Manager${where}`;
+    }
+    if (verb === 'list')
+        return `Lists the versions of ${secret(ops[0])} in Secret Manager${where}`;
+    if (verb === 'add') {
+        const dataFile = flagValue(toks, '--data-file');
+        return `Adds a new version to ${secret(ops[0])} in Secret Manager${dataFile ? `, value from ${dataFile === '-' ? 'standard input' : shortValue(dataFile, 60)}` : ''}${where}`;
+    }
+    const version = ops[0] ? `version ${shortValue(ops[0], 20)} of ` : '';
+    if (verb === 'describe')
+        return `Reads details of ${version}${secret(flagSecret)} in Secret Manager${where}`;
+    const state = { destroy: 'Destroys', disable: 'Disables', enable: 'Enables' };
+    if (state[verb])
+        return `${state[verb]} ${version}${secret(flagSecret)} in Secret Manager${where}`;
+    return `Runs \`gcloud secrets versions ${verb}\`${where}`;
+}
 function describeGcloud(toks) {
     let i = 1;
     while (i < toks.length && toks[i].startsWith('-'))
         i++;
     if (/^(?:alpha|beta)$/.test(toks[i] || ''))
         i++;
+    if (toks[i] === 'secrets' && toks[i + 1] === 'versions') {
+        const project = flagValue(toks, '--project');
+        return describeSecretVersions(toks, i + 2, project ? ` in project ${project}` : '');
+    }
     const groups = [];
     let verb;
     for (; i < toks.length; i++) {
@@ -234,6 +261,79 @@ function describePipeTail(stages) {
         return ', and writes the output to a file';
     return '';
 }
+/**
+ * The whole statement is one quoted string (`"len=$($t.Length)"`, `'done'`): its text
+ * with each `$( … )` sub-expression shown as `…`. Undefined when it is anything else.
+ */
+function bareStringText(head) {
+    const value = head.trim();
+    const q = value[0];
+    if ((q !== '"' && q !== "'") || value.length < 2 || value[value.length - 1] !== q)
+        return undefined;
+    let depth = 0;
+    let text = '';
+    for (let k = 1; k < value.length - 1; k++) {
+        const ch = value[k];
+        if (q === '"' && ch === '`') {
+            text += value[++k] ?? '';
+            continue;
+        }
+        if (q === '"' && ch === '$' && value[k + 1] === '(') {
+            if (depth++ === 0)
+                text += '…';
+            k++;
+            continue;
+        }
+        if (depth > 0) {
+            if (ch === '(')
+                depth++;
+            else if (ch === ')')
+                depth--;
+            continue;
+        }
+        if (ch === q) {
+            if (q === "'" && value[k + 1] === "'") {
+                text += "'";
+                k++;
+                continue;
+            }
+            return undefined;
+        }
+        text += ch;
+    }
+    return depth === 0 ? text.trim() : undefined;
+}
+/** `((gcloud … $p) -join '').Trim()` -> `gcloud … $p`: the command inside nested groups (quote-aware). */
+function peelGroups(text) {
+    let value = text.trim();
+    for (let guard = 0; guard < 8 && value.startsWith('('); guard++) {
+        let depth = 0;
+        let end = -1;
+        let quote = '';
+        for (let k = 0; k < value.length; k++) {
+            const ch = value[k];
+            if (quote) {
+                if (ch === quote)
+                    quote = '';
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                quote = ch;
+                continue;
+            }
+            if (ch === '(')
+                depth++;
+            else if (ch === ')' && --depth === 0) {
+                end = k;
+                break;
+            }
+        }
+        if (end < 0)
+            break;
+        value = value.slice(1, end).trim();
+    }
+    return value;
+}
 function describeOne(segmentIn) {
     const segment = segmentIn.trim();
     const [head, ...pipe] = splitPipe(segment);
@@ -270,10 +370,14 @@ function describeOne(segmentIn) {
             }
             return step(`Sets variable ${name}${interpolates ? ' from other values' : ` to ${shortValue(bare, 60)}`}`);
         }
-        const inner = rhs.replace(/^\(\s*/, '').replace(/\)\s*(?:\.\w+\(\))*$/, '');
+        const inner = rhs.startsWith('(') ? peelGroups(rhs) : rhs.replace(/\)\s*(?:\.\w+\(\))*$/, '');
         const innerStep = describeOne(inner);
         return { segment, text: shortValue(`Stores in ${name}: ${innerStep.text.charAt(0).toLowerCase()}${innerStep.text.slice(1)}${tail}`, MAX_LINE), known: innerStep.known };
     }
+    // A bare string statement: PowerShell writes it to the output (`"len=$($t.Length)"`).
+    const bare = bareStringText(head);
+    if (bare !== undefined)
+        return step(bare ? `Prints text: ${shortValue(bare, 80)}` : 'Prints an empty line');
     const toks = tokens(head);
     if (toks.length === 0)
         return step('(empty)', false);
@@ -531,7 +635,10 @@ function describeOne(segmentIn) {
         default:
             if (/^\$/.test(programToken))
                 return step(pipe.length ? `Uses ${shortValue(programToken, 40)}${tail}` : `Reads variable ${shortValue(programToken, 40)}`, false);
-            return step(`Runs \`${shortValue([program, rest[1]].filter(t => t && !t.startsWith('-')).join(' '), 50)}\``, false);
+            {
+                const shown = shortValue([program, rest[1]].filter(t => t && !t.startsWith('-')).join(' '), 50);
+                return step(shown ? `Runs \`${shown}\`` : 'Runs a command this dialog cannot describe', false);
+            }
     }
 }
 /** Split one step on top-level `|` (quote-aware). */

package/dist/commands/daemon.js

@@ -1593,7 +1593,7 @@ async function runDaemon(args, config) {
     // to full local evaluation whenever this server is down — never a blocker.
     let verdictServer;
     try {
-        verdictServer = (0, verdictIpc_1.startVerdictServer)((hookArgs, stdin) => (0, hook_1.evaluateHookRequest)(hookArgs, stdin, (0, config_1.loadConfig)()), log);
+        verdictServer = (0, verdictIpc_1.startVerdictServer)((hookArgs, stdin) => (0, hook_1.evaluateHookRequest)(hookArgs, stdin, (0, config_1.loadConfig)(), { viaDaemon: true }), log);
     }
     catch (error) {
         log(`Verdict IPC: failed to start (${error.message}) — hooks will evaluate locally.`);

package/dist/commands/deterministicGuard.js

@@ -1219,6 +1219,11 @@ function interpreterCodeSpawnsProcess(before, code) {
         return true;
     return BACKTICK_SHELL_INTERPRETER.test(before) && /`[^`]*`|%x[\[{(]/.test(code);
 }
+// An HTTP client in the same code makes a metadata endpoint literal a request target, not prose.
+const CODE_OPENS_REQUEST = /\b(?:urlopen|Request|requests|httpx|urllib3|aiohttp|http\.client|HTTPS?Connection|fetch|axios|got|XMLHttpRequest|https?\.(?:get|request)|Net::HTTP|LWP|HTTP::Tiny|URI\.open|curl_exec|file_get_contents|fsockopen|socket)\b/;
+function interpreterCodeRequestsMetadata(code) {
+    return Boolean(containsMetadataEndpoint(code)) && CODE_OPENS_REQUEST.test(code);
+}
 /** First path argument of direct file APIs in inline language code, not printed examples. */
 function interpreterFileArguments(text) {
     if (text.length > 32_000)
@@ -1306,7 +1311,7 @@ function stripInertDataSegments(text) {
         const before = src.slice(Math.max(0, offset - 80), offset);
         // Language-interpreter code: data unless it spawns a process (see above).
         if (LANG_INTERPRETER_CODE_BEFORE.test(before))
-            return interpreterCodeSpawnsProcess(before, body) ? whole : INERT_DATA;
+            return interpreterCodeSpawnsProcess(before, body) || interpreterCodeRequestsMetadata(body) ? whole : INERT_DATA;
         if (CODE_CONTEXT_BEFORE.test(before))
             return whole; // code position: executes
         if (dq !== undefined && INTERPOLATES.test(body))

package/dist/commands/hook.d.ts

@@ -193,7 +193,27 @@ export interface HookIo {
      * mode, where `exit` only unwinds the evaluation and the process lives on.
      */
     exitsProcess: boolean;
+    /** Evaluated inside the resident daemon for a thin client (see DaemonDeclined). */
+    viaDaemon?: boolean;
+    /** Set when this evaluation's verdict is a stop still being settled (approval wait). */
+    pendingStop?: string;
 }
+/**
+ * The daemon declines a request whose verdict is a human wait (org approval,
+ * taint approve-once). The thin client stops listening after ~2.5s and
+ * re-evaluates locally, so a daemon-side wait only opened a second approval
+ * request nobody would ever read. Declining sends the client to its local
+ * evaluation at once, where the one wait runs in the developer's own process.
+ */
+export declare class DaemonDeclined extends Error {
+}
+/** Absolute time a human wait must end by: its own cap, and never past the IDE's timeout. */
+export declare function humanWaitDeadline(waitMs: number, now?: number, startedAt?: number, ideTimeoutMs?: number): number;
+/** Verdict for an unexpected error that escaped the evaluation (process-level handlers). */
+export declare function crashVerdictForProcess(event: string | undefined, message: string): {
+    stdout: string;
+    exitCode: number;
+};
 /**
  * Daemon-side entry: evaluate one hook request in-process and return the
  * verdict instead of writing/exiting. Everything the per-event hook process
@@ -202,7 +222,9 @@ export interface HookIo {
  * Mirrors hookCommand's fail-open contract: any unexpected exception yields
  * an allow verdict, never an error the thin client would surface.
  */
-export declare function evaluateHookRequest(args: HookArgs, stdinRaw: string, config: BotGuardConfig): Promise<{
+export declare function evaluateHookRequest(args: HookArgs, stdinRaw: string, config: BotGuardConfig, opts?: {
+    viaDaemon?: boolean;
+}): Promise<{
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -217,4 +239,15 @@ export declare function evaluateHookRequest(args: HookArgs, stdinRaw: string, co
  * through respond() inside and never reach this catch.
  */
 export declare function hookCommand(args: HookArgs, config: BotGuardConfig): Promise<void>;
+/**
+ * Errors that escape every await (an async 'error' event from a child process,
+ * a stray rejection) never reach the try/catch around the evaluation. Without
+ * these handlers Node prints a stack and exits 1 with NO verdict, which every
+ * client reads as a non-blocking hook error — the action runs. Route them
+ * through the same contract as a caught crash instead.
+ */
+export declare function installHookCrashHandlers(verdict: (message: string) => {
+    stdout: string;
+    exitCode: number;
+}): void;
 export {};