295 lines
9.8 KiB
JavaScript
295 lines
9.8 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import os from 'node:os';
|
|
|
|
import { executeRuntimeIntegratedGovernance } from '../src/index.mjs';
|
|
import capabilityDescriptor from '../capabilities/openclaw-watchdog-reference.json' with { type: 'json' };
|
|
|
|
const packageRoot = path.resolve(import.meta.dirname, '..');
|
|
const repoRoot = path.resolve(packageRoot, '..', '..');
|
|
|
|
const noSilencePack = {
|
|
metadata: { id: 'no-silence', severity_default: 'high' },
|
|
spec: {
|
|
evaluation_mode: 'any_rule_match',
|
|
rules: [
|
|
{
|
|
id: 'no-silence.missed-checkpoint',
|
|
title: 'Missed checkpoint requires visible recovery',
|
|
triggers: { event_types: ['silence_timeout'] },
|
|
conditions: {
|
|
all: [
|
|
{ fact: 'checkpoint.is_overdue', equals: true }
|
|
]
|
|
},
|
|
decision_output: {
|
|
decision: 'force_checkpoint',
|
|
severity: 'high',
|
|
reason: 'checkpoint overdue triggered forced operator-visible recovery',
|
|
required_actions: [
|
|
{ action: 'notify_operator', target: 'operator_channel', mandatory: true },
|
|
{ action: 'emit_event', target: 'event_stream', mandatory: true }
|
|
],
|
|
operator_notice: {
|
|
required: true,
|
|
channel: 'telegram',
|
|
urgency: 'high',
|
|
message: 'Required update: checkpoint overdue.',
|
|
deadline: '2026-01-01T00:00:00.000Z'
|
|
}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
};
|
|
|
|
const unknownActionPack = {
|
|
metadata: { id: 'unknown-action-pack', severity_default: 'high' },
|
|
spec: {
|
|
evaluation_mode: 'any_rule_match',
|
|
rules: [
|
|
{
|
|
id: 'unknown-action-pack.route-to-unsupported-action',
|
|
title: 'Route to unsupported action for matrix coverage',
|
|
triggers: { event_types: ['silence_timeout'] },
|
|
conditions: {
|
|
all: [
|
|
{ fact: 'checkpoint.is_overdue', equals: true }
|
|
]
|
|
},
|
|
decision_output: {
|
|
decision: 'force_checkpoint',
|
|
severity: 'high',
|
|
reason: 'checkpoint overdue triggered unsupported adapter action for route matrix coverage',
|
|
required_actions: [
|
|
{ action: 'rewrite_message', target: 'message_body', mandatory: true }
|
|
]
|
|
}
|
|
}
|
|
]
|
|
}
|
|
};
|
|
|
|
const strictProfileArtifact = {
|
|
kind: 'DeploymentProfileArtifact',
|
|
apiVersion: 'reporting-governance/v1alpha1',
|
|
metadata: {
|
|
id: 'strict-manager-mode',
|
|
runtime: 'openclaw',
|
|
compatibility_mode: 'strict_envelope',
|
|
},
|
|
spec: {
|
|
package: { pluginVersion: '0.1.0-mainline' },
|
|
policies: {
|
|
overrides: {
|
|
checkpoints: { overdueAction: 'force_checkpoint' }
|
|
}
|
|
},
|
|
notifications: {
|
|
operatorVisibleRecoveryRequired: true
|
|
},
|
|
bindings: {
|
|
runtime: 'openclaw',
|
|
entrypoint: 'scripts/watchdog_auto_notify_orchestrator.mjs',
|
|
scripts: {
|
|
watchdog: 'scripts/long_task_watchdog.mjs',
|
|
dispatcher: 'scripts/operator_notify_dispatcher.mjs',
|
|
bridgeSupervisor: 'scripts/operator_notify_bridge_supervisor.mjs',
|
|
senderBinding: 'scripts/operator_notify_sender_binding.mjs',
|
|
orchestrator: 'scripts/watchdog_auto_notify_orchestrator.mjs'
|
|
},
|
|
artifact_roots: {
|
|
queueItems: 'state/operator-notify-queue'
|
|
}
|
|
}
|
|
},
|
|
capability_expectations: {
|
|
required: [
|
|
'emit_canonical_events',
|
|
'evaluate_watchdog_overdue',
|
|
'create_queue_items',
|
|
'create_spool_handoff',
|
|
'write_bridge_receipts'
|
|
],
|
|
preferred: ['direct_sender_binding', 'final_delivery_ack']
|
|
}
|
|
};
|
|
|
|
function createFixtureRoot() {
|
|
return fs.mkdtempSync(path.join(os.tmpdir(), 'reporting-governance-runtime-integrated-'));
|
|
}
|
|
|
|
function mkdirs(root, names) {
|
|
for (const name of names) {
|
|
fs.mkdirSync(path.join(root, name), { recursive: true });
|
|
}
|
|
}
|
|
|
|
function writeState(root) {
|
|
const statePath = path.join(root, 'watchdog-state.json');
|
|
fs.writeFileSync(statePath, `${JSON.stringify({
|
|
version: 1,
|
|
watchdogs: [
|
|
{
|
|
id: 'reporting-governance-plugin-watchdog',
|
|
task: 'reporting-governance plugin spec development',
|
|
status: 'active',
|
|
ownerSessionKey: 'agent:coder:main',
|
|
reportChannel: 'telegram',
|
|
reportTarget: '864811879',
|
|
intervalMinutes: 10,
|
|
lastMilestoneAt: '2026-05-07T08:00:00.000Z',
|
|
lastAlertAt: null,
|
|
},
|
|
],
|
|
}, null, 2)}\n`, 'utf8');
|
|
return statePath;
|
|
}
|
|
|
|
function readSingleJson(dirPath) {
|
|
const files = fs.readdirSync(dirPath).filter((name) => name.endsWith('.json')).sort();
|
|
assert.equal(files.length, 1, `expected exactly one json file in ${dirPath}`);
|
|
return JSON.parse(fs.readFileSync(path.join(dirPath, files[0]), 'utf8'));
|
|
}
|
|
|
|
function createBaseArgs(overrides = {}) {
|
|
return {
|
|
event: {
|
|
type: 'silence_timeout',
|
|
payload: {
|
|
checkpoint_overdue: true,
|
|
}
|
|
},
|
|
evidence: [
|
|
{ id: 'ev-watchdog', quality: 'moderate', is_new: true }
|
|
],
|
|
capabilityDescriptor,
|
|
policyPacks: [noSilencePack],
|
|
context: {
|
|
signals: ['checkpoint_overdue'],
|
|
},
|
|
profile: strictProfileArtifact,
|
|
packageVersion: '0.1.0-mainline',
|
|
repoRootOverride: repoRoot,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createStubRuntime() {
|
|
return {
|
|
state: path.join(repoRoot, 'tmp', 'unused-state.json'),
|
|
evidenceDir: path.join(repoRoot, 'tmp', 'unused-evidence'),
|
|
eventDir: path.join(repoRoot, 'tmp', 'unused-events'),
|
|
queueDir: path.join(repoRoot, 'tmp', 'unused-queue'),
|
|
spoolDir: path.join(repoRoot, 'tmp', 'unused-spool'),
|
|
receiptDir: path.join(repoRoot, 'tmp', 'unused-receipts'),
|
|
dryRun: true,
|
|
now: '2026-05-07T08:20:00.000Z',
|
|
};
|
|
}
|
|
|
|
test('runtime-integrated route matrix: no runtime stays planning-only', () => {
|
|
const result = executeRuntimeIntegratedGovernance(createBaseArgs());
|
|
|
|
assert.equal(result.preflight.status, 'pass');
|
|
assert.equal(result.runtimeIntegration.attempted, false);
|
|
assert.equal(result.runtimeIntegration.reason, 'runtime execution not attempted');
|
|
assert.equal(result.runtimeExecution, null);
|
|
});
|
|
|
|
test('runtime-integrated route matrix: preflight fail blocks runtime route', () => {
|
|
const result = executeRuntimeIntegratedGovernance(createBaseArgs({
|
|
profile: {
|
|
...strictProfileArtifact,
|
|
spec: {
|
|
...strictProfileArtifact.spec,
|
|
package: { pluginVersion: '0.9.9-mismatch' },
|
|
},
|
|
},
|
|
runtime: createStubRuntime(),
|
|
}));
|
|
|
|
assert.equal(result.preflight.status, 'fail_closed');
|
|
assert.equal(result.runtimeIntegration.attempted, false);
|
|
assert.equal(result.runtimeIntegration.reason, 'runtime execution not attempted: compatibility preflight did not pass');
|
|
assert.equal(result.runtimeExecution, null);
|
|
});
|
|
|
|
test('runtime-integrated route matrix: missing deploymentBinding blocks runtime route', () => {
|
|
const profileWithoutBindings = {
|
|
...strictProfileArtifact,
|
|
spec: {
|
|
...strictProfileArtifact.spec,
|
|
},
|
|
};
|
|
delete profileWithoutBindings.spec.bindings;
|
|
|
|
const result = executeRuntimeIntegratedGovernance(createBaseArgs({
|
|
profile: profileWithoutBindings,
|
|
runtime: createStubRuntime(),
|
|
}));
|
|
|
|
assert.equal(result.preflight.status, 'pass');
|
|
assert.equal(result.deploymentBinding, null);
|
|
assert.equal(result.runtimeIntegration.attempted, false);
|
|
assert.equal(result.runtimeIntegration.reason, 'runtime execution not attempted: deployment binding is missing');
|
|
assert.equal(result.runtimeExecution, null);
|
|
});
|
|
|
|
test('runtime-integrated route matrix: unknown adapter_action stays planning-only', () => {
|
|
const result = executeRuntimeIntegratedGovernance(createBaseArgs({
|
|
policyPacks: [unknownActionPack],
|
|
runtime: createStubRuntime(),
|
|
}));
|
|
|
|
assert.equal(result.preflight.status, 'pass');
|
|
assert.deepEqual(result.contract.adapter_actions, []);
|
|
assert.deepEqual(result.contract.blocked_actions, ['rewrite_message']);
|
|
assert.equal(result.runtimeIntegration.attempted, false);
|
|
assert.equal(result.runtimeIntegration.reason, 'runtime execution not attempted: no adapter_action matched an adapter runner route');
|
|
assert.equal(result.runtimeExecution, null);
|
|
});
|
|
|
|
test('runtime-integrated route matrix: matched adapter_action runs orchestrator adapter runner', () => {
|
|
const root = createFixtureRoot();
|
|
try {
|
|
mkdirs(root, ['evidence', 'events', 'queue', 'spool', 'receipts']);
|
|
const statePath = writeState(root);
|
|
|
|
const result = executeRuntimeIntegratedGovernance(createBaseArgs({
|
|
runtime: {
|
|
state: statePath,
|
|
evidenceDir: path.join(root, 'evidence'),
|
|
eventDir: path.join(root, 'events'),
|
|
queueDir: path.join(root, 'queue'),
|
|
spoolDir: path.join(root, 'spool'),
|
|
receiptDir: path.join(root, 'receipts'),
|
|
writeState: true,
|
|
dryRun: true,
|
|
now: '2026-05-07T08:20:00.000Z',
|
|
},
|
|
}));
|
|
|
|
assert.equal(result.preflight.status, 'pass');
|
|
assert.equal(result.contract.decision, 'force_checkpoint');
|
|
assert.equal(result.runtimeIntegration.attempted, true);
|
|
assert.equal(result.runtimeIntegration.adapter, 'orchestrator');
|
|
assert.equal(result.runtimeIntegration.action, 'notify_operator');
|
|
assert.equal(result.runtimeIntegration.reason, 'adapter_action notify_operator routed to orchestrator adapter runner');
|
|
assert.equal(result.runtimeExecution.ok, true);
|
|
assert.equal(result.runtimeExecution.result.dispatcher.dispatchedCount, 1);
|
|
assert.equal(result.runtimeExecution.result.supervisor.pendingCount, 1);
|
|
|
|
const queueItem = readSingleJson(path.join(root, 'queue'));
|
|
assert.equal(queueItem.status, 'dispatched');
|
|
|
|
const receipt = readSingleJson(path.join(root, 'receipts'));
|
|
assert.equal(receipt.state, 'pending_external_send');
|
|
assert.equal(receipt.supervisor_mode, 'dry_run');
|
|
} finally {
|
|
fs.rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|