dsh-perm-gate 2.1.2 → 4.0.0

package/lib/allowlist.js

@@ -2,11 +2,113 @@
  * Durable allowlist (whitelist) writes for dsh-perm-gate.
  *
  * The "allow everywhere" approval action appends a matched command pattern to
- * the rules file's `allow` list and reloads, so a human-approved command is
+ * the rules' `allow` list and reloads, so a human-approved command is
  * persistently whitelisted across sessions — not just granted once.
+ *
+ * Two storage backs, per the dual-source migration:
+ * - **settings** (`appendAllowToSettings` / `replaceAllowInSettings`) — the
+ *   `dsh-perm-gate-rules` namespace; the primary write path once the settings
+ *   service is available.
+ * - **rules file** (`appendAllowCommand` / `replaceAllowCommands`) — the legacy
+ *   path, kept as the fallback when no settings scope is wired (and as the
+ *   migration seed: the first settings write carries the file document along so
+ *   file-defined deny/ask rules are not shadowed).
  */
 import { readFileSync, writeFileSync } from 'node:fs';
 import { parse, stringify } from 'yaml';
+import { isRulesConfigured } from './config.js';
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Accept both the bare rules form and the file's `permissions:`-wrapped form. */
+function unwrapPermissions(seed) {
+    if (!isRecord(seed))
+        return {};
+    return isRecord(seed['permissions']) ? seed['permissions'] : seed;
+}
+/** The file document a first write should migrate into the namespace, or bare defaults. */
+function seedOrDefaults(seed) {
+    const root = unwrapPermissions(seed);
+    return {
+        defaultAction: typeof root['defaultAction'] === 'string' ? root['defaultAction'] : 'ask',
+        deny: Array.isArray(root['deny']) ? root['deny'] : [],
+        allow: Array.isArray(root['allow']) ? root['allow'] : [],
+        ask: Array.isArray(root['ask']) ? root['ask'] : [],
+    };
+}
+function allowEntriesOf(section) {
+    const allow = section['allow'];
+    return Array.isArray(allow) ? allow : [];
+}
+function commandEntries(patterns, reason) {
+    return patterns.map((pattern) => ({ command: [pattern], reason }));
+}
+/** The allow-list command patterns currently in the settings rules document (read-only). */
+export function listAllowFromRulesDoc(doc) {
+    const section = unwrapPermissions(doc);
+    const out = [];
+    for (const entry of allowEntriesOf(section)) {
+        if (!isRecord(entry))
+            continue;
+        const command = entry['command'];
+        if (typeof command === 'string') {
+            out.push(command);
+            continue;
+        }
+        if (!Array.isArray(command))
+            continue;
+        for (const c of command)
+            if (typeof c === 'string')
+                out.push(c);
+    }
+    return out;
+}
+/**
+ * Append one command pattern as a new `allow` entry in the settings rules
+ * namespace. When the namespace is still unconfigured (bare defaults) and a
+ * file document is supplied, the namespace is seeded from it first — the
+ * implicit migration — so the first settings write cannot shadow file-defined
+ * deny/ask rules. Returns false when the scope rejects the write.
+ */
+export async function appendAllowToSettings(scope, pattern, reason = 'permissive allow-everywhere', seed) {
+    try {
+        const current = scope.get();
+        const section = isRulesConfigured(current) && isRecord(current)
+            ? { ...current }
+            : seedOrDefaults(seed);
+        const allow = allowEntriesOf(section);
+        allow.push({ command: [pattern], reason });
+        section['allow'] = allow;
+        await scope.update(section);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Replace the settings rules namespace's `allow` whitelist with exactly the
+ * given command patterns (one allow entry per pattern); empty clears it.
+ * Other sections (deny / ask / defaultAction) are preserved — seeded from the
+ * file document on the namespace's first write. Returns false when the scope
+ * rejects the write.
+ */
+export async function replaceAllowInSettings(scope, patterns, reason = 'permissive allowlist', seed) {
+    try {
+        if (patterns === undefined)
+            return false;
+        const current = scope.get();
+        const section = isRulesConfigured(current) && isRecord(current)
+            ? { ...current }
+            : seedOrDefaults(seed);
+        section['allow'] = commandEntries(patterns, reason);
+        await scope.update(section);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Append one command pattern as a new `allow` entry in the rules file.
  * Returns false (leaving the file untouched) on any I/O or shape error.

package/lib/cli.js

@@ -10,7 +10,7 @@
  */
 import { parseArgs } from 'node:util';
 import { resolve } from 'node:path';
-import { PermGateRuntime } from './runtime.js';
+import { createDryRunRuntime, runDryRun } from './dry-run.js';
 function main() {
     const { values } = parseArgs({
         options: {
@@ -23,11 +23,7 @@ function main() {
         },
     });
     const rulesFile = values.rules ? resolve(values.rules) : undefined;
-    const runtime = new PermGateRuntime({
-        rulesFile,
-        caseInsensitivePaths: true,
-        permissive: values.permissive || undefined,
-    });
+    const runtime = createDryRunRuntime({ rulesFile, permissive: values.permissive });
     if (values.list) {
         process.stdout.write(JSON.stringify({
             rulesFile,
@@ -53,15 +49,16 @@ function main() {
         process.exitCode = 2;
         return;
     }
-    const decision = runtime.decideExecution({
-        name: tool,
-        arguments: args,
-        cwd: values.cwd ? resolve(values.cwd) : process.cwd(),
-    });
+    // `hostView` reproduces this command's historic output exactly: it reports the
+    // host-facing decision path (whose `allow` is a bare passthrough with no
+    // reason) and its audit count. The panel reports the pure policy verdict
+    // instead, because a session-less caller must not inherit the session layers.
+    const result = runDryRun({ tool, args, rulesFile, cwd: values.cwd, hostView: true }, runtime);
+    const host = result.host;
     process.stdout.write(JSON.stringify({
-        decision: decision === undefined ? 'allow' : decision.kind,
-        reason: decision?.reason ?? '(default/passthrough)',
-        audited: runtime.auditEntries.length,
+        decision: host?.verdict ?? result.verdict,
+        reason: host?.reason ?? result.reason,
+        audited: host?.audited ?? 0,
     }, null, 2) + '\n');
 }
 main();