@denial-web/clawguard 0.1.10 → 0.1.11

package/README.md

@@ -114,6 +114,14 @@ TELEGRAM_BOT_TOKEN=123456:token npx @denial-web/clawguard approvals poll-telegra
 
 The poller records the Telegram update offset in `./.clawguard/decisions.jsonl.telegram-state.json` by default so the same reply is not processed again.
 
+Apply the recorded decision to continue or block the pending install:
+
+```bash
+npx @denial-web/clawguard approvals apply ./.clawguard/approvals.jsonl --id <approval-id> --decisions ./.clawguard/decisions.jsonl
+```
+
+If the latest decision is `approve`, ClawGuard copies the original scanned source to the original approved destination. If the latest decision is `deny`, it exits blocked without copying. If no decision exists yet, it stays paused.
+
 When testing the published package, run `npx` from outside this repository. From inside the ClawGuard source checkout, use the local commands instead:
 
 ```bash

package/docs/INTEGRATION_SPEC.md

@@ -111,6 +111,24 @@ TELEGRAM_BOT_TOKEN=123456:token clawguard approvals poll-telegram ./.clawguard/a
 
 The poller calls Telegram `getUpdates`, parses approval commands, looks up the referenced approval request, and appends a `clawguard.decision.v1` decision. It records the next Telegram update offset in `./.clawguard/decisions.jsonl.telegram-state.json` by default. For tests and offline replay, `--telegram-updates-file <path>` can read a captured Telegram-style update payload instead of calling the Telegram API.
 
+### Approval Apply
+
+After a decision is recorded, ClawGuard can apply that decision to the original pending install:
+
+```bash
+clawguard approvals apply ./.clawguard/approvals.jsonl \
+  --id <approval-id> \
+  --decisions ./.clawguard/decisions.jsonl
+```
+
+Apply behavior:
+
+- If the latest matching decision is `approve`, copy the original scanned `target` to the original approval `destination`.
+- If the latest matching decision is `deny`, exit blocked and copy nothing.
+- If no matching decision exists, exit paused and copy nothing.
+- Never execute the skill or install dependencies during apply.
+- Refuse symlinked install sources and existing destinations, matching normal install safety.
+
 ### Skill Folder Scan
 
 Command:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@denial-web/clawguard",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Explainable security scanner for OpenClaw-style skills and MCP tool configs.",
   "type": "module",
   "repository": {

package/src/cli.js

@@ -40,7 +40,8 @@ if (![
   "approvals-send",
   "approvals-watch",
   "approvals-decide",
-  "approvals-poll-telegram"
+  "approvals-poll-telegram",
+  "approvals-apply"
 ].includes(command)) {
   console.error(`Unknown command: ${command}`);
   printHelp();
@@ -94,6 +95,17 @@ try {
     process.exit(0);
   }
 
+  if (command === "approvals-apply") {
+    const applyOptions = parseApprovalApplyOptions(optionValues);
+    const result = await applyApprovalDecision(applyOptions);
+    if (applyOptions.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printApprovalApplyResult(result);
+    }
+    process.exit(approvalApplyExitCode(result));
+  }
+
   const cliOptions = parseOptions(optionValues);
   cliOptions.framework = framework;
   const loadedConfig = await loadConfig(cliOptions.target, cliOptions.configPath);
@@ -158,6 +170,7 @@ Usage:
   clawguard approvals watch <approvals.jsonl> --via telegram --chat-id <id>
   clawguard approvals decide <approval.json|approvals.jsonl> --id <id> --decision approve|deny
   clawguard approvals poll-telegram <approvals.jsonl> --decisions <decisions.jsonl>
+  clawguard approvals apply <approvals.jsonl> --id <id> --decisions <decisions.jsonl>
   clawguard scan-workspace <path> [--json] [--policy <preset>]
   npm run scan -- <path>
 
@@ -218,6 +231,7 @@ Examples:
   npx @denial-web/clawguard approvals watch ./.clawguard/approvals.jsonl --via telegram --chat-id 123456789
   npx @denial-web/clawguard approvals decide ./.clawguard/approvals.jsonl --id <id> --decision approve
   npx @denial-web/clawguard approvals poll-telegram ./.clawguard/approvals.jsonl --decisions ./.clawguard/decisions.jsonl
+  npx @denial-web/clawguard approvals apply ./.clawguard/approvals.jsonl --id <id> --decisions ./.clawguard/decisions.jsonl
   npm run scan -- examples/risky-skill
   npm run scan -- examples/metadata-mismatch-skill --policy governed --fail-on-policy
   npm run scan -- examples/metadata-mismatch-skill --html clawguard.html
@@ -333,6 +347,14 @@ function parseCommand(values) {
     };
   }
 
+  if (rawCommand === "approvals" && values[1] === "apply") {
+    return {
+      command: "approvals-apply",
+      framework: undefined,
+      optionValues: values.slice(2)
+    };
+  }
+
   if (["openclaw", "hermes"].includes(rawCommand)) {
     const nestedCommand = values[1];
 
@@ -578,6 +600,97 @@ async function pollTelegramApprovals(options) {
   return result;
 }
 
+async function applyApprovalDecision(options) {
+  const approval = await readApprovalRequest(options.approvalPath, options.id);
+  const decisionsPath = path.resolve(options.decisionsPath ?? `${options.approvalPath}.decisions.jsonl`);
+  const decision = await readLatestApprovalDecision(decisionsPath, approval.id);
+  const result = {
+    approval: {
+      id: approval.id,
+      status: approval.status,
+      decision: approval.decision,
+      risk: approval.risk,
+      framework: approval.framework
+    },
+    decision,
+    decisionsPath,
+    source: approval.target ? path.resolve(approval.target) : undefined,
+    destination: approval.destination ? path.resolve(approval.destination) : undefined,
+    dryRun: options.dryRun,
+    installed: false,
+    skipped: true,
+    reason: undefined
+  };
+
+  if (!decision) {
+    result.reason = "No decision has been recorded for this approval.";
+    return result;
+  }
+
+  if (decision.decision !== "approve") {
+    result.reason = decision.reason ?? "Approval was denied.";
+    return result;
+  }
+
+  if (!result.source) {
+    throw new Error("Approval request has no target path to install.");
+  }
+
+  if (!result.destination) {
+    throw new Error("Approval request has no destination path to install.");
+  }
+
+  if (options.dryRun) {
+    result.skipped = false;
+    result.reason = "Dry run passed; no files were copied.";
+    return result;
+  }
+
+  await assertInstallableSource(result.source);
+  await assertDestinationAvailable(result.destination);
+  await fs.mkdir(path.dirname(result.destination), { recursive: true });
+  await fs.cp(result.source, result.destination, {
+    recursive: true,
+    errorOnExist: true,
+    force: false,
+    verbatimSymlinks: true
+  });
+
+  result.installed = true;
+  result.skipped = false;
+  result.reason = "Copied after recorded approval.";
+  return result;
+}
+
+async function readLatestApprovalDecision(decisionsPath, approvalId) {
+  let decisions;
+
+  try {
+    decisions = await readApprovalDecisions(decisionsPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return undefined;
+    }
+
+    throw error;
+  }
+
+  return decisions.filter((decision) => decision.approvalId === approvalId).at(-1);
+}
+
+async function readApprovalDecisions(decisionsPath) {
+  const content = await fs.readFile(decisionsPath, "utf8");
+  const decisions = content.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+
+  for (const decision of decisions) {
+    if (decision.schemaVersion !== "clawguard.decision.v1") {
+      throw new Error("Unsupported approval decision schema.");
+    }
+  }
+
+  return decisions;
+}
+
 async function fetchTelegramUpdates(options, offset) {
   if (options.telegramUpdatesPath) {
     const content = await fs.readFile(path.resolve(options.telegramUpdatesPath), "utf8");
@@ -817,6 +930,17 @@ function printApprovalTelegramPollResult(result) {
   }
 }
 
+function printApprovalApplyResult(result) {
+  console.log(`ClawGuard approval apply: ${result.approval.id}`);
+  console.log(`Decision: ${result.decision ? formatDecision(result.decision.decision) : "PENDING"}`);
+  console.log(`Source: ${result.source ?? "not recorded"}`);
+  console.log(`Destination: ${result.destination ?? "not recorded"}`);
+  console.log(`Dry run: ${result.dryRun ? "yes" : "no"}`);
+  console.log(`Installed: ${result.installed ? "yes" : "no"}`);
+  console.log(`Exit code: ${approvalApplyExitCode(result)}`);
+  console.log(`Reason: ${result.reason}`);
+}
+
 async function readApprovalRequest(approvalPath, id) {
   const resolvedPath = path.resolve(approvalPath);
   const approvals = await readApprovalRequests(resolvedPath);
@@ -1246,6 +1370,10 @@ function commandLabel(commandName) {
     return "Telegram approval poll";
   }
 
+  if (commandName === "approvals-apply") {
+    return "Approval apply";
+  }
+
   if (commandName === "gate") {
     return "Gate";
   }
@@ -1324,6 +1452,18 @@ function installExitCode(decision, install) {
   return gateExitCode(decision);
 }
 
+function approvalApplyExitCode(result) {
+  if (!result.decision) {
+    return 1;
+  }
+
+  if (result.decision.decision !== "approve") {
+    return 2;
+  }
+
+  return 0;
+}
+
 function parseOptions(values) {
   const options = {
     json: false,
@@ -1893,6 +2033,67 @@ function parseApprovalTelegramPollOptions(values) {
   return options;
 }
 
+function parseApprovalApplyOptions(values) {
+  const options = {
+    approvalPath: undefined,
+    id: undefined,
+    decisionsPath: undefined,
+    dryRun: false,
+    json: false
+  };
+  const paths = [];
+
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+
+    if (value === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (value === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (value === "--id") {
+      options.id = requireNextValue(values, index, "--id");
+      index += 1;
+      continue;
+    }
+
+    if (value === "--decisions") {
+      options.decisionsPath = requireNextValue(values, index, "--decisions");
+      index += 1;
+      continue;
+    }
+
+    if (value === "--out") {
+      options.decisionsPath = requireNextValue(values, index, "--out");
+      index += 1;
+      continue;
+    }
+
+    if (value.startsWith("--")) {
+      throw new Error(`Unknown option: ${value}`);
+    }
+
+    paths.push(value);
+  }
+
+  options.approvalPath = paths[0];
+
+  if (!options.approvalPath) {
+    throw new Error("approvals apply requires <approval.json|approvals.jsonl>.");
+  }
+
+  if (!options.id) {
+    throw new Error("approvals apply requires --id <id>.");
+  }
+
+  return options;
+}
+
 async function writeReportFile(outputPath, content) {
   const resolvedPath = path.resolve(outputPath);
   await fs.mkdir(path.dirname(resolvedPath), { recursive: true });