dsh-perm-gate 4.0.0 → 4.1.0-beta.1

package/lib/config.d.ts

@@ -10,6 +10,9 @@ import { DEFAULT_GATE_PRESETS, resolveGatePresets } from './preset.js';
 export declare function resolveDshHome(configured?: string): string;
 /** This plugin's data directory (`<dshHome>/perm-gate`), always defined. */
 export declare function resolveDataDir(configured?: string): string;
+export declare function ensureDataDir(dataDir: string): boolean;
+/** Check whether the data directory exists without creating it. */
+export declare function dataDirReady(dataDir: string): boolean;
 /**
  * The permissions document the gate loads. An explicit `rulesFile` wins; unset
  * falls back to `<dataDir>/rules.yml`, so a rules file the user drops in the

package/lib/config.js

@@ -3,6 +3,7 @@
  * loader validates and fills defaults before `apply`. Invalid values fail loud.
  */
 import { homedir } from 'node:os';
+import { mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import z from '@deepseek-ai/schemastery';
 import { DEFAULT_GATE_PRESETS, resolveGatePresets } from './preset.js';
@@ -24,6 +25,41 @@ export function resolveDshHome(configured) {
 export function resolveDataDir(configured) {
     return join(resolveDshHome(configured), 'perm-gate');
 }
+/**
+ * Lazily ensure the data directory exists. Safe to call repeatedly —
+ * `mkdirSync({recursive:true})` is a no-op when the directory already
+ * exists. Returns `true` if the directory is now available, `false`
+ * if creation failed (caller should degrade to empty defaults).
+ *
+ * Used by every write path. Read paths should call `dataDirReady()`
+ * instead to avoid creating the directory as a side effect of reading.
+ */
+let _dataDirReady = false;
+export function ensureDataDir(dataDir) {
+    if (_dataDirReady)
+        return true;
+    try {
+        mkdirSync(dataDir, { recursive: true });
+        _dataDirReady = true;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check whether the data directory exists without creating it. */
+export function dataDirReady(dataDir) {
+    if (_dataDirReady)
+        return true;
+    try {
+        statSync(dataDir);
+        _dataDirReady = true;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * The permissions document the gate loads. An explicit `rulesFile` wins; unset
  * falls back to `<dataDir>/rules.yml`, so a rules file the user drops in the
@@ -157,7 +193,7 @@ export const Config = z.object({
     networkAskTimeoutMs: z.number().min(1000).max(600_000).default(120_000),
     networkGrantTtlMs: z.number().min(0).max(24 * 60 * 60_000).default(30 * 60_000),
     // Hot reload (Phase 3)
-    watch: z.boolean().default(true),
+    watch: z.boolean().default(false),
     watchDebounceMs: z.number().min(50).max(5000).default(300),
 });
 export function resolveConfig(config = {}) {

package/lib/index.js

@@ -1,16 +1,27 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parse } from 'yaml';
-import { Config, RULES_NAMESPACE, RulesSchema, isRulesConfigured, readRulesFromSettings, resolveDshHome, resolveDataDir, resolveGatePresets, resolvePermissiveStrategies, resolveRulesFile } from './config.js';
-import { appendAllowToSettings, replaceAllowInSettings } from './allowlist.js';
+import { Config, resolveDshHome, resolveDataDir, ensureDataDir, resolveGatePresets, resolvePermissiveStrategies, resolveRulesFile } from './config.js';
 import { runDryRun } from './dry-run.js';
-import { registerDryRunRoute, registerEventsRoute, registerHealthRoute, registerLearningRoute, registerNetworkRoute, registerReceiverRoute, registerReviewRoutes, registerRulesRoute, registerStreamRoute } from './events.js';
+import { registerDryRunRoute, registerEventsRoute, registerHealthRoute, registerLearningRoute, registerNetworkRoute, registerReceiverRoute, registerReviewRoutes, registerRulesRoute } from './events.js';
 import { buildReceiverInfo } from './receiver-info.js';
-import { readRulesView, readRulesViewFromSettings } from './rules-view.js';
+import { readRulesView } from './rules-view.js';
 import { PermGateRuntime } from './runtime.js';
 import { classifySessions, sweepSessionData } from './session-sweep.js';
 import { decideNetworkTarget } from './network.js';
 import { NetworkLifecycle } from './network-lifecycle.js';
+import { RuleWatcher } from './watch.js';
+// ─── Cold-start directory bootstrap ─────────────────────────────────────────
+// Ensure the plugin data directory exists BEFORE cordis calls apply().
+// The DSH framework (or other plugins) may scan dataDir during plugin
+// registration — before our apply() entry point runs. If the directory
+// is missing at that point, the scan throws and the plugin (or the
+// entire profile) fails to load.
+//
+// This is a belt-and-suspenders approach:
+//   1. Module-level: ensure dataDir exists at import time (earliest possible)
+//   2. Read paths: check dataDirReady() → return empty defaults if missing
+//   3. Write paths: call ensureDataDir() before first write
+ensureDataDir(resolveDataDir());
 export const name = 'dsh-perm-gate';
 /**
  * The `tools` service drives `tools/pre-execute`/`tools/result` (dsh-tools).
@@ -185,37 +196,6 @@ export function apply(ctx, config = {}) {
     // read-only). The default resolves to `$DSH_HOME` / `~/.dsh`, so a profile
     // entry that omits `config` still records events, snapshots and learning.
     const dataDir = resolveDataDir(typeof config.dshHome === 'string' ? config.dshHome : undefined);
-    // ─── Rules sources (dual-source: settings first, rulesFile fallback) ──
-    // The `dsh-perm-gate-rules` settings namespace is the primary rules store —
-    // the framework owns it, so the gate loads with no rules file on disk. A
-    // namespace still at bare defaults never shadows the file, and the first
-    // settings write seeds the file document along (implicit migration). Both
-    // references are filled in by the settings registration below; until then
-    // the file paths run exactly as before.
-    const rulesFilePath = resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir);
-    let rulesFromSettings = () => ({});
-    const rulesScopeRef = { scope: undefined };
-    /** The raw file document, for seeding the namespace on its first write. */
-    const fileSeedDoc = () => {
-        try {
-            const text = readFileSync(rulesFilePath, 'utf8');
-            if (text.trim() === '')
-                return undefined;
-            return parse(text);
-        }
-        catch {
-            return undefined;
-        }
-    };
-    const settingsWrite = (write, fallback) => {
-        const scope = rulesScopeRef.scope;
-        if (scope === undefined)
-            return fallback();
-        void write(scope, fileSeedDoc()).catch((e) => {
-            console.warn('[dsh-perm-gate] settings rules write failed:', e);
-        });
-        return true;
-    };
     // Host model-group services (typed minimally; supplied by the dsh runtime
     // through the loader `inject` — dsh-approval-gate demonstrates the same
     // contract). The llm service backs the `host` receiver; agentDefaultModel
@@ -356,19 +336,8 @@ export function apply(ctx, config = {}) {
             : join(dataDir, 'learning.json'),
         // The rules document lives in the plugin's data dir by default, so a
         // `$DSH_HOME/perm-gate/rules.yml` the user writes is actually loaded without
-        // also having to declare `rulesFile` in the composition entry. It is the
-        // FALLBACK source: a configured `dsh-perm-gate-rules` namespace wins.
-        rulesFile: rulesFilePath,
-        // Settings-first rules: the live `dsh-perm-gate-rules` document when the
-        // namespace carries a real configuration, else undefined (file fallback).
-        readRulesDocument: () => readRulesFromSettings({ get: () => rulesFromSettings() }),
-        // Settings-backed allowlist writes; a falsy verdict (settings service
-        // absent) makes the runtime fall back to its own rules-file paths, and the
-        // namespace's watch triggers the reload once a write lands.
-        allowlistWriter: {
-            append: (pattern, reason) => settingsWrite((scope, seed) => appendAllowToSettings(scope, pattern, reason, seed), () => false),
-            replace: (patterns, reason) => settingsWrite((scope, seed) => replaceAllowInSettings(scope, patterns, reason, seed), () => false),
-        },
+        // also having to declare `rulesFile` in the composition entry.
+        rulesFile: resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir),
         // The whole gate is scoped to the presets that opt into it (default: the
         // `permissive` tier this plugin adds); elsewhere it stands down entirely.
         gatePresets: resolveGatePresets(Array.isArray(config.gatePresets) ? config.gatePresets : undefined),
@@ -459,17 +428,15 @@ export function apply(ctx, config = {}) {
         },
         onChange: () => { },
         onScope: (scope) => {
-            // Seed the editable whitelist from the rules source only when the
-            // namespace carries no override yet, so the card shows the current allow
-            // patterns.
+            // Seed the editable whitelist from the rules file only when the namespace
+            // carries no override yet, so the card shows the current allow patterns.
             const surface = asSurface(scope.get());
             if (surface !== undefined && !Array.isArray(surface.allowlist)) {
                 const patterns = runtime.allowlist();
                 if (patterns.length > 0)
                     void scope.update({ allowlist: patterns.slice() });
             }
-            // Card edits -> namespace -> rules source (settings via the runtime's
-            // writer, else the rules file mirror) + reload.
+            // Card edits -> namespace -> rulesFile (mirror + reload).
             scope.watch(() => {
                 const next = asSurface(scope.get());
                 if (next !== undefined && Array.isArray(next.allowlist)) {
@@ -489,22 +456,6 @@ export function apply(ctx, config = {}) {
             });
         },
     });
-    // The rules namespace: the primary rules store (JSON twin of rules.yml).
-    // Every change recompiles the gate — the settings half of the hot reload
-    // that used to be a chokidar file watcher. `onScope` hands the live scope to
-    // the allowlist writers above; the seed entry is `{}`, so an untouched
-    // namespace reads as "not configured" and the file paths stay in force.
-    installSettingsSection(ctx, RULES_NAMESPACE, RulesSchema, {}, {
-        setSource: (source) => {
-            rulesFromSettings = source;
-        },
-        onChange: () => {
-            runtime.reload();
-        },
-        onScope: (scope) => {
-            rulesScopeRef.scope = scope;
-        },
-    });
     // Event feed HTTP API (best effort): the dsh webServer service exposes the
     // JSONL decision events to the browser half; without it events stay on disk.
     try {
@@ -520,11 +471,6 @@ export function apply(ctx, config = {}) {
             const offEvents = registerEventsRoute(webServer, runtime.eventLog);
             if (offEvents !== undefined)
                 ctx.effect(() => () => { offEvents(); }, 'dsh-perm-gate: events route');
-            // Push plane: the browser half follows decisions over one SSE connection
-            // instead of re-reading the event log on a timer.
-            const offStream = registerStreamRoute(webServer, runtime.eventLog);
-            if (offStream !== undefined)
-                ctx.effect(() => () => { offStream(); }, 'dsh-perm-gate: stream route');
         }
         // Review-page plane (diff / revert / snapshot stats / snapshot clear): the
         // approval-history view's file chips and snapshot bar drive these.
@@ -572,18 +518,12 @@ export function apply(ctx, config = {}) {
             });
             if (offDryRun !== undefined)
                 ctx.effect(() => () => { offDryRun(); }, 'dsh-perm-gate: dry-run route');
-            // Permissions view: the document the gate is actually loading, shown so
-            // the panel is never editing rules it cannot display. Read-only, and
-            // resolved exactly as the gate resolves it — settings first, the file the
-            // fallback resolves to otherwise.
-            const offRules = registerRulesRoute(webServer, {
-                view: () => {
-                    const doc = rulesFromSettings();
-                    if (isRulesConfigured(doc))
-                        return readRulesViewFromSettings(doc);
-                    return readRulesView(rulesFilePath);
-                },
-            });
+            // Permissions YAML view: the document the gate is actually loading, shown
+            // so the panel is never editing a file it cannot display. Read-only, and
+            // resolved exactly as the gate resolves it — a view that resolved its own
+            // path could describe a different file than the one in force.
+            const rulesFilePath = resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir);
+            const offRules = registerRulesRoute(webServer, { view: () => readRulesView(rulesFilePath) });
             if (offRules !== undefined)
                 ctx.effect(() => () => { offRules(); }, 'dsh-perm-gate: rules route');
             // Receiver projection for the settings card (provider/model catalog is
@@ -731,10 +671,23 @@ export function apply(ctx, config = {}) {
     networkRefs.snapshot = () => networkLifecycle.snapshot();
     if (networkRefs.appliedKey === undefined)
         networkRefs.appliedKey = networkKeyOf(current());
-    // ─── Rule hot reload ────────────────────────────────────────────────
-    // The file watcher (chokidar) is gone: the settings namespace is the primary
-    // rules store and its `scope.watch` recompiles the gate on every change
-    // (see the RULES_NAMESPACE registration above). A rules FILE edit is no
-    // longer picked up mid-session — the settings document is the source to edit.
+    // ─── Hot reload watcher (Phase 3, T3.6) ────────────────────────────
+    const watchEnabled = typeof config.watch === 'boolean' ? config.watch : true;
+    if (watchEnabled) {
+        const watchDebounceMs = typeof config.watchDebounceMs === 'number' ? config.watchDebounceMs : 300;
+        const ruleWatcher = new RuleWatcher({
+            debounceMs: watchDebounceMs,
+            logger: { warn: (msg) => console.warn(msg) },
+        });
+        // Watch the effective rules file for the current workspace.
+        const rulesFile = resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir);
+        const cwd = typeof config.cwd === 'string' ? config.cwd : process.cwd();
+        ruleWatcher.watch(cwd, [rulesFile], () => {
+            runtime.reload();
+        });
+        ctx.effect(() => () => {
+            ruleWatcher.closeAll();
+        }, 'dsh-perm-gate: rule watcher');
+    }
     return runtime;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-perm-gate",
-  "version": "4.0.0",
+  "version": "4.1.0-beta.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",