@strongkeep/watchdog 0.1.1

package/dist/pipeline.js

@@ -0,0 +1,110 @@
+/**
+ * Apply pipeline — the orchestrator that ties verified entries → autonomy → applier → undo.
+ * This is the runtime the harness hook invokes on each poll (steady state, Journey B step 2).
+ *
+ * For each VERIFIED, parsed entry (from feed-client.pollFeed), for each of its actions:
+ *   1. decideDisposition(action, consumerTier, entryTier)  (autonomy.ts)
+ *   2. report  → surface to the human, no write.
+ *      stage   → applyAction(dryRun:true) → write a 'staged' UndoRecord + a pending diff file
+ *                (the PR-style pending change a human approves via {@link applyStaged}).
+ *      apply   → applyAction(dryRun:false) → append 'applied' UndoRecord.
+ *   3. All apply/stage outcomes append to the audit/undo log; a refused action is counted and
+ *      reported, never silently dropped.
+ *
+ * The pipeline NEVER executes an entry body and NEVER runs feed-supplied text; it only routes
+ * closed-vocabulary actions to allowlisted appliers. Crash-safety (D3): every applier writes
+ * its byte-exact out-of-log BACKUP before touching a target file, so prior state is
+ * recoverable on disk even if the process dies between the write and the log append.
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { applyAction, RefusedActionError } from './appliers/applier.js';
+import { decideDisposition } from './autonomy.js';
+import { appendUndoRecord, listApplied } from './undo.js';
+/** Where staged PR-style diffs are written, under the log dir. */
+export const PENDING_DIR = 'pending';
+/**
+ * Process all verified entries through the autonomy → applier → undo pipeline.
+ * Aggregates per-action failures (refusals) instead of aborting the whole run.
+ */
+export async function runPipeline(entries, config) {
+    const summary = { reported: 0, staged: 0, applied: 0, refused: 0, messages: [] };
+    for (const entry of entries) {
+        const fm = entry.frontmatter;
+        for (const action of fm.actions) {
+            const disposition = decideDisposition(action, config.consumerTier, fm.autonomy);
+            const why = `${fm.id}: ${fm.title}`;
+            try {
+                if (disposition === 'report') {
+                    summary.reported++;
+                    summary.messages.push(`report ${fm.id}: ${action.type} advised (tier gives no write authority)`);
+                    continue;
+                }
+                if (disposition === 'stage') {
+                    // Dry-run computes the diff + inverse without writing anything live.
+                    const result = await applyAction(action, { ...config.applyCtx, dryRun: true });
+                    const record = {
+                        id: randomUUID(),
+                        entryId: fm.id,
+                        action,
+                        appliedAt: new Date().toISOString(),
+                        status: 'staged',
+                        why,
+                        inverse: result.inverse,
+                    };
+                    await appendUndoRecord(config.logDir, record);
+                    const pendingDir = join(config.logDir, PENDING_DIR);
+                    await mkdir(pendingDir, { recursive: true });
+                    await writeFile(join(pendingDir, `${record.id}.diff`), result.diffPreview + '\n', 'utf8');
+                    summary.staged++;
+                    summary.messages.push(`staged ${fm.id}: ${result.summary} (approve with applyStaged/${record.id})`);
+                    continue;
+                }
+                // apply: the applier writes its out-of-log backup BEFORE the live write.
+                const result = await applyAction(action, { ...config.applyCtx, dryRun: false });
+                await appendUndoRecord(config.logDir, {
+                    id: randomUUID(),
+                    entryId: fm.id,
+                    action,
+                    appliedAt: new Date().toISOString(),
+                    status: 'applied',
+                    why,
+                    inverse: result.inverse,
+                });
+                summary.applied++;
+                summary.messages.push(`applied ${fm.id}: ${result.summary}`);
+            }
+            catch (err) {
+                if (err instanceof RefusedActionError) {
+                    summary.refused++;
+                    summary.messages.push(`refused ${fm.id}: ${err.message}`);
+                    continue; // a refused action never aborts the run — but it is never silent either
+                }
+                throw err;
+            }
+        }
+    }
+    return summary;
+}
+/**
+ * Human-approval path for a staged change: apply a previously-staged record for real and log
+ * the transition under the SAME record id (staged → applied → revertible). This is the
+ * "human applies the PR-style diff" step of the propose tier.
+ */
+export async function applyStaged(recordId, config) {
+    const records = await listApplied(config.logDir);
+    const staged = records.find((r) => r.id === recordId && r.status === 'staged');
+    if (staged === undefined)
+        throw new Error(`no staged record with id "${recordId}"`);
+    // The live apply captures the REAL inverse (incl. the byte-exact file backup pointer).
+    const result = await applyAction(staged.action, { ...config.applyCtx, dryRun: false });
+    await appendUndoRecord(config.logDir, {
+        ...staged,
+        appliedAt: new Date().toISOString(),
+        status: 'applied',
+        inverse: result.inverse,
+    });
+    return { summary: result.summary };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/pipeline.js.map

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

package/dist/undo.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Undo record model + audit log — the counterweight to autonomy (BUILD-PLAN #5 + D3).
+ *
+ * Every applied action writes an UndoRecord (capturing prior state via its applier's inverse)
+ * so `strongkeep-revert` can restore exactly. The undo log doubles as the audit trail: it is
+ * APPEND-ONLY (state transitions are new lines, never edits) and holds the plain-language
+ * "why applied" + the exact inverse needed to revert.
+ *
+ * D3 rule (binding): "the applier and its paired undo ship together or the action isn't
+ * shippable." An applier without a working undo path must refuse to apply.
+ *
+ * SECURITY:
+ *  - Undo records capture only config LOCATORS + scalar prior values. Where prior content is a
+ *    whole file (which could contain a secret), the applier backs the file up OUT of the log
+ *    (under .strongkeep/backups/) and only the backup POINTER (`backupRef`) is stored here —
+ *    same discipline as Phase 1 redaction.
+ *  - The log is local, append-only, and is the source of truth for `strongkeep-revert`.
+ *
+ * ponytail: the log is a single NDJSON file (one record per line, append = atomicity unit).
+ * Upgrade path: per-record files if concurrent writers ever exist (they don't in v1 — the
+ * pipeline is the only writer).
+ */
+import type { ConstrainedAction } from '@strongkeep/core';
+/** Lifecycle status of an applied action. */
+export type UndoStatus = 'staged' | 'applied' | 'reverted';
+/** A single applied (or staged) action + everything needed to revert it. */
+export interface UndoRecord {
+    /** Unique id for this application (what `strongkeep-revert <id>` takes). */
+    id: string;
+    /** The feed entry that motivated this action. */
+    entryId: string;
+    /** The action that was applied (closed-vocabulary). */
+    action: ConstrainedAction;
+    /** ISO timestamp of application. */
+    appliedAt: string;
+    status: UndoStatus;
+    /** Plain-language reason surfaced in the "recently applied" list (D3). No jargon, no emoji. */
+    why: string;
+    /**
+     * The inverse needed to restore prior state, produced by the action's paired undo builder.
+     * Interpreted by the same applier that created it.
+     */
+    inverse: UndoInverse;
+}
+/**
+ * The captured inverse of an applied action. Discriminated by the action type so the right
+ * applier reverses it. Carries prior scalar state + out-of-log backup pointers — never a
+ * secret value inline.
+ */
+export type UndoInverse = {
+    kind: 'set_config';
+    file: string;
+    keypath: string;
+    priorValue: string | number | boolean | undefined;
+    /** Byte-exact backup of the prior file (relative to harness root), when the file existed. */
+    backupRef?: string;
+    /** True when the config file itself did not exist before apply (revert deletes it). */
+    fileExistedBefore: boolean;
+} | {
+    kind: 'add_hook';
+    hookPackId: string;
+    existedBefore: boolean;
+    path: string;
+    backupRef?: string;
+} | {
+    kind: 'block_domain';
+    domain: string;
+    existedBefore: boolean;
+} | {
+    kind: 'pin_mcp';
+    server: string;
+    priorVersion: string | undefined;
+    backupRef?: string;
+} | {
+    kind: 'update_rule_file';
+    path: string;
+    existedBefore: boolean;
+    backupRef?: string;
+} | {
+    kind: 'min_version';
+    noop: true;
+};
+/**
+ * Append an undo record to the local, append-only log. Called by the pipeline at apply time
+ * (the applier has already written its out-of-log backup BEFORE touching the target file, so
+ * prior state is recoverable even across a crash between write and log-append).
+ */
+export declare function appendUndoRecord(logDir: string, record: UndoRecord): Promise<void>;
+/**
+ * Read the "recently applied" list for the revert UX (D3), newest first. The log is a stream
+ * of state transitions; the LATEST line per id wins (e.g. applied → reverted).
+ */
+export declare function listApplied(logDir: string): Promise<UndoRecord[]>;
+/**
+ * Mark a record reverted after its inverse has been applied. Appends a `reverted` transition
+ * line (the log stays append-only).
+ */
+export declare function markReverted(logDir: string, id: string): Promise<void>;

package/dist/undo.js

@@ -0,0 +1,67 @@
+/**
+ * Undo record model + audit log — the counterweight to autonomy (BUILD-PLAN #5 + D3).
+ *
+ * Every applied action writes an UndoRecord (capturing prior state via its applier's inverse)
+ * so `strongkeep-revert` can restore exactly. The undo log doubles as the audit trail: it is
+ * APPEND-ONLY (state transitions are new lines, never edits) and holds the plain-language
+ * "why applied" + the exact inverse needed to revert.
+ *
+ * D3 rule (binding): "the applier and its paired undo ship together or the action isn't
+ * shippable." An applier without a working undo path must refuse to apply.
+ *
+ * SECURITY:
+ *  - Undo records capture only config LOCATORS + scalar prior values. Where prior content is a
+ *    whole file (which could contain a secret), the applier backs the file up OUT of the log
+ *    (under .strongkeep/backups/) and only the backup POINTER (`backupRef`) is stored here —
+ *    same discipline as Phase 1 redaction.
+ *  - The log is local, append-only, and is the source of truth for `strongkeep-revert`.
+ *
+ * ponytail: the log is a single NDJSON file (one record per line, append = atomicity unit).
+ * Upgrade path: per-record files if concurrent writers ever exist (they don't in v1 — the
+ * pipeline is the only writer).
+ */
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const LOG_FILE = 'undo-log.ndjson';
+/**
+ * Append an undo record to the local, append-only log. Called by the pipeline at apply time
+ * (the applier has already written its out-of-log backup BEFORE touching the target file, so
+ * prior state is recoverable even across a crash between write and log-append).
+ */
+export async function appendUndoRecord(logDir, record) {
+    await mkdir(logDir, { recursive: true });
+    await appendFile(join(logDir, LOG_FILE), JSON.stringify(record) + '\n', 'utf8');
+}
+/**
+ * Read the "recently applied" list for the revert UX (D3), newest first. The log is a stream
+ * of state transitions; the LATEST line per id wins (e.g. applied → reverted).
+ */
+export async function listApplied(logDir) {
+    let text;
+    try {
+        text = await readFile(join(logDir, LOG_FILE), 'utf8');
+    }
+    catch {
+        return []; // no log yet — nothing applied
+    }
+    const latest = new Map();
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        const record = JSON.parse(line);
+        latest.set(record.id, record); // later lines supersede earlier states for the same id
+    }
+    return [...latest.values()].reverse(); // newest first (insertion order = log order)
+}
+/**
+ * Mark a record reverted after its inverse has been applied. Appends a `reverted` transition
+ * line (the log stays append-only).
+ */
+export async function markReverted(logDir, id) {
+    const records = await listApplied(logDir);
+    const record = records.find((r) => r.id === id);
+    if (record === undefined)
+        throw new Error(`no undo record with id "${id}"`);
+    await appendUndoRecord(logDir, { ...record, status: 'reverted' });
+}
+//# sourceMappingURL=undo.js.map

package/dist/undo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo.js","sourceRoot":"","sources":["../src/undo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAgDjC,MAAM,QAAQ,GAAG,iBAAiB,CAAC;AAEnC;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,MAAc,EAAE,MAAkB;IACvE,MAAM,KAAK,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,MAAM,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;AAClF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,MAAc;IAC9C,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC,CAAC,+BAA+B;IAC5C,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC7C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,SAAS;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAe,CAAC;QAC9C,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,uDAAuD;IACxF,CAAC;IACD,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,6CAA6C;AACtF,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,MAAc,EAAE,EAAU;IAC3D,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAChD,IAAI,MAAM,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,EAAE,GAAG,CAAC,CAAC;IAC5E,MAAM,gBAAgB,CAAC,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;AACpE,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@strongkeep/watchdog",
+  "version": "0.1.1",
+  "description": "Consumer (subscriber-side) config pack for the AI Security feed (D6 — NOT a daemon). strongkeep-init writes hooks/rules/skill/MCP config into the subscriber's own harness; the feed client verifies + applies signed ConstrainedActions per autonomy tier with a paired undo; strongkeep-revert is one-click self-serve undo.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "strongkeep-login": "dist/cli/login.js",
+    "strongkeep-init": "dist/cli/init.js",
+    "strongkeep-poll": "dist/cli/poll.js",
+    "strongkeep-revert": "dist/cli/revert.js",
+    "strongkeep-mcp": "dist/cli/mcp.js",
+    "strongkeep-guard-check": "dist/cli/guard-check.js"
+  },
+  "files": [
+    "dist/",
+    "assets/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node --experimental-strip-types --test 'test/**/*.test.ts'",
+    "test:acceptance": "npm run build && node --experimental-strip-types --test 'test/acceptance/**/*.test.ts'"
+  },
+  "dependencies": {
+    "@strongkeep/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  }
+}