mirror of
https://github.com/PR0M3TH3AN/TORCH.git
synced 2026-10-29 00:41:58 +00:00
Merge branch 'main' into test/upload-validation-15691315589845316357
This commit is contained in:
33 files changed
+9337
-1079
No files matched your search
@@ -0,0 +1,11 @@
|
||||
# Memory Update — content-audit-agent — 2026-02-21
|
||||
|
||||
## Key findings
|
||||
- CLI help text (`USAGE_TEXT`) can drift from implementation (`src/lib.mjs`) if not actively audited.
|
||||
- `package.json` scripts do not cover all `torch-lock` CLI commands (e.g. `proposal`, `rollback`, `backup`).
|
||||
|
||||
## Patterns / reusable knowledge
|
||||
- Always cross-reference `bin/torch-lock.mjs --help` against `README.md` and `src/lib.mjs` command handlers.
|
||||
|
||||
## Warnings / gotchas
|
||||
- `npm run validate:docs` only checks links, not command accuracy or completeness.
|
||||
Generated
+41
-70
@@ -17,7 +17,7 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^10.0.1",
|
||||
"eslint": "^10.0.0",
|
||||
"eslint": "^10.0.1",
|
||||
"globals": "^17.3.0"
|
||||
},
|
||||
"engines": {
|
||||
@@ -67,15 +67,15 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@eslint/config-array": {
|
||||
"version": "0.23.1",
|
||||
"resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.1.tgz",
|
||||
"integrity": "sha512-uVSdg/V4dfQmTjJzR0szNczjOH/J+FyUMMjYtr07xFRXR7EDf9i1qdxrD0VusZH9knj1/ecxzCQQxyic5NzAiA==",
|
||||
"version": "0.23.2",
|
||||
"resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.2.tgz",
|
||||
"integrity": "sha512-YF+fE6LV4v5MGWRGj7G404/OZzGNepVF8fxk7jqmqo3lrza7a0uUcDnROGRBG1WFC1omYUS/Wp1f42i0M+3Q3A==",
|
||||
"dev": true,
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@eslint/object-schema": "^3.0.1",
|
||||
"@eslint/object-schema": "^3.0.2",
|
||||
"debug": "^4.3.1",
|
||||
"minimatch": "^10.1.1"
|
||||
"minimatch": "^10.2.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": "^20.19.0 || ^22.13.0 || >=24"
|
||||
@@ -129,9 +129,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@eslint/object-schema": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.1.tgz",
|
||||
"integrity": "sha512-P9cq2dpr+LU8j3qbLygLcSZrl2/ds/pUpfnHNNuk5HW7mnngHs+6WSq5C9mO3rqRX8A1poxqLTC9cu0KOyJlBg==",
|
||||
"version": "3.0.2",
|
||||
"resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.2.tgz",
|
||||
"integrity": "sha512-HOy56KJt48Bx8KmJ+XGQNSUMT/6dZee/M54XyUyuvTvPXJmsERRvBchsUVx1UMe1WwIH49XLAczNC7V2INsuUw==",
|
||||
"dev": true,
|
||||
"license": "Apache-2.0",
|
||||
"engines": {
|
||||
@@ -204,16 +204,6 @@
|
||||
"url": "https://github.com/sponsors/nzakas"
|
||||
}
|
||||
},
|
||||
"node_modules/@isaacs/cliui": {
|
||||
"version": "9.0.0",
|
||||
"resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz",
|
||||
"integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==",
|
||||
"dev": true,
|
||||
"license": "BlueOak-1.0.0",
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
}
|
||||
},
|
||||
"node_modules/@noble/ciphers": {
|
||||
"version": "2.1.1",
|
||||
"resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-2.1.1.tgz",
|
||||
@@ -311,9 +301,9 @@
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/acorn": {
|
||||
"version": "8.15.0",
|
||||
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
|
||||
"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
|
||||
"version": "8.16.0",
|
||||
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
|
||||
"integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"bin": {
|
||||
@@ -334,9 +324,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/ajv": {
|
||||
"version": "6.12.6",
|
||||
"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
|
||||
"integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
|
||||
"version": "6.14.0",
|
||||
"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
|
||||
"integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -351,14 +341,11 @@
|
||||
}
|
||||
},
|
||||
"node_modules/balanced-match": {
|
||||
"version": "4.0.2",
|
||||
"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.2.tgz",
|
||||
"integrity": "sha512-x0K50QvKQ97fdEz2kPehIerj+YTeptKF9hyYkKf6egnwmMWAkADiO0QCzSp0R5xN8FTZgYaBfSaue46Ej62nMg==",
|
||||
"version": "4.0.3",
|
||||
"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.3.tgz",
|
||||
"integrity": "sha512-1pHv8LX9CpKut1Zp4EXey7Z8OfH11ONNH6Dhi2WDUt31VVZFXZzKwXcysBgqSumFCmR+0dqjMK5v5JiFHzi0+g==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"jackspeak": "^4.2.3"
|
||||
},
|
||||
"engines": {
|
||||
"node": "20 || >=22"
|
||||
}
|
||||
@@ -430,15 +417,15 @@
|
||||
}
|
||||
},
|
||||
"node_modules/eslint": {
|
||||
"version": "10.0.0",
|
||||
"resolved": "https://registry.npmjs.org/eslint/-/eslint-10.0.0.tgz",
|
||||
"integrity": "sha512-O0piBKY36YSJhlFSG8p9VUdPV/SxxS4FYDWVpr/9GJuMaepzwlf4J8I4ov1b+ySQfDTPhc3DtLaxcT1fN0yqCg==",
|
||||
"version": "10.0.1",
|
||||
"resolved": "https://registry.npmjs.org/eslint/-/eslint-10.0.1.tgz",
|
||||
"integrity": "sha512-20MV9SUdeN6Jd84xESsKhRly+/vxI+hwvpBMA93s+9dAcjdCuCojn4IqUGS3lvVaqjVYGYHSRMCpeFtF2rQYxQ==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@eslint-community/eslint-utils": "^4.8.0",
|
||||
"@eslint-community/regexpp": "^4.12.2",
|
||||
"@eslint/config-array": "^0.23.0",
|
||||
"@eslint/config-array": "^0.23.2",
|
||||
"@eslint/config-helpers": "^0.5.2",
|
||||
"@eslint/core": "^1.1.0",
|
||||
"@eslint/plugin-kit": "^0.6.0",
|
||||
@@ -450,9 +437,9 @@
|
||||
"cross-spawn": "^7.0.6",
|
||||
"debug": "^4.3.2",
|
||||
"escape-string-regexp": "^4.0.0",
|
||||
"eslint-scope": "^9.1.0",
|
||||
"eslint-visitor-keys": "^5.0.0",
|
||||
"espree": "^11.1.0",
|
||||
"eslint-scope": "^9.1.1",
|
||||
"eslint-visitor-keys": "^5.0.1",
|
||||
"espree": "^11.1.1",
|
||||
"esquery": "^1.7.0",
|
||||
"esutils": "^2.0.2",
|
||||
"fast-deep-equal": "^3.1.3",
|
||||
@@ -463,7 +450,7 @@
|
||||
"imurmurhash": "^0.1.4",
|
||||
"is-glob": "^4.0.0",
|
||||
"json-stable-stringify-without-jsonify": "^1.0.1",
|
||||
"minimatch": "^10.1.1",
|
||||
"minimatch": "^10.2.1",
|
||||
"natural-compare": "^1.4.0",
|
||||
"optionator": "^0.9.3"
|
||||
},
|
||||
@@ -486,9 +473,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/eslint-scope": {
|
||||
"version": "9.1.0",
|
||||
"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.0.tgz",
|
||||
"integrity": "sha512-CkWE42hOJsNj9FJRaoMX9waUFYhqY4jmyLFdAdzZr6VaCg3ynLYx4WnOdkaIifGfH4gsUcBTn4OZbHXkpLD0FQ==",
|
||||
"version": "9.1.1",
|
||||
"resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.1.tgz",
|
||||
"integrity": "sha512-GaUN0sWim5qc8KVErfPBWmc31LEsOkrUJbvJZV+xuL3u2phMUK4HIvXlWAakfC8W4nzlK+chPEAkYOYb5ZScIw==",
|
||||
"dev": true,
|
||||
"license": "BSD-2-Clause",
|
||||
"dependencies": {
|
||||
@@ -505,9 +492,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/eslint-visitor-keys": {
|
||||
"version": "5.0.0",
|
||||
"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.0.tgz",
|
||||
"integrity": "sha512-A0XeIi7CXU7nPlfHS9loMYEKxUaONu/hTEzHTGba9Huu94Cq1hPivf+DE5erJozZOky0LfvXAyrV/tcswpLI0Q==",
|
||||
"version": "5.0.1",
|
||||
"resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
|
||||
"integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
|
||||
"dev": true,
|
||||
"license": "Apache-2.0",
|
||||
"engines": {
|
||||
@@ -518,15 +505,15 @@
|
||||
}
|
||||
},
|
||||
"node_modules/espree": {
|
||||
"version": "11.1.0",
|
||||
"resolved": "https://registry.npmjs.org/espree/-/espree-11.1.0.tgz",
|
||||
"integrity": "sha512-WFWYhO1fV4iYkqOOvq8FbqIhr2pYfoDY0kCotMkDeNtGpiGGkZ1iov2u8ydjtgM8yF8rzK7oaTbw2NAzbAbehw==",
|
||||
"version": "11.1.1",
|
||||
"resolved": "https://registry.npmjs.org/espree/-/espree-11.1.1.tgz",
|
||||
"integrity": "sha512-AVHPqQoZYc+RUM4/3Ly5udlZY/U4LS8pIG05jEjWM2lQMU/oaZ7qshzAl2YP1tfNmXfftH3ohurfwNAug+MnsQ==",
|
||||
"dev": true,
|
||||
"license": "BSD-2-Clause",
|
||||
"dependencies": {
|
||||
"acorn": "^8.15.0",
|
||||
"acorn": "^8.16.0",
|
||||
"acorn-jsx": "^5.3.2",
|
||||
"eslint-visitor-keys": "^5.0.0"
|
||||
"eslint-visitor-keys": "^5.0.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": "^20.19.0 || ^22.13.0 || >=24"
|
||||
@@ -729,22 +716,6 @@
|
||||
"dev": true,
|
||||
"license": "ISC"
|
||||
},
|
||||
"node_modules/jackspeak": {
|
||||
"version": "4.2.3",
|
||||
"resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz",
|
||||
"integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==",
|
||||
"dev": true,
|
||||
"license": "BlueOak-1.0.0",
|
||||
"dependencies": {
|
||||
"@isaacs/cliui": "^9.0.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": "20 || >=22"
|
||||
},
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/isaacs"
|
||||
}
|
||||
},
|
||||
"node_modules/json-buffer": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
|
||||
@@ -807,16 +778,16 @@
|
||||
}
|
||||
},
|
||||
"node_modules/minimatch": {
|
||||
"version": "10.2.0",
|
||||
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.0.tgz",
|
||||
"integrity": "sha512-ugkC31VaVg9cF0DFVoADH12k6061zNZkZON+aX8AWsR9GhPcErkcMBceb6znR8wLERM2AkkOxy2nWRLpT9Jq5w==",
|
||||
"version": "10.2.2",
|
||||
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.2.tgz",
|
||||
"integrity": "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw==",
|
||||
"dev": true,
|
||||
"license": "BlueOak-1.0.0",
|
||||
"dependencies": {
|
||||
"brace-expansion": "^5.0.2"
|
||||
},
|
||||
"engines": {
|
||||
"node": "20 || >=22"
|
||||
"node": "18 || 20 || >=22"
|
||||
},
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/isaacs"
|
||||
|
||||
+1
-1
@@ -78,7 +78,7 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"@eslint/js": "^10.0.1",
|
||||
"eslint": "^10.0.0",
|
||||
"eslint": "^10.0.1",
|
||||
"globals": "^17.3.0"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
# Prompt Safety Audit Report - 2026-02-21T18-27-45
|
||||
|
||||
**Total Prompts:** 44
|
||||
**Safe:** 44
|
||||
**Needs Review:** 0
|
||||
|
||||
## Findings
|
||||
|
||||
| Filename | Status | Has Safety Section | Forceful Keywords (Approx) |
|
||||
|---|---|---|---|
|
||||
| audit-agent.md | SAFE | Yes | 11 |
|
||||
| ci-health-agent.md | SAFE | Yes | 11 |
|
||||
| const-refactor-agent.md | SAFE | Yes | 13 |
|
||||
| content-audit-agent.md | SAFE | Yes | 11 |
|
||||
| decompose-agent.md | SAFE | Yes | 16 |
|
||||
| deps-security-agent.md | SAFE | Yes | 18 |
|
||||
| design-system-audit-agent.md | SAFE | Yes | 14 |
|
||||
| docs-agent.md | SAFE | Yes | 16 |
|
||||
| docs-alignment-agent.md | SAFE | Yes | 16 |
|
||||
| docs-code-investigator.md | SAFE | Yes | 12 |
|
||||
| governance-agent.md | SAFE | Yes | 9 |
|
||||
| innerhtml-migration-agent.md | SAFE | Yes | 14 |
|
||||
| known-issues-agent.md | SAFE | Yes | 14 |
|
||||
| load-test-agent.md | SAFE | Yes | 15 |
|
||||
| log-fixer-agent.md | SAFE | Yes | 11 |
|
||||
| onboarding-audit-agent.md | SAFE | Yes | 14 |
|
||||
| perf-agent.md | SAFE | Yes | 13 |
|
||||
| protocol-research-agent.md | SAFE | Yes | 10 |
|
||||
| scheduler-update-agent.md | SAFE | Yes | 10 |
|
||||
| style-agent.md | SAFE | Yes | 11 |
|
||||
| test-audit-agent.md | SAFE | Yes | 10 |
|
||||
| todo-triage-agent.md | SAFE | Yes | 15 |
|
||||
| torch-garbage-collection-agent.md | SAFE | Yes | 10 |
|
||||
| bug-reproducer-agent.md | SAFE | Yes | 14 |
|
||||
| changelog-agent.md | SAFE | Yes | 14 |
|
||||
| dead-code-agent.md | SAFE | Yes | 16 |
|
||||
| feature-proposer-agent.md | SAFE | Yes | 10 |
|
||||
| frontend-console-debug-agent.md | SAFE | Yes | 13 |
|
||||
| fuzz-agent.md | SAFE | Yes | 14 |
|
||||
| perf-deepdive-agent.md | SAFE | Yes | 14 |
|
||||
| perf-optimization-agent.md | SAFE | Yes | 11 |
|
||||
| pr-review-agent.md | SAFE | Yes | 11 |
|
||||
| prompt-fixer-agent.md | SAFE | Yes | 9 |
|
||||
| prompt-gap-analysis-agent.md | SAFE | Yes | 8 |
|
||||
| prompt-maintenance-agent.md | SAFE | Yes | 10 |
|
||||
| prompt-safety-agent.md | SAFE | Yes | 15 |
|
||||
| race-condition-agent.md | SAFE | Yes | 12 |
|
||||
| refactor-agent.md | SAFE | Yes | 14 |
|
||||
| repo-fit-agent.md | SAFE | Yes | 10 |
|
||||
| smoke-agent.md | SAFE | Yes | 12 |
|
||||
| telemetry-agent.md | SAFE | Yes | 11 |
|
||||
| test-coverage-agent.md | SAFE | Yes | 17 |
|
||||
| ui-ux-agent.md | SAFE | Yes | 9 |
|
||||
| weekly-synthesis-agent.md | SAFE | Yes | 13 |
|
||||
|
||||
## Recommendations
|
||||
- Review prompts marked 'NEEDS_REVIEW'.
|
||||
- Ensure all prompts have a 'FAILURE MODES' or 'EXIT CRITERIA' section.
|
||||
+10
-7
@@ -2,8 +2,6 @@ import fs from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
import { execSync } from 'node:child_process';
|
||||
|
||||
const BACKUP_ROOT = path.resolve(process.cwd(), '.torch/backups');
|
||||
|
||||
// Paths to snapshot on each backup run
|
||||
const STATE_SOURCES = [
|
||||
'.scheduler-memory/memory-store.json',
|
||||
@@ -22,19 +20,21 @@ const STATE_SOURCES = [
|
||||
*
|
||||
* @param {Object} [opts]
|
||||
* @param {string|null} [opts.output] - Override destination directory (default: .torch/backups/<ts>)
|
||||
* @param {string} [opts.cwd] - Working directory (default: process.cwd())
|
||||
* @returns {Promise<{backupDir: string, manifest: Object}>}
|
||||
*/
|
||||
export async function cmdBackup({ output = null } = {}) {
|
||||
export async function cmdBackup({ output = null, cwd = process.cwd() } = {}) {
|
||||
const BACKUP_ROOT = path.resolve(cwd, '.torch/backups');
|
||||
const ts = new Date().toISOString().replace(/[:.]/g, '-');
|
||||
const backupDir = output
|
||||
? path.resolve(process.cwd(), output)
|
||||
? path.resolve(cwd, output)
|
||||
: path.join(BACKUP_ROOT, ts);
|
||||
|
||||
await fs.mkdir(backupDir, { recursive: true });
|
||||
|
||||
let gitCommit = null;
|
||||
try {
|
||||
gitCommit = execSync('git rev-parse HEAD', { stdio: 'pipe' }).toString().trim();
|
||||
gitCommit = execSync('git rev-parse HEAD', { stdio: 'pipe', cwd }).toString().trim();
|
||||
} catch {
|
||||
// Not in a git repo or git unavailable
|
||||
}
|
||||
@@ -43,7 +43,7 @@ export async function cmdBackup({ output = null } = {}) {
|
||||
const skipped = [];
|
||||
|
||||
for (const relPath of STATE_SOURCES) {
|
||||
const src = path.resolve(process.cwd(), relPath);
|
||||
const src = path.resolve(cwd, relPath);
|
||||
const dest = path.join(backupDir, relPath.replace(/\//g, '__'));
|
||||
try {
|
||||
await fs.copyFile(src, dest);
|
||||
@@ -77,9 +77,12 @@ export async function cmdBackup({ output = null } = {}) {
|
||||
/**
|
||||
* Lists all available backups under .torch/backups/, newest first.
|
||||
*
|
||||
* @param {Object} [opts]
|
||||
* @param {string} [opts.cwd] - Working directory (default: process.cwd())
|
||||
* @returns {Promise<Array<{id: string, createdAt: string|null, backupDir: string}>>}
|
||||
*/
|
||||
export async function listBackups() {
|
||||
export async function listBackups({ cwd = process.cwd() } = {}) {
|
||||
const BACKUP_ROOT = path.resolve(cwd, '.torch/backups');
|
||||
try {
|
||||
const entries = await fs.readdir(BACKUP_ROOT, { withFileTypes: true });
|
||||
const backups = [];
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
import { generateSecretKey as _generateSecretKey, getPublicKey as _getPublicKey, finalizeEvent as _finalizeEvent } from 'nostr-tools/pure';
|
||||
import {
|
||||
getRelays as _getRelays,
|
||||
getNamespace as _getNamespace,
|
||||
getHashtag as _getHashtag,
|
||||
getTtl as _getTtl,
|
||||
} from './torch-config.mjs';
|
||||
import {
|
||||
KIND_APP_DATA,
|
||||
RACE_CHECK_DELAY_MS,
|
||||
MS_PER_SECOND,
|
||||
} from './constants.mjs';
|
||||
import { getRoster as _getRoster } from './roster.mjs';
|
||||
import { queryLocks as _queryLocks, publishLock as _publishLock } from './lock-ops.mjs';
|
||||
import { ExitError } from './errors.mjs';
|
||||
import { todayDateStr, nowUnix, detectPlatform } from './utils.mjs';
|
||||
import fs from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { execSync } from 'node:child_process';
|
||||
|
||||
function getGitCommit() {
|
||||
try {
|
||||
return execSync('git rev-parse HEAD', { stdio: 'pipe' }).toString().trim();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function getPromptInfo(agent, cadence) {
|
||||
try {
|
||||
const potentialPath = path.join(process.cwd(), 'src', 'prompts', cadence, `${agent}.md`);
|
||||
const content = await fs.readFile(potentialPath, 'utf8');
|
||||
const promptHash = createHash('sha256').update(content).digest('hex');
|
||||
const promptPath = `src/prompts/${cadence}/${agent}.md`;
|
||||
return { promptHash, promptPath };
|
||||
} catch {
|
||||
return { promptHash: null, promptPath: null };
|
||||
}
|
||||
}
|
||||
|
||||
function validateRoster(agent, roster, cadence, error) {
|
||||
if (!roster.includes(agent)) {
|
||||
error(`ERROR: agent "${agent}" is not in the ${cadence} roster`);
|
||||
error(`Allowed ${cadence} agents: ${roster.join(', ')}`);
|
||||
throw new ExitError(1, 'Agent not in roster');
|
||||
}
|
||||
}
|
||||
|
||||
function checkExistingLocks(existingLocks, agent, error, log) {
|
||||
const conflicting = existingLocks.filter((l) => l.agent === agent);
|
||||
|
||||
if (conflicting.length > 0) {
|
||||
const earliest = conflicting.sort((a, b) => a.createdAt - b.createdAt)[0];
|
||||
|
||||
if (earliest.status === 'completed') {
|
||||
error(`LOCK DENIED: Task already completed by event ${earliest.eventId}`);
|
||||
log('LOCK_STATUS=denied');
|
||||
log('LOCK_REASON=already_completed');
|
||||
throw new ExitError(3, 'Task already completed');
|
||||
}
|
||||
|
||||
error(
|
||||
`LOCK DENIED: ${agent} already locked by event ${earliest.eventId} ` +
|
||||
`(created ${earliest.createdAtIso}, platform: ${earliest.platform})`,
|
||||
);
|
||||
log('LOCK_STATUS=denied');
|
||||
log('LOCK_REASON=already_locked');
|
||||
log(`LOCK_EXISTING_EVENT=${earliest.eventId}`);
|
||||
throw new ExitError(3, 'Lock denied');
|
||||
}
|
||||
}
|
||||
|
||||
function buildLockEvent(agent, cadence, namespace, hashtag, dateStr, now, expiresAt, platform, model, gitCommit, promptPath, promptHash, finalizeEvent, sk) {
|
||||
return finalizeEvent(
|
||||
{
|
||||
kind: KIND_APP_DATA,
|
||||
created_at: now,
|
||||
tags: [
|
||||
['d', `${namespace}-lock/${cadence}/${agent}/${dateStr}`],
|
||||
['t', hashtag],
|
||||
['t', `${namespace}-lock-${cadence}`],
|
||||
['t', `${namespace}-lock-${cadence}-${dateStr}`],
|
||||
['expiration', String(expiresAt)],
|
||||
],
|
||||
content: JSON.stringify({
|
||||
agent,
|
||||
cadence,
|
||||
status: 'started',
|
||||
namespace,
|
||||
date: dateStr,
|
||||
platform: platform || process.env.AGENT_PLATFORM || detectPlatform() || 'unknown',
|
||||
model: model || process.env.AGENT_MODEL || 'unknown',
|
||||
lockedAt: new Date(now * MS_PER_SECOND).toISOString(),
|
||||
expiresAt: new Date(expiresAt * MS_PER_SECOND).toISOString(),
|
||||
gitCommit,
|
||||
promptPath,
|
||||
promptHash,
|
||||
}),
|
||||
},
|
||||
sk,
|
||||
);
|
||||
}
|
||||
|
||||
async function performRaceCheck(relays, cadence, dateStr, namespace, agent, myEventId, queryLocks, raceCheckDelayMs, error, log) {
|
||||
await new Promise((resolve) => setTimeout(resolve, raceCheckDelayMs));
|
||||
|
||||
const postLocks = await queryLocks(relays, cadence, dateStr, namespace);
|
||||
const racingLocks = postLocks
|
||||
.filter((l) => l.agent === agent)
|
||||
.sort((a, b) => (a.createdAt - b.createdAt) || String(a.eventId).localeCompare(String(b.eventId)));
|
||||
|
||||
if (racingLocks.length > 1 && racingLocks[0].eventId !== myEventId) {
|
||||
const winner = racingLocks[0];
|
||||
error(
|
||||
`RACE CHECK: lost (earlier lock by event ${winner.eventId}, created ${winner.createdAtIso})`,
|
||||
);
|
||||
log('LOCK_STATUS=race_lost');
|
||||
log('LOCK_REASON=earlier_claim_exists');
|
||||
log(`LOCK_WINNER_EVENT=${winner.eventId}`);
|
||||
throw new ExitError(3, 'Race check lost');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to acquire an exclusive lock for an agent on the specified cadence.
|
||||
*
|
||||
* Algorithm:
|
||||
* 1. Validate agent against the roster.
|
||||
* 2. Query relays for existing valid locks (checking for conflicts).
|
||||
* 3. Generate a new ephemeral keypair and build a lock event (kind 30078).
|
||||
* 4. Publish the lock event to relays.
|
||||
* 5. Wait for propagation (raceCheckDelayMs) and re-query to confirm no earlier lock won the race.
|
||||
*
|
||||
* @param {string} agent - Agent name
|
||||
* @param {string} cadence - 'daily' or 'weekly'
|
||||
* @param {boolean} [dryRun=false] - If true, skips publishing
|
||||
* @param {Object} [deps] - Dependency injection
|
||||
* @returns {Promise<{status: string, eventId: string}>}
|
||||
* @throws {ExitError} If lock is denied (already locked, completed, or race lost)
|
||||
*/
|
||||
export async function cmdLock(agent, cadence, optionsOrDryRun = false, deps = {}) {
|
||||
const options = typeof optionsOrDryRun === 'object' ? optionsOrDryRun : { dryRun: !!optionsOrDryRun };
|
||||
const { dryRun = false, platform = null, model = null } = options;
|
||||
|
||||
const {
|
||||
getRelays = _getRelays,
|
||||
getNamespace = _getNamespace,
|
||||
getHashtag = _getHashtag,
|
||||
getTtl = _getTtl,
|
||||
queryLocks = _queryLocks,
|
||||
getRoster = _getRoster,
|
||||
publishLock = _publishLock,
|
||||
generateSecretKey = _generateSecretKey,
|
||||
getPublicKey = _getPublicKey,
|
||||
finalizeEvent = _finalizeEvent,
|
||||
raceCheckDelayMs = RACE_CHECK_DELAY_MS,
|
||||
getDateStr = todayDateStr,
|
||||
log = console.log,
|
||||
error = console.error
|
||||
} = deps;
|
||||
|
||||
const relays = await getRelays();
|
||||
const namespace = await getNamespace();
|
||||
const hashtag = await getHashtag();
|
||||
const dateStr = getDateStr();
|
||||
const ttl = await getTtl();
|
||||
const now = nowUnix();
|
||||
const expiresAt = now + ttl;
|
||||
|
||||
const gitCommit = getGitCommit();
|
||||
const { promptHash, promptPath } = await getPromptInfo(agent, cadence);
|
||||
|
||||
error(`Locking: namespace=${namespace}, agent=${agent}, cadence=${cadence}, date=${dateStr}`);
|
||||
error(`Hashtag: #${hashtag}`);
|
||||
error(`TTL: ${ttl}s, expires: ${new Date(expiresAt * MS_PER_SECOND).toISOString()}`);
|
||||
error(`Relays: ${relays.join(', ')}`);
|
||||
if (gitCommit) error(`Git Commit: ${gitCommit}`);
|
||||
if (promptHash) error(`Prompt Hash: ${promptHash.slice(0, 12)}...`);
|
||||
|
||||
const roster = await getRoster(cadence);
|
||||
validateRoster(agent, roster, cadence, error);
|
||||
|
||||
error('Step 1: Checking for existing locks...');
|
||||
const existingLocks = await queryLocks(relays, cadence, dateStr, namespace);
|
||||
checkExistingLocks(existingLocks, agent, error, log);
|
||||
|
||||
error('Step 2: Generating ephemeral keypair...');
|
||||
const sk = generateSecretKey();
|
||||
const pk = getPublicKey(sk);
|
||||
error(` Ephemeral pubkey: ${pk.slice(0, 16)}...`);
|
||||
|
||||
error('Step 3: Building lock event...');
|
||||
const event = buildLockEvent(agent, cadence, namespace, hashtag, dateStr, now, expiresAt, platform, model, gitCommit, promptPath, promptHash, finalizeEvent, sk);
|
||||
|
||||
error(` Event ID: ${event.id}`);
|
||||
|
||||
if (dryRun) {
|
||||
error('Step 4: [DRY RUN] Skipping publish — event built but not sent');
|
||||
error('RACE CHECK: won (dry run — no real contention possible)');
|
||||
} else {
|
||||
error('Step 4: Publishing to relays...');
|
||||
await publishLock(relays, event);
|
||||
|
||||
error('Step 5: Race check...');
|
||||
await performRaceCheck(relays, cadence, dateStr, namespace, agent, event.id, queryLocks, raceCheckDelayMs, error, log);
|
||||
|
||||
error('RACE CHECK: won');
|
||||
}
|
||||
|
||||
log('LOCK_STATUS=ok');
|
||||
log(`LOCK_EVENT_ID=${event.id}`);
|
||||
log(`LOCK_PUBKEY=${pk}`);
|
||||
log(`LOCK_AGENT=${agent}`);
|
||||
log(`LOCK_HASHTAG=${hashtag}`);
|
||||
log(`LOCK_CADENCE=${cadence}`);
|
||||
log(`LOCK_DATE=${dateStr}`);
|
||||
log(`LOCK_EXPIRES=${expiresAt}`);
|
||||
log(`LOCK_EXPIRES_ISO=${new Date(expiresAt * MS_PER_SECOND).toISOString()}`);
|
||||
if (gitCommit) log(`LOCK_GIT_COMMIT=${gitCommit}`);
|
||||
if (promptHash) log(`LOCK_PROMPT_HASH=${promptHash}`);
|
||||
return { status: 'ok', eventId: event.id };
|
||||
}
|
||||
+54
-37
@@ -1,99 +1,116 @@
|
||||
import { createProposal, listProposals, applyProposal, rejectProposal, getProposal } from './services/governance/index.js';
|
||||
import {
|
||||
createProposal as _createProposal,
|
||||
listProposals as _listProposals,
|
||||
applyProposal as _applyProposal,
|
||||
rejectProposal as _rejectProposal,
|
||||
getProposal as _getProposal
|
||||
} from './services/governance/index.js';
|
||||
import { ExitError } from './errors.mjs';
|
||||
import fs from 'node:fs/promises';
|
||||
|
||||
export async function cmdProposal(subcommand, args = {}) {
|
||||
export async function cmdProposal(subcommand, args = {}, deps = {}) {
|
||||
const {
|
||||
createProposal = _createProposal,
|
||||
listProposals = _listProposals,
|
||||
applyProposal = _applyProposal,
|
||||
rejectProposal = _rejectProposal,
|
||||
getProposal = _getProposal,
|
||||
readFile = fs.readFile,
|
||||
log = console.log,
|
||||
error = console.error
|
||||
} = deps;
|
||||
|
||||
switch (subcommand) {
|
||||
case 'create':
|
||||
return await handleCreate(args);
|
||||
return await handleCreate(args, { createProposal, readFile, log, error });
|
||||
case 'list':
|
||||
return await handleList(args);
|
||||
return await handleList(args, { listProposals, log, error });
|
||||
case 'apply':
|
||||
return await handleApply(args);
|
||||
return await handleApply(args, { applyProposal, log, error });
|
||||
case 'reject':
|
||||
return await handleReject(args);
|
||||
return await handleReject(args, { rejectProposal, log, error });
|
||||
case 'show':
|
||||
return await handleShow(args);
|
||||
return await handleShow(args, { getProposal, log, error });
|
||||
default:
|
||||
console.error(`Unknown proposal subcommand: ${subcommand}`);
|
||||
error(`Unknown proposal subcommand: ${subcommand}`);
|
||||
throw new ExitError(1, 'Unknown subcommand');
|
||||
}
|
||||
}
|
||||
|
||||
async function handleCreate({ agent, target, contentFile, reason }) {
|
||||
async function handleCreate({ agent, target, contentFile, reason }, { createProposal, readFile, log, error }) {
|
||||
if (!agent || !target || !contentFile || !reason) {
|
||||
console.error('Usage: torch-lock proposal create --agent <name> --target <path> --content <file> --reason <text>');
|
||||
error('Usage: torch-lock proposal create --agent <name> --target <path> --content <file> --reason <text>');
|
||||
throw new ExitError(1, 'Missing arguments');
|
||||
}
|
||||
|
||||
let newContent;
|
||||
try {
|
||||
newContent = await fs.readFile(contentFile, 'utf8');
|
||||
newContent = await readFile(contentFile, 'utf8');
|
||||
} catch (_e) {
|
||||
console.error(`Failed to read content file: ${contentFile}`);
|
||||
error(`Failed to read content file: ${contentFile}`);
|
||||
throw new ExitError(1, 'File read error');
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await createProposal({ agent, target, newContent, reason });
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
log(JSON.stringify(result, null, 2));
|
||||
} catch (e) {
|
||||
console.error(`Failed to create proposal: ${e.message}`);
|
||||
error(`Failed to create proposal: ${e.message}`);
|
||||
throw new ExitError(1, 'Proposal creation failed');
|
||||
}
|
||||
}
|
||||
|
||||
async function handleList({ status }) {
|
||||
async function handleList({ status }, { listProposals, log, error }) {
|
||||
try {
|
||||
const proposals = await listProposals();
|
||||
const filtered = status ? proposals.filter(p => p.status === status) : proposals;
|
||||
console.log(JSON.stringify(filtered, null, 2));
|
||||
log(JSON.stringify(filtered, null, 2));
|
||||
} catch (e) {
|
||||
console.error(`Failed to list proposals: ${e.message}`);
|
||||
error(`Failed to list proposals: ${e.message}`);
|
||||
throw new ExitError(1, 'List failed');
|
||||
}
|
||||
}
|
||||
|
||||
async function handleApply({ id }) {
|
||||
async function handleApply({ id }, { applyProposal, log, error }) {
|
||||
if (!id) {
|
||||
console.error('Usage: torch-lock proposal apply --id <proposal-id>');
|
||||
error('Usage: torch-lock proposal apply --id <proposal-id>');
|
||||
throw new ExitError(1, 'Missing id');
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await applyProposal(id);
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
log(JSON.stringify(result, null, 2));
|
||||
} catch (e) {
|
||||
console.error(`Failed to apply proposal: ${e.message}`);
|
||||
error(`Failed to apply proposal: ${e.message}`);
|
||||
throw new ExitError(1, 'Apply failed');
|
||||
}
|
||||
}
|
||||
|
||||
async function handleReject({ id, reason }) {
|
||||
async function handleReject({ id, reason }, { rejectProposal, log, error }) {
|
||||
if (!id || !reason) {
|
||||
console.error('Usage: torch-lock proposal reject --id <proposal-id> --reason <text>');
|
||||
error('Usage: torch-lock proposal reject --id <proposal-id> --reason <text>');
|
||||
throw new ExitError(1, 'Missing arguments');
|
||||
}
|
||||
|
||||
try {
|
||||
const result = await rejectProposal(id, reason);
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
log(JSON.stringify(result, null, 2));
|
||||
} catch (e) {
|
||||
console.error(`Failed to reject proposal: ${e.message}`);
|
||||
error(`Failed to reject proposal: ${e.message}`);
|
||||
throw new ExitError(1, 'Reject failed');
|
||||
}
|
||||
}
|
||||
|
||||
async function handleShow({ id }) {
|
||||
if (!id) {
|
||||
console.error('Usage: torch-lock proposal show --id <proposal-id>');
|
||||
throw new ExitError(1, 'Missing id');
|
||||
}
|
||||
try {
|
||||
const proposal = await getProposal(id);
|
||||
console.log(JSON.stringify(proposal, null, 2));
|
||||
} catch (e) {
|
||||
console.error(`Failed to show proposal: ${e.message}`);
|
||||
throw new ExitError(1, 'Show failed');
|
||||
}
|
||||
async function handleShow({ id }, { getProposal, log, error }) {
|
||||
if (!id) {
|
||||
error('Usage: torch-lock proposal show --id <proposal-id>');
|
||||
throw new ExitError(1, 'Missing id');
|
||||
}
|
||||
try {
|
||||
const proposal = await getProposal(id);
|
||||
log(JSON.stringify(proposal, null, 2));
|
||||
} catch (e) {
|
||||
error(`Failed to show proposal: ${e.message}`);
|
||||
throw new ExitError(1, 'Show failed');
|
||||
}
|
||||
}
|
||||
@@ -53,6 +53,9 @@ Commands:
|
||||
init [--force] Initialize torch/ directory in current project
|
||||
update [--force] Update torch/ configuration (backups, merges)
|
||||
remove [--force] Remove all TORCH files and configuration from project
|
||||
backup [--list] [--output <path>] Snapshot runtime state to .torch/backups/
|
||||
proposal <create|list|apply|reject|show> [...] Manage prompt change proposals
|
||||
rollback --target <file> [--list] Roll back a prompt to a previous version
|
||||
|
||||
list-memories [--agent <id>] [--type <type>] [--tags <a,b>] [--pinned <true|false>] [--full]
|
||||
inspect-memory --id <memoryId>
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
---
|
||||
agent: content-audit-agent
|
||||
cadence: daily
|
||||
session: 2026-02-21T18-44-11Z
|
||||
run-start: 2026-02-21T18-44-11Z
|
||||
prompt: src/prompts/daily/content-audit-agent.md
|
||||
---
|
||||
# Context Note — Content Audit — 2026-02-21
|
||||
|
||||
## Goal
|
||||
Verify documentation accuracy against repository implementation.
|
||||
|
||||
## Scope
|
||||
- `README.md`
|
||||
- `TORCH.md`
|
||||
- `bin/torch-lock.mjs`
|
||||
- `src/constants.mjs`
|
||||
|
||||
## Findings
|
||||
- `USAGE_TEXT` in `src/constants.mjs` was missing `proposal`, `rollback`, and `backup` commands, despite them being implemented and documented.
|
||||
- `README.md` correctly lists these commands.
|
||||
- `npm run validate:docs` passed.
|
||||
|
||||
## Constraints
|
||||
- Limited to correcting specific inaccuracies.
|
||||
+73
-1
@@ -31,16 +31,72 @@ function timingSafeCompare(a, b) {
|
||||
return crypto.timingSafeEqual(bufA, bufB);
|
||||
}
|
||||
|
||||
function verifyPassword(input, stored) {
|
||||
if (stored.startsWith('scrypt:')) {
|
||||
const parts = stored.split(':');
|
||||
if (parts.length !== 3) return false;
|
||||
try {
|
||||
const salt = Buffer.from(parts[1], 'hex');
|
||||
const hash = Buffer.from(parts[2], 'hex');
|
||||
const derived = crypto.scryptSync(input, salt, 64);
|
||||
return crypto.timingSafeEqual(derived, hash);
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return timingSafeCompare(input, stored);
|
||||
}
|
||||
|
||||
export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT, host = '127.0.0.1') {
|
||||
// Resolve package root relative to this file (src/dashboard.mjs)
|
||||
// this file is in <root>/src/dashboard.mjs, so '..' goes to <root>
|
||||
const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
||||
const auth = await getDashboardAuth();
|
||||
|
||||
// Rate limiting state
|
||||
const MAX_AUTH_ATTEMPTS = 5;
|
||||
const BLOCK_DURATION_MS = 300000; // 5 minutes
|
||||
const CLEANUP_INTERVAL_MS = 600000; // 10 minutes
|
||||
const rateLimit = new Map(); // ip -> { attempts, blockExpires, lastSeen }
|
||||
|
||||
// Cleanup old entries
|
||||
const cleanupInterval = setInterval(() => {
|
||||
const now = Date.now();
|
||||
for (const [ip, data] of rateLimit.entries()) {
|
||||
if (data.blockExpires && data.blockExpires < now) {
|
||||
rateLimit.delete(ip);
|
||||
} else if (!data.blockExpires && (now - data.lastSeen > CLEANUP_INTERVAL_MS)) {
|
||||
rateLimit.delete(ip);
|
||||
}
|
||||
}
|
||||
}, CLEANUP_INTERVAL_MS);
|
||||
|
||||
const server = http.createServer(async (req, res) => {
|
||||
try {
|
||||
// Basic Auth check
|
||||
if (auth) {
|
||||
const clientIp = req.socket.remoteAddress;
|
||||
const now = Date.now();
|
||||
|
||||
// Check rate limit
|
||||
const clientState = rateLimit.get(clientIp) || { attempts: 0, blockExpires: 0, lastSeen: now };
|
||||
|
||||
// Update last seen
|
||||
clientState.lastSeen = now;
|
||||
|
||||
if (clientState.blockExpires > now) {
|
||||
res.writeHead(429, {
|
||||
...SECURITY_HEADERS,
|
||||
'Retry-After': Math.ceil((clientState.blockExpires - now) / 1000)
|
||||
});
|
||||
res.end('Too Many Requests');
|
||||
return;
|
||||
} else if (clientState.blockExpires) {
|
||||
// Block expired, reset state
|
||||
clientState.attempts = 0;
|
||||
clientState.blockExpires = 0;
|
||||
}
|
||||
|
||||
const authHeader = req.headers.authorization;
|
||||
if (!authHeader) {
|
||||
res.writeHead(401, { ...SECURITY_HEADERS, 'WWW-Authenticate': 'Basic realm="TORCH Dashboard"' });
|
||||
@@ -54,17 +110,29 @@ export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT, host = '127.0.
|
||||
if (type === 'Basic' && credentials) {
|
||||
try {
|
||||
const decoded = Buffer.from(credentials, 'base64').toString();
|
||||
isValid = timingSafeCompare(decoded, auth);
|
||||
isValid = verifyPassword(decoded, auth);
|
||||
} catch {
|
||||
isValid = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!isValid) {
|
||||
// Increment attempts
|
||||
clientState.attempts += 1;
|
||||
if (clientState.attempts >= MAX_AUTH_ATTEMPTS) {
|
||||
clientState.blockExpires = Date.now() + BLOCK_DURATION_MS;
|
||||
}
|
||||
rateLimit.set(clientIp, clientState);
|
||||
|
||||
res.writeHead(401, { ...SECURITY_HEADERS, 'WWW-Authenticate': 'Basic realm="TORCH Dashboard"' });
|
||||
res.end('Invalid credentials');
|
||||
return;
|
||||
}
|
||||
|
||||
// Reset attempts on success
|
||||
if (rateLimit.has(clientIp)) {
|
||||
rateLimit.delete(clientIp);
|
||||
}
|
||||
}
|
||||
|
||||
// URL parsing
|
||||
@@ -219,6 +287,10 @@ export async function cmdDashboard(port = DEFAULT_DASHBOARD_PORT, host = '127.0.
|
||||
}
|
||||
});
|
||||
|
||||
server.on('close', () => {
|
||||
clearInterval(cleanupInterval);
|
||||
});
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
server.listen(port, host, () => {
|
||||
const listenUrl = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}/dashboard/`;
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
---
|
||||
agent: content-audit-agent
|
||||
cadence: daily
|
||||
session: 2026-02-21T18-44-11Z
|
||||
run-start: 2026-02-21T18-44-11Z
|
||||
prompt: src/prompts/daily/content-audit-agent.md
|
||||
---
|
||||
# Decision Note — Content Audit — 2026-02-21
|
||||
|
||||
## Update `src/constants.mjs` Usage Text
|
||||
**Decision:** Add `proposal`, `rollback`, and `backup` commands to `USAGE_TEXT`.
|
||||
**Rationale:** The implementation exists in `src/lib.mjs` and commands are documented in `README.md`. The CLI help text was incomplete, leading to potential user confusion.
|
||||
+2
-191
@@ -10,13 +10,11 @@ import {
|
||||
loadTorchConfig as _loadTorchConfig,
|
||||
getRelays as _getRelays,
|
||||
getNamespace as _getNamespace,
|
||||
getTtl as _getTtl,
|
||||
getHashtag as _getHashtag,
|
||||
} from './torch-config.mjs';
|
||||
import {
|
||||
VALID_CADENCES,
|
||||
KIND_APP_DATA,
|
||||
RACE_CHECK_DELAY_MS,
|
||||
USAGE_TEXT,
|
||||
MS_PER_SECOND,
|
||||
} from './constants.mjs';
|
||||
@@ -38,16 +36,15 @@ import { todayDateStr, nowUnix, detectPlatform } from './utils.mjs';
|
||||
import { runRelayHealthCheck } from './relay-health.mjs';
|
||||
import fs from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { execSync } from 'node:child_process';
|
||||
import { getCompletedAgents } from './lock-utils.mjs';
|
||||
import { cmdProposal } from './cmd-proposal.mjs';
|
||||
import { cmdRollback } from './cmd-rollback.mjs';
|
||||
import { cmdLock } from './cmd-lock.mjs';
|
||||
|
||||
useWebSocketImplementation(WebSocket);
|
||||
|
||||
// Re-export for backward compatibility/library usage
|
||||
export { parseLockEvent, cmdDashboard, _queryLocks as queryLocks, _publishLock as publishLock };
|
||||
export { parseLockEvent, cmdDashboard, _queryLocks as queryLocks, _publishLock as publishLock, cmdLock };
|
||||
|
||||
/**
|
||||
* Checks the status of the repository locks for a given cadence.
|
||||
@@ -147,192 +144,6 @@ export async function cmdCheck(cadence, deps = {}) {
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to acquire an exclusive lock for an agent on the specified cadence.
|
||||
*
|
||||
* Algorithm:
|
||||
* 1. Validate agent against the roster.
|
||||
* 2. Query relays for existing valid locks (checking for conflicts).
|
||||
* 3. Generate a new ephemeral keypair and build a lock event (kind 30078).
|
||||
* 4. Publish the lock event to relays.
|
||||
* 5. Wait for propagation (raceCheckDelayMs) and re-query to confirm no earlier lock won the race.
|
||||
*
|
||||
* @param {string} agent - Agent name
|
||||
* @param {string} cadence - 'daily' or 'weekly'
|
||||
* @param {boolean} [dryRun=false] - If true, skips publishing
|
||||
* @param {Object} [deps] - Dependency injection
|
||||
* @returns {Promise<{status: string, eventId: string}>}
|
||||
* @throws {ExitError} If lock is denied (already locked, completed, or race lost)
|
||||
*/
|
||||
export async function cmdLock(agent, cadence, optionsOrDryRun = false, deps = {}) {
|
||||
const options = typeof optionsOrDryRun === 'object' ? optionsOrDryRun : { dryRun: !!optionsOrDryRun };
|
||||
const { dryRun = false, platform = null, model = null } = options;
|
||||
|
||||
const {
|
||||
getRelays = _getRelays,
|
||||
getNamespace = _getNamespace,
|
||||
getHashtag = _getHashtag,
|
||||
getTtl = _getTtl,
|
||||
queryLocks = _queryLocks,
|
||||
getRoster = _getRoster,
|
||||
publishLock = _publishLock,
|
||||
generateSecretKey = _generateSecretKey,
|
||||
getPublicKey = _getPublicKey,
|
||||
finalizeEvent = _finalizeEvent,
|
||||
raceCheckDelayMs = RACE_CHECK_DELAY_MS,
|
||||
getDateStr = todayDateStr,
|
||||
log = console.log,
|
||||
error = console.error
|
||||
} = deps;
|
||||
|
||||
const relays = await getRelays();
|
||||
const namespace = await getNamespace();
|
||||
const hashtag = await getHashtag();
|
||||
const dateStr = getDateStr();
|
||||
const ttl = await getTtl();
|
||||
const now = nowUnix();
|
||||
const expiresAt = now + ttl;
|
||||
|
||||
let gitCommit = null;
|
||||
try {
|
||||
gitCommit = execSync('git rev-parse HEAD', { stdio: 'pipe' }).toString().trim();
|
||||
} catch {
|
||||
// Ignore git errors (not a git repo, etc)
|
||||
}
|
||||
|
||||
let promptHash = null;
|
||||
let promptPath = null;
|
||||
try {
|
||||
// Attempt to locate the prompt file based on standard structure
|
||||
// We assume the CWD is the project root or we are in a standard structure.
|
||||
// If not found, we just omit the hash.
|
||||
const potentialPath = path.join(process.cwd(), 'src', 'prompts', cadence, `${agent}.md`);
|
||||
const content = await fs.readFile(potentialPath, 'utf8');
|
||||
promptHash = createHash('sha256').update(content).digest('hex');
|
||||
promptPath = `src/prompts/${cadence}/${agent}.md`;
|
||||
} catch {
|
||||
// Ignore missing prompt file
|
||||
}
|
||||
|
||||
error(`Locking: namespace=${namespace}, agent=${agent}, cadence=${cadence}, date=${dateStr}`);
|
||||
error(`Hashtag: #${hashtag}`);
|
||||
error(`TTL: ${ttl}s, expires: ${new Date(expiresAt * MS_PER_SECOND).toISOString()}`);
|
||||
error(`Relays: ${relays.join(', ')}`);
|
||||
if (gitCommit) error(`Git Commit: ${gitCommit}`);
|
||||
if (promptHash) error(`Prompt Hash: ${promptHash.slice(0, 12)}...`);
|
||||
|
||||
const roster = await getRoster(cadence);
|
||||
if (!roster.includes(agent)) {
|
||||
error(`ERROR: agent "${agent}" is not in the ${cadence} roster`);
|
||||
error(`Allowed ${cadence} agents: ${roster.join(', ')}`);
|
||||
throw new ExitError(1, 'Agent not in roster');
|
||||
}
|
||||
|
||||
error('Step 1: Checking for existing locks...');
|
||||
const existingLocks = await queryLocks(relays, cadence, dateStr, namespace);
|
||||
const conflicting = existingLocks.filter((l) => l.agent === agent);
|
||||
|
||||
if (conflicting.length > 0) {
|
||||
const earliest = conflicting.sort((a, b) => a.createdAt - b.createdAt)[0];
|
||||
|
||||
// Check if it is a completed task
|
||||
if (earliest.status === 'completed') {
|
||||
error(`LOCK DENIED: Task already completed by event ${earliest.eventId}`);
|
||||
log('LOCK_STATUS=denied');
|
||||
log('LOCK_REASON=already_completed');
|
||||
throw new ExitError(3, 'Task already completed');
|
||||
}
|
||||
|
||||
error(
|
||||
`LOCK DENIED: ${agent} already locked by event ${earliest.eventId} ` +
|
||||
`(created ${earliest.createdAtIso}, platform: ${earliest.platform})`,
|
||||
);
|
||||
log('LOCK_STATUS=denied');
|
||||
log('LOCK_REASON=already_locked');
|
||||
log(`LOCK_EXISTING_EVENT=${earliest.eventId}`);
|
||||
throw new ExitError(3, 'Lock denied');
|
||||
}
|
||||
|
||||
error('Step 2: Generating ephemeral keypair...');
|
||||
const sk = generateSecretKey();
|
||||
const pk = getPublicKey(sk);
|
||||
error(` Ephemeral pubkey: ${pk.slice(0, 16)}...`);
|
||||
|
||||
error('Step 3: Building lock event...');
|
||||
const event = finalizeEvent(
|
||||
{
|
||||
kind: KIND_APP_DATA,
|
||||
created_at: now,
|
||||
tags: [
|
||||
['d', `${namespace}-lock/${cadence}/${agent}/${dateStr}`],
|
||||
['t', hashtag],
|
||||
['t', `${namespace}-lock-${cadence}`],
|
||||
['t', `${namespace}-lock-${cadence}-${dateStr}`],
|
||||
['expiration', String(expiresAt)],
|
||||
],
|
||||
content: JSON.stringify({
|
||||
agent,
|
||||
cadence,
|
||||
status: 'started',
|
||||
namespace,
|
||||
date: dateStr,
|
||||
platform: platform || process.env.AGENT_PLATFORM || detectPlatform() || 'unknown',
|
||||
model: model || process.env.AGENT_MODEL || 'unknown',
|
||||
lockedAt: new Date(now * MS_PER_SECOND).toISOString(),
|
||||
expiresAt: new Date(expiresAt * MS_PER_SECOND).toISOString(),
|
||||
gitCommit,
|
||||
promptPath,
|
||||
promptHash,
|
||||
}),
|
||||
},
|
||||
sk,
|
||||
);
|
||||
|
||||
error(` Event ID: ${event.id}`);
|
||||
|
||||
if (dryRun) {
|
||||
error('Step 4: [DRY RUN] Skipping publish — event built but not sent');
|
||||
error('RACE CHECK: won (dry run — no real contention possible)');
|
||||
} else {
|
||||
error('Step 4: Publishing to relays...');
|
||||
await publishLock(relays, event);
|
||||
|
||||
error('Step 5: Race check...');
|
||||
await new Promise((resolve) => setTimeout(resolve, raceCheckDelayMs));
|
||||
|
||||
const postLocks = await queryLocks(relays, cadence, dateStr, namespace);
|
||||
const racingLocks = postLocks
|
||||
.filter((l) => l.agent === agent)
|
||||
.sort((a, b) => (a.createdAt - b.createdAt) || String(a.eventId).localeCompare(String(b.eventId)));
|
||||
|
||||
if (racingLocks.length > 1 && racingLocks[0].eventId !== event.id) {
|
||||
const winner = racingLocks[0];
|
||||
error(
|
||||
`RACE CHECK: lost (earlier lock by event ${winner.eventId}, created ${winner.createdAtIso})`,
|
||||
);
|
||||
log('LOCK_STATUS=race_lost');
|
||||
log('LOCK_REASON=earlier_claim_exists');
|
||||
log(`LOCK_WINNER_EVENT=${winner.eventId}`);
|
||||
throw new ExitError(3, 'Race check lost');
|
||||
}
|
||||
|
||||
error('RACE CHECK: won');
|
||||
}
|
||||
|
||||
log('LOCK_STATUS=ok');
|
||||
log(`LOCK_EVENT_ID=${event.id}`);
|
||||
log(`LOCK_PUBKEY=${pk}`);
|
||||
log(`LOCK_AGENT=${agent}`);
|
||||
log(`LOCK_HASHTAG=${hashtag}`);
|
||||
log(`LOCK_CADENCE=${cadence}`);
|
||||
log(`LOCK_DATE=${dateStr}`);
|
||||
log(`LOCK_EXPIRES=${expiresAt}`);
|
||||
log(`LOCK_EXPIRES_ISO=${new Date(expiresAt * MS_PER_SECOND).toISOString()}`);
|
||||
if (gitCommit) log(`LOCK_GIT_COMMIT=${gitCommit}`);
|
||||
if (promptHash) log(`LOCK_PROMPT_HASH=${promptHash}`);
|
||||
return { status: 'ok', eventId: event.id };
|
||||
}
|
||||
|
||||
/**
|
||||
* Lists all active locks for the specified cadence (or all cadences if null).
|
||||
* It prints a formatted table to stdout with lock age, TTL, and event ID.
|
||||
|
||||
+54
-129
@@ -6,100 +6,14 @@ import {
|
||||
getRelayFallbacks,
|
||||
getMinActiveRelayPool,
|
||||
} from './torch-config.mjs';
|
||||
import { mergeRelayList, relayListLabel, withTimeout } from './utils.mjs';
|
||||
import { relayListLabel, withTimeout, mergeRelayList } from './utils.mjs';
|
||||
import { defaultHealthManager, buildRelayHealthConfig } from './relay-health-manager.mjs';
|
||||
import { secureRandom } from './lock-utils.mjs';
|
||||
|
||||
const PUBLISH_ERROR_CODES = {
|
||||
TIMEOUT: 'publish_timeout',
|
||||
DNS: 'dns_resolution',
|
||||
TCP: 'tcp_connect_timeout',
|
||||
TLS: 'tls_handshake',
|
||||
WEBSOCKET: 'websocket_open_failure',
|
||||
NETWORK: 'network_timeout',
|
||||
CONNECTION_RESET: 'connection_reset',
|
||||
RELAY_UNAVAILABLE: 'relay_unavailable',
|
||||
PERMANENT: 'permanent_validation_error',
|
||||
};
|
||||
|
||||
const PUBLISH_FAILURE_CATEGORIES = {
|
||||
QUORUM_FAILURE: 'relay_publish_quorum_failure',
|
||||
NON_RETRYABLE: 'relay_publish_non_retryable',
|
||||
};
|
||||
|
||||
/**
|
||||
* Classifies a raw error message into a standardized publication error code.
|
||||
* Used to determine if a failure is transient (retryable) or permanent.
|
||||
*
|
||||
* @param {string|Error} message - The error message or object to classify.
|
||||
* @returns {string} One of the PUBLISH_ERROR_CODES constants.
|
||||
*/
|
||||
function classifyPublishError(message) {
|
||||
const normalized = String(message || '').toLowerCase();
|
||||
if (normalized.includes('publish timed out after') || normalized.includes('publish timeout')) {
|
||||
return PUBLISH_ERROR_CODES.TIMEOUT;
|
||||
}
|
||||
if (
|
||||
normalized.includes('enotfound')
|
||||
|| normalized.includes('eai_again')
|
||||
|| normalized.includes('getaddrinfo')
|
||||
|| (normalized.includes('dns') && normalized.includes('websocket'))
|
||||
) {
|
||||
return PUBLISH_ERROR_CODES.DNS;
|
||||
}
|
||||
if (
|
||||
normalized.includes('connect etimedout')
|
||||
|| normalized.includes('tcp connect timed out')
|
||||
|| normalized.includes('connect timeout')
|
||||
) {
|
||||
return PUBLISH_ERROR_CODES.TCP;
|
||||
}
|
||||
if (
|
||||
normalized.includes('tls')
|
||||
|| normalized.includes('ssl')
|
||||
|| normalized.includes('certificate')
|
||||
|| normalized.includes('handshake')
|
||||
) {
|
||||
return PUBLISH_ERROR_CODES.TLS;
|
||||
}
|
||||
if (
|
||||
normalized.includes('websocket')
|
||||
|| normalized.includes('bad response')
|
||||
|| normalized.includes('unexpected server response')
|
||||
) {
|
||||
return PUBLISH_ERROR_CODES.WEBSOCKET;
|
||||
}
|
||||
if (normalized.includes('timed out') || normalized.includes('timeout') || normalized.includes('etimedout')) {
|
||||
return PUBLISH_ERROR_CODES.NETWORK;
|
||||
}
|
||||
if (normalized.includes('econnreset') || normalized.includes('connection reset') || normalized.includes('socket hang up')) {
|
||||
return PUBLISH_ERROR_CODES.CONNECTION_RESET;
|
||||
}
|
||||
if (
|
||||
normalized.includes('unavailable')
|
||||
|| normalized.includes('offline')
|
||||
|| normalized.includes('econnrefused')
|
||||
|| normalized.includes('connection refused')
|
||||
|| normalized.includes('enotfound')
|
||||
|| normalized.includes('503')
|
||||
) {
|
||||
return PUBLISH_ERROR_CODES.RELAY_UNAVAILABLE;
|
||||
}
|
||||
return PUBLISH_ERROR_CODES.PERMANENT;
|
||||
}
|
||||
|
||||
function isTransientPublishCategory(category) {
|
||||
return [
|
||||
PUBLISH_ERROR_CODES.TIMEOUT,
|
||||
PUBLISH_ERROR_CODES.DNS,
|
||||
PUBLISH_ERROR_CODES.TCP,
|
||||
PUBLISH_ERROR_CODES.TLS,
|
||||
PUBLISH_ERROR_CODES.WEBSOCKET,
|
||||
PUBLISH_ERROR_CODES.NETWORK,
|
||||
PUBLISH_ERROR_CODES.CONNECTION_RESET,
|
||||
PUBLISH_ERROR_CODES.RELAY_UNAVAILABLE,
|
||||
].includes(category);
|
||||
}
|
||||
import {
|
||||
PUBLISH_FAILURE_CATEGORIES,
|
||||
classifyPublishError,
|
||||
isTransientPublishCategory,
|
||||
} from './lock-error-classifier.mjs';
|
||||
|
||||
function calculateBackoffDelayMs(attemptNumber, baseMs, capMs, randomFn = secureRandom) {
|
||||
const maxDelay = Math.min(capMs, baseMs * (2 ** Math.max(0, attemptNumber - 1)));
|
||||
@@ -187,6 +101,17 @@ export class LockPublisher {
|
||||
* @throws {Error} If publication quorum is not met after all attempts.
|
||||
*/
|
||||
async publish() {
|
||||
this._initialize();
|
||||
|
||||
try {
|
||||
this.healthManager.maybeLogSnapshot(this.allRelays, this.healthConfig, this.healthLogger, 'publish:periodic');
|
||||
return await this._executeRetryLoop(Date.now());
|
||||
} finally {
|
||||
this.pool.close(this.allRelays);
|
||||
}
|
||||
}
|
||||
|
||||
_initialize() {
|
||||
const {
|
||||
poolFactory = () => new SimplePool(),
|
||||
retryAttempts = 4,
|
||||
@@ -222,49 +147,49 @@ export class LockPublisher {
|
||||
this.attemptId = diagnostics.attemptId || randomUUID();
|
||||
|
||||
this.allRelays = mergeRelayList(this.relays, this.fallbackRelays);
|
||||
}
|
||||
|
||||
try {
|
||||
this.healthManager.maybeLogSnapshot(this.allRelays, this.healthConfig, this.healthLogger, 'publish:periodic');
|
||||
let lastAttemptState = null;
|
||||
const retryTimeline = [];
|
||||
const overallStartedAt = Date.now();
|
||||
let terminalFailureCategory = PUBLISH_FAILURE_CATEGORIES.NON_RETRYABLE;
|
||||
async _executeRetryLoop(overallStartedAt) {
|
||||
let lastAttemptState = null;
|
||||
const retryTimeline = [];
|
||||
let terminalFailureCategory = PUBLISH_FAILURE_CATEGORIES.NON_RETRYABLE;
|
||||
|
||||
// Retry loop: attempts publication until success or max attempts reached
|
||||
for (let attemptNumber = 1; attemptNumber <= this.maxAttempts; attemptNumber += 1) {
|
||||
const startedAtMs = Date.now();
|
||||
lastAttemptState = await this.executePublishCycle();
|
||||
const elapsedMs = Date.now() - startedAtMs;
|
||||
retryTimeline.push({
|
||||
publishAttempt: attemptNumber,
|
||||
successCount: lastAttemptState.successCount,
|
||||
relayAttemptedCount: lastAttemptState.attempted.size,
|
||||
elapsedMs,
|
||||
});
|
||||
// Retry loop: attempts publication until success or max attempts reached
|
||||
for (let attemptNumber = 1; attemptNumber <= this.maxAttempts; attemptNumber += 1) {
|
||||
const startedAtMs = Date.now();
|
||||
lastAttemptState = await this.executePublishCycle();
|
||||
const elapsedMs = Date.now() - startedAtMs;
|
||||
retryTimeline.push({
|
||||
publishAttempt: attemptNumber,
|
||||
successCount: lastAttemptState.successCount,
|
||||
relayAttemptedCount: lastAttemptState.attempted.size,
|
||||
elapsedMs,
|
||||
});
|
||||
|
||||
if (lastAttemptState.successCount >= this.minSuccesses) {
|
||||
this.logSuccess(attemptNumber, lastAttemptState, retryTimeline, overallStartedAt);
|
||||
return this.event;
|
||||
}
|
||||
|
||||
const { hasTransientFailure, hasPermanentFailure } = this.analyzeFailures(lastAttemptState.failures);
|
||||
const canRetry = attemptNumber < this.maxAttempts && hasTransientFailure && !hasPermanentFailure;
|
||||
|
||||
terminalFailureCategory = this.determineFailureCategory(hasTransientFailure, hasPermanentFailure, attemptNumber);
|
||||
|
||||
if (!canRetry) {
|
||||
break;
|
||||
}
|
||||
|
||||
const nextDelayMs = calculateBackoffDelayMs(attemptNumber, this.retryBaseDelayMs, this.retryCapDelayMs, this.randomFn);
|
||||
this.logRetry(attemptNumber, lastAttemptState.failures, elapsedMs, nextDelayMs);
|
||||
await this.sleepFn(nextDelayMs);
|
||||
if (lastAttemptState.successCount >= this.minSuccesses) {
|
||||
this.logSuccess(attemptNumber, lastAttemptState, retryTimeline, overallStartedAt);
|
||||
return this.event;
|
||||
}
|
||||
|
||||
this.handleFinalFailure(lastAttemptState, terminalFailureCategory, retryTimeline, overallStartedAt);
|
||||
} finally {
|
||||
this.pool.close(this.allRelays);
|
||||
const { hasTransientFailure, hasPermanentFailure } = this.analyzeFailures(lastAttemptState.failures);
|
||||
const canRetry = this._shouldRetry(attemptNumber, hasTransientFailure, hasPermanentFailure);
|
||||
|
||||
terminalFailureCategory = this.determineFailureCategory(hasTransientFailure, hasPermanentFailure, attemptNumber);
|
||||
|
||||
if (!canRetry) {
|
||||
break;
|
||||
}
|
||||
|
||||
const nextDelayMs = calculateBackoffDelayMs(attemptNumber, this.retryBaseDelayMs, this.retryCapDelayMs, this.randomFn);
|
||||
this.logRetry(attemptNumber, lastAttemptState.failures, elapsedMs, nextDelayMs);
|
||||
await this.sleepFn(nextDelayMs);
|
||||
}
|
||||
|
||||
this.handleFinalFailure(lastAttemptState, terminalFailureCategory, retryTimeline, overallStartedAt);
|
||||
}
|
||||
|
||||
_shouldRetry(attemptNumber, hasTransientFailure, hasPermanentFailure) {
|
||||
return attemptNumber < this.maxAttempts && hasTransientFailure && !hasPermanentFailure;
|
||||
}
|
||||
|
||||
async executePublishCycle() {
|
||||
|
||||
+1
-7
@@ -3,7 +3,7 @@ import path from 'node:path';
|
||||
import { randomInt } from 'node:crypto';
|
||||
import { todayDateStr, getIsoWeekStr } from './utils.mjs';
|
||||
|
||||
export { relayListLabel } from './utils.mjs';
|
||||
export { relayListLabel, withTimeout, mergeRelayList } from './utils.mjs';
|
||||
|
||||
/**
|
||||
* Scans the local log directory to identify agents that have already completed their task
|
||||
@@ -51,12 +51,6 @@ export async function getCompletedAgents(cadence, logDir, deps) {
|
||||
return completed;
|
||||
}
|
||||
|
||||
export { withTimeout } from './utils.mjs';
|
||||
|
||||
export function mergeRelayList(primaryRelays, fallbackRelays) {
|
||||
return [...new Set([...primaryRelays, ...fallbackRelays])];
|
||||
}
|
||||
|
||||
const MAX_RANDOM = 281474976710655; // 2**48 - 1
|
||||
|
||||
export function secureRandom() {
|
||||
|
||||
@@ -10,17 +10,16 @@
|
||||
|
||||
You are: **perf-agent**, a senior software engineer AI agent working inside this repository (default branch).
|
||||
|
||||
Mission: **daily, measurable improvement of app responsiveness** by finding and fixing background CPU/network work that degrades UX — and ensuring user-facing docs (`/content`) match runtime upload/contribution behavior. Make small, safe, incremental changes. Every change must be traceable, tested or manually verified, and documented.
|
||||
Mission: **daily, measurable improvement of app responsiveness** by finding and fixing background CPU/network work that degrades UX. Make small, safe, incremental changes. Every change must be traceable, tested or manually verified, and documented.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
IDENTITY & MANDATE
|
||||
- Role: senior engineer agent (implementer + doc auditor).
|
||||
- Role: senior engineer agent.
|
||||
- Repo: this repository — default branch.
|
||||
- Focus (priority):
|
||||
- **P0**: Login/auth, relay initialization & profile hydration, decryption of user lists (hashtags, subscriptions, blocks, watch history, moderation lists).
|
||||
- **P1**: Anything affecting initial UI responsiveness (profile cache, relay load).
|
||||
- **P2**: User-initiated heavy features (WebTorrent playback) — lazy-init/deprioritize until P0/P1 resolved.
|
||||
- **Docs**: `/content` — keep upload/contribution docs accurate and runnable.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
PRIMARY GOALS & SUCCESS CRITERIA
|
||||
@@ -28,11 +27,9 @@ PRIMARY GOALS & SUCCESS CRITERIA
|
||||
1. Finds expensive background patterns (main-thread loops, unbounded concurrency, eager socket/torrent creation).
|
||||
2. Applies small safety-first fixes (visibility-gating, bounded concurrency, workerization, lazy-init).
|
||||
3. Keeps login/auth and decryption flows fast and reliable.
|
||||
4. Verifies and updates `/content` so user docs are accurate and executable.
|
||||
- Success:
|
||||
- Login/auth & profile hydration not blocked by background tasks.
|
||||
- Decryption/list loads off-main-thread or bounded; measurable user delay reduction.
|
||||
- `/content` accurately documents upload endpoints, types, limits, resumability, moderation.
|
||||
- Every fix is a small PR with files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/` and tests/QA steps.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
@@ -79,10 +76,7 @@ DAILY WORKFLOW (run each day)
|
||||
- Make the smallest change that improves UX; add tests or manual QA steps.
|
||||
- If risky, gate behind feature flags in `src/constants.js`.
|
||||
|
||||
5. **Docs audit**
|
||||
- If upload/ingest code or `/content` is touched, run the docs audit workflow (inventory → verify → update → validate → deliver). Always leave `/content` runnable/precise.
|
||||
|
||||
6. **Report**
|
||||
5. **Report**
|
||||
- Produce `reports/performance/daily-perf-report-YYYY-MM-DD.md` summarizing findings, PRs/issues, metrics, and blockers.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
@@ -119,19 +113,9 @@ SMALL SAFE FIX EXAMPLES (PRs)
|
||||
- Add `MAX_DM_WORKER_PENDING` to `dmDecryptWorkerClient.js`. Throttle/reject when exceeded; log `getDmDecryptWorkerQueueSize()`.
|
||||
- **perf: visibility-gate ambient RAF & canvas**
|
||||
- Ensure RAF loops check `document.hidden` and avoid multiple attachments.
|
||||
- **docs: `/content` upload alignment**
|
||||
- Audit `/content`, update exact accepted types, size limits, endpoints, resumability examples (curl/JS).
|
||||
|
||||
All PRs: small, feature-flagged if risky, include `src/context/CONTEXT_<timestamp>.md`, `src/test_logs/TEST_LOG_<timestamp>.md`, `src/decisions/DECISIONS_<timestamp>.md`.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
DOCS AUDIT (integrated sub-workflow — mandatory when doc/code touched)
|
||||
1. INVENTORY: list `/content` pages that document uploading/contribution. Extract concrete claims and map to code locations.
|
||||
2. VERIFY: confirm claims against frontend components, API handlers, storage/processing pipelines, and build/deploy. Pay attention to MIME lists, size limits, resumability, error messages, moderation.
|
||||
3. UPDATE: make `/content` exact and copy-pastable. If code is wrong, either fix code (small) or document divergence and open issue.
|
||||
4. VALIDATE: run end-to-end uploads where possible; capture terminal logs, curl responses, screenshots (redact secrets).
|
||||
5. DELIVER: open PR titled `"docs: align /content user docs with actual upload & contribution behavior"` with validation artifacts and a contributor-facing note.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
WORK LOOP & VERIFICATION (for code changes)
|
||||
A) PLAN: 3–7 bullet plan before coding.
|
||||
@@ -162,10 +146,6 @@ PR & ISSUE GUIDELINES (what to include)
|
||||
- QA steps & manual validation instructions.
|
||||
- Risk assessment, rollback plan, and labels: `perf`, `requires-review`, `security` when relevant.
|
||||
|
||||
Docs PR:
|
||||
- Title: `"🌐 Align /content user docs with actual upload & contribution behavior"`
|
||||
- Body: summary, diffs, validation artifacts, note for contributors.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
- If no work is required, exit without making changes.
|
||||
ESCALATION & RISK POLICY
|
||||
@@ -178,8 +158,7 @@ FIRST-RUN CHECKLIST (execute now)
|
||||
- Commit files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`, `reports/performance/INITIAL_BASELINE.md`.
|
||||
2. Run Search Patterns across repo and save `reports/performance/hits-YYYY-MM-DD.json`.
|
||||
3. Prioritize P0 findings, open at most 1–3 small PRs (bounded concurrency, worker queue limits, visibility gating).
|
||||
4. Audit `/content` upload pages: inventory claims → map to code → verify → open docs PR or issue.
|
||||
5. Produce `reports/performance/daily-perf-report-YYYY-MM-DD.md` summarizing results and PR links.
|
||||
4. Produce `reports/performance/daily-perf-report-YYYY-MM-DD.md` summarizing results and PR links.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
@@ -196,7 +175,6 @@ OUTPUTS (per run)
|
||||
- PRs opened / Issues opened.
|
||||
- Blockers & human decisions requested.
|
||||
- For every PR: branch contains files in `src/context/`, `src/todo/`, `src/decisions/`, `src/test_logs/`.
|
||||
- For docs PR: verification artifacts attached.
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
BEHAVIORAL GUARDRAILS & QUALITY BAR
|
||||
|
||||
+44
-19
@@ -70,33 +70,58 @@ const FALLBACK_ROSTER = {
|
||||
|
||||
let cachedCanonicalRoster = null;
|
||||
|
||||
function loadCanonicalRoster() {
|
||||
async function loadCanonicalRoster() {
|
||||
if (cachedCanonicalRoster) return cachedCanonicalRoster;
|
||||
|
||||
let rosterPath = ROSTER_FILE;
|
||||
let content = null;
|
||||
|
||||
// Prefer user-managed roster if present
|
||||
if (deps.fs.existsSync(USER_ROSTER_FILE)) {
|
||||
const tryRead = async (p) => {
|
||||
try {
|
||||
return { data: await deps.fs.promises.readFile(p, 'utf8'), error: null };
|
||||
} catch (error) {
|
||||
return { data: null, error };
|
||||
}
|
||||
};
|
||||
|
||||
// Try user roster
|
||||
let result = await tryRead(USER_ROSTER_FILE);
|
||||
if (result.data) {
|
||||
rosterPath = USER_ROSTER_FILE;
|
||||
} else if (deps.fs.existsSync(CWD_ROSTER_FILE)) {
|
||||
rosterPath = CWD_ROSTER_FILE;
|
||||
content = result.data;
|
||||
} else if (result.error.code === 'ENOENT') {
|
||||
// Try CWD roster
|
||||
result = await tryRead(CWD_ROSTER_FILE);
|
||||
if (result.data) {
|
||||
rosterPath = CWD_ROSTER_FILE;
|
||||
content = result.data;
|
||||
} else if (result.error.code === 'ENOENT') {
|
||||
// Try default roster
|
||||
result = await tryRead(ROSTER_FILE);
|
||||
if (result.data) {
|
||||
rosterPath = ROSTER_FILE;
|
||||
content = result.data;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const parsed = JSON.parse(deps.fs.readFileSync(rosterPath, 'utf8'));
|
||||
const daily = Array.isArray(parsed.daily) ? parsed.daily.map((item) => String(item).trim()).filter(Boolean) : [];
|
||||
const weekly = Array.isArray(parsed.weekly)
|
||||
? parsed.weekly.map((item) => String(item).trim()).filter(Boolean)
|
||||
: [];
|
||||
if (content) {
|
||||
try {
|
||||
const parsed = JSON.parse(content);
|
||||
const daily = Array.isArray(parsed.daily) ? parsed.daily.map((item) => String(item).trim()).filter(Boolean) : [];
|
||||
const weekly = Array.isArray(parsed.weekly)
|
||||
? parsed.weekly.map((item) => String(item).trim()).filter(Boolean)
|
||||
: [];
|
||||
|
||||
if (daily.length > 0 && weekly.length > 0) {
|
||||
cachedCanonicalRoster = { daily, weekly };
|
||||
return cachedCanonicalRoster;
|
||||
if (daily.length > 0 && weekly.length > 0) {
|
||||
cachedCanonicalRoster = { daily, weekly };
|
||||
return cachedCanonicalRoster;
|
||||
}
|
||||
|
||||
console.error(`WARNING: Roster file is missing daily/weekly entries, falling back: ${rosterPath}`);
|
||||
} catch {
|
||||
// It's okay if roster file is missing when used as a library/CLI without the file present
|
||||
}
|
||||
|
||||
console.error(`WARNING: Roster file is missing daily/weekly entries, falling back: ${rosterPath}`);
|
||||
} catch {
|
||||
// It's okay if roster file is missing when used as a library/CLI without the file present
|
||||
}
|
||||
|
||||
cachedCanonicalRoster = FALLBACK_ROSTER;
|
||||
@@ -120,7 +145,7 @@ export async function getRoster(cadence) {
|
||||
const config = await deps.loadTorchConfig();
|
||||
const dailyFromEnv = parseEnvRoster(process.env.NOSTR_LOCK_DAILY_ROSTER);
|
||||
const weeklyFromEnv = parseEnvRoster(process.env.NOSTR_LOCK_WEEKLY_ROSTER);
|
||||
const canonical = loadCanonicalRoster();
|
||||
const canonical = await loadCanonicalRoster();
|
||||
const dailyFromConfig = config.nostrLock.dailyRoster;
|
||||
const weeklyFromConfig = config.nostrLock.weeklyRoster;
|
||||
|
||||
|
||||
@@ -91,21 +91,26 @@ export function createMemoryCache(options = {}) {
|
||||
}
|
||||
}
|
||||
|
||||
function removeExpired(now = Date.now()) {
|
||||
for (const [namespaceKey, bucket] of runtimeNamespaces.entries()) {
|
||||
if (!bucket.events.length) continue;
|
||||
function expireNamespace(namespaceKey, now) {
|
||||
const bucket = runtimeNamespaces.get(namespaceKey);
|
||||
if (!bucket || !bucket.events.length) return;
|
||||
|
||||
const originalLength = bucket.events.length;
|
||||
bucket.events = bucket.events.filter((entry) => entry.expiresAt > now);
|
||||
const removed = originalLength - bucket.events.length;
|
||||
if (removed > 0) {
|
||||
totalRuntimeEvents -= removed;
|
||||
metrics.runtime_events_expired += removed;
|
||||
}
|
||||
const originalLength = bucket.events.length;
|
||||
bucket.events = bucket.events.filter((entry) => entry.expiresAt > now);
|
||||
const removed = originalLength - bucket.events.length;
|
||||
if (removed > 0) {
|
||||
totalRuntimeEvents -= removed;
|
||||
metrics.runtime_events_expired += removed;
|
||||
}
|
||||
|
||||
if (bucket.events.length === 0) {
|
||||
runtimeNamespaces.delete(namespaceKey);
|
||||
}
|
||||
if (bucket.events.length === 0) {
|
||||
runtimeNamespaces.delete(namespaceKey);
|
||||
}
|
||||
}
|
||||
|
||||
function expireAllNamespaces(now = Date.now()) {
|
||||
for (const [namespaceKey] of runtimeNamespaces.entries()) {
|
||||
expireNamespace(namespaceKey, now);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -152,13 +157,25 @@ export function createMemoryCache(options = {}) {
|
||||
runtimeNamespaces.clear();
|
||||
totalRuntimeEvents = 0;
|
||||
},
|
||||
prune(predicate) {
|
||||
if (typeof predicate !== 'function') return;
|
||||
for (const key of store.keys()) {
|
||||
if (predicate(key)) {
|
||||
store.delete(key);
|
||||
}
|
||||
}
|
||||
},
|
||||
setRuntimeEvent(scope, event, ttlMs = MINUTE_MS) {
|
||||
const now = Date.now();
|
||||
removeExpired(now);
|
||||
const namespaceKey = getNamespaceKey(scope);
|
||||
|
||||
expireNamespace(namespaceKey, now);
|
||||
if (totalRuntimeEvents >= maxTotalEvents) {
|
||||
expireAllNamespaces(now);
|
||||
}
|
||||
|
||||
const safeTtlMs = Number.isFinite(ttlMs) && ttlMs > 0 ? ttlMs : MINUTE_MS;
|
||||
const expiresAt = now + safeTtlMs;
|
||||
const namespaceKey = getNamespaceKey(scope);
|
||||
const bucket = runtimeNamespaces.get(namespaceKey) ?? { events: [] };
|
||||
|
||||
bucket.events.push({
|
||||
@@ -182,9 +199,9 @@ export function createMemoryCache(options = {}) {
|
||||
},
|
||||
getRecentRuntimeEvents(scope, params = {}) {
|
||||
const now = Date.now();
|
||||
removeExpired(now);
|
||||
|
||||
const namespaceKey = getNamespaceKey(scope);
|
||||
expireNamespace(namespaceKey, now);
|
||||
|
||||
const bucket = runtimeNamespaces.get(namespaceKey);
|
||||
if (!bucket) return [];
|
||||
|
||||
|
||||
+108
-29
@@ -38,9 +38,50 @@ function loadMemoryStore() {
|
||||
return new Map();
|
||||
}
|
||||
|
||||
let currentSavePromise = null;
|
||||
let pendingSavePromise = null;
|
||||
let pendingSaveResolve = null;
|
||||
class CoalescingWorker {
|
||||
constructor(workerFn) {
|
||||
this.workerFn = workerFn;
|
||||
this.currentPromise = null;
|
||||
this.pendingPromise = null;
|
||||
this.pendingResolve = null;
|
||||
this.pendingArg = null;
|
||||
}
|
||||
|
||||
enqueue(arg) {
|
||||
this.pendingArg = arg;
|
||||
|
||||
if (this.pendingPromise) {
|
||||
return this.pendingPromise;
|
||||
}
|
||||
|
||||
if (this.currentPromise) {
|
||||
this.pendingPromise = new Promise((resolve) => {
|
||||
this.pendingResolve = resolve;
|
||||
});
|
||||
return this.pendingPromise;
|
||||
}
|
||||
|
||||
this.currentPromise = this._execute(arg);
|
||||
return this.currentPromise;
|
||||
}
|
||||
|
||||
async _execute(arg) {
|
||||
try {
|
||||
await this.workerFn(arg);
|
||||
} finally {
|
||||
this.currentPromise = null;
|
||||
if (this.pendingPromise) {
|
||||
const resolve = this.pendingResolve;
|
||||
const nextArg = this.pendingArg;
|
||||
this.pendingPromise = null;
|
||||
this.pendingResolve = null;
|
||||
this.pendingArg = null;
|
||||
this.currentPromise = this._execute(nextArg).then(resolve);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let lastSaveTime = 0;
|
||||
const MIN_SAVE_INTERVAL_MS = 1000;
|
||||
|
||||
@@ -61,31 +102,13 @@ async function performSave(store) {
|
||||
lastSaveTime = Date.now();
|
||||
} catch (err) {
|
||||
console.error('Failed to save memory store:', err);
|
||||
} finally {
|
||||
currentSavePromise = null;
|
||||
if (pendingSavePromise) {
|
||||
const resolve = pendingSaveResolve;
|
||||
pendingSavePromise = null;
|
||||
pendingSaveResolve = null;
|
||||
currentSavePromise = performSave(store).then(() => resolve());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const saveWorker = new CoalescingWorker(performSave);
|
||||
|
||||
async function saveMemoryStore(store) {
|
||||
if (pendingSavePromise) {
|
||||
return pendingSavePromise;
|
||||
}
|
||||
|
||||
if (currentSavePromise) {
|
||||
pendingSavePromise = new Promise((resolve) => {
|
||||
pendingSaveResolve = resolve;
|
||||
});
|
||||
return pendingSavePromise;
|
||||
}
|
||||
|
||||
currentSavePromise = performSave(store);
|
||||
return currentSavePromise;
|
||||
return saveWorker.enqueue(store);
|
||||
}
|
||||
|
||||
const memoryStore = loadMemoryStore();
|
||||
@@ -227,6 +250,24 @@ function recordThroughput(samples, now) {
|
||||
}
|
||||
}
|
||||
|
||||
function invalidateAgentCache(agentId) {
|
||||
if (!agentId) return;
|
||||
// If the cache supports prune (it should), use it to remove entries for this agent.
|
||||
if (typeof cache.prune === 'function') {
|
||||
cache.prune((key) => {
|
||||
try {
|
||||
const parsed = JSON.parse(key);
|
||||
return parsed.agent_id === agentId;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// Fallback if cache implementation doesn't support prune
|
||||
cache.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ingests agent events and stores them as memory records.
|
||||
*
|
||||
@@ -255,7 +296,22 @@ export async function ingestEvents(events, options = {}) {
|
||||
}
|
||||
},
|
||||
});
|
||||
cache.clear();
|
||||
|
||||
const uniqueAgents = new Set();
|
||||
if (options.agent_id) uniqueAgents.add(options.agent_id);
|
||||
for (const event of events) {
|
||||
if (event.agent_id) uniqueAgents.add(event.agent_id);
|
||||
}
|
||||
for (const record of records) {
|
||||
if (record.agent_id) uniqueAgents.add(record.agent_id);
|
||||
}
|
||||
|
||||
if (uniqueAgents.size > 0) {
|
||||
for (const agentId of uniqueAgents) invalidateAgentCache(agentId);
|
||||
} else {
|
||||
cache.clear();
|
||||
}
|
||||
|
||||
return records;
|
||||
}
|
||||
|
||||
@@ -372,7 +428,16 @@ export async function runPruneCycle(options = {}) {
|
||||
});
|
||||
emitMetric(options, 'memory_pruned_total', { count: prunable.length, retention_ms: retentionMs });
|
||||
|
||||
cache.clear();
|
||||
const uniqueAgents = new Set();
|
||||
for (const memory of prunable) {
|
||||
if (memory.agent_id) uniqueAgents.add(memory.agent_id);
|
||||
}
|
||||
|
||||
if (uniqueAgents.size > 0) {
|
||||
for (const agentId of uniqueAgents) invalidateAgentCache(agentId);
|
||||
} else if (prunable.length > 0) {
|
||||
cache.clear();
|
||||
}
|
||||
|
||||
const result = { pruned: prunable };
|
||||
if (Number.isFinite(options.scheduleEveryMs) && options.scheduleEveryMs > 0) {
|
||||
@@ -397,7 +462,11 @@ export async function runPruneCycle(options = {}) {
|
||||
export async function pinMemory(id, options = {}) {
|
||||
const repository = options.repository ?? memoryRepository;
|
||||
const updated = await repository.setPinned(id, true);
|
||||
cache.clear();
|
||||
if (updated && updated.agent_id) {
|
||||
invalidateAgentCache(updated.agent_id);
|
||||
} else {
|
||||
cache.clear();
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
|
||||
@@ -414,7 +483,11 @@ export async function pinMemory(id, options = {}) {
|
||||
export async function unpinMemory(id, options = {}) {
|
||||
const repository = options.repository ?? memoryRepository;
|
||||
const updated = await repository.setPinned(id, false);
|
||||
cache.clear();
|
||||
if (updated && updated.agent_id) {
|
||||
invalidateAgentCache(updated.agent_id);
|
||||
} else {
|
||||
cache.clear();
|
||||
}
|
||||
return updated;
|
||||
}
|
||||
|
||||
@@ -431,8 +504,14 @@ export async function unpinMemory(id, options = {}) {
|
||||
*/
|
||||
export async function markMemoryMerged(id, mergedInto, options = {}) {
|
||||
const repository = options.repository ?? memoryRepository;
|
||||
const memory = await inspectMemory(id, { repository });
|
||||
const merged = await repository.markMerged(id, mergedInto);
|
||||
cache.clear();
|
||||
|
||||
if (memory && memory.agent_id) {
|
||||
invalidateAgentCache(memory.agent_id);
|
||||
} else {
|
||||
cache.clear();
|
||||
}
|
||||
return merged;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
---
|
||||
agent: content-audit-agent
|
||||
cadence: daily
|
||||
session: 2026-02-21T18-44-11Z
|
||||
run-start: 2026-02-21T18-44-11Z
|
||||
prompt: src/prompts/daily/content-audit-agent.md
|
||||
---
|
||||
# Test Log — Content Audit — 2026-02-21
|
||||
|
||||
## `npm run validate:docs`
|
||||
**Result:** PASS
|
||||
**Output:**
|
||||
```
|
||||
Found 365 markdown files. Checking links (including anchors)...
|
||||
No broken links found.
|
||||
```
|
||||
|
||||
## Manual Verification
|
||||
**Command:** `node bin/torch-lock.mjs --help`
|
||||
**Result:** Originally missing commands; verified fix (pending verification step).
|
||||
@@ -5,10 +5,10 @@ Run Start: 2026-02-20T01-13-24Z
|
||||
Prompt: src/prompts/daily/deps-security-agent.md
|
||||
|
||||
## Pending Tasks
|
||||
- [ ] Investigate `eslint` upgrade path to resolve `minimatch` (High) vulnerability.
|
||||
- [ ] Investigate `ajv` vulnerability in `eslint` dependency tree.
|
||||
|
||||
## Completed Tasks
|
||||
- [x] Investigate `eslint` upgrade path to resolve `minimatch` (High) vulnerability.
|
||||
- [x] Investigate `ajv` vulnerability in `eslint` dependency tree.
|
||||
- [x] Run npm audit.
|
||||
- [x] Run npm outdated.
|
||||
- [x] Generate security report.
|
||||
@@ -0,0 +1,16 @@
|
||||
---
|
||||
agent: content-audit-agent
|
||||
cadence: daily
|
||||
session: 2026-02-21T18-44-11Z
|
||||
run-start: 2026-02-21T18-44-11Z
|
||||
prompt: src/prompts/daily/content-audit-agent.md
|
||||
---
|
||||
# Todo Note — Content Audit — 2026-02-21
|
||||
|
||||
## Completed
|
||||
- [x] Run `npm run validate:docs`.
|
||||
- [x] Check `README.md` commands against implementation.
|
||||
- [x] Update `src/constants.mjs` to include missing commands in usage text.
|
||||
|
||||
## Pending
|
||||
- None.
|
||||
@@ -0,0 +1,18 @@
|
||||
---
|
||||
agent: content-audit-agent
|
||||
cadence: daily
|
||||
status: completed
|
||||
platform: jules
|
||||
---
|
||||
# Content Audit Agent — Completed
|
||||
|
||||
**Task:** Verify documentation accuracy against repository implementation.
|
||||
|
||||
**Result:**
|
||||
- Identified missing commands in `src/constants.mjs` (`backup`, `proposal`, `rollback`).
|
||||
- Updated `USAGE_TEXT` to match implementation.
|
||||
- Validated `README.md` and docs links.
|
||||
|
||||
**Learnings:**
|
||||
- `package.json` scripts are not exhaustive; `bin/torch-lock.mjs` has more commands.
|
||||
- CLI help text requires manual synchronization.
|
||||
@@ -0,0 +1,99 @@
|
||||
import { test, after } from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { cmdBackup, listBackups } from '../src/cmd-backup.mjs';
|
||||
|
||||
const tempBase = fs.mkdtempSync(path.join(process.cwd(), 'test-backup-'));
|
||||
|
||||
// Helper to setup dummy state files
|
||||
function setupStateFiles(cwd) {
|
||||
const memoryDir = path.join(cwd, '.scheduler-memory');
|
||||
const logsDir = path.join(cwd, 'task-logs', 'daily');
|
||||
|
||||
fs.mkdirSync(memoryDir, { recursive: true });
|
||||
fs.mkdirSync(logsDir, { recursive: true });
|
||||
|
||||
fs.writeFileSync(path.join(memoryDir, 'memory-store.json'), '{"dummy": "memory"}');
|
||||
fs.writeFileSync(path.join(logsDir, '.scheduler-run-state.json'), '{"dummy": "state"}');
|
||||
}
|
||||
|
||||
after(() => {
|
||||
fs.rmSync(tempBase, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('cmdBackup creates backup directory and manifest', async () => {
|
||||
const cwd = path.join(tempBase, 'scenario-1');
|
||||
fs.mkdirSync(cwd, { recursive: true });
|
||||
setupStateFiles(cwd);
|
||||
|
||||
const { backupDir } = await cmdBackup({ cwd });
|
||||
|
||||
assert.ok(fs.existsSync(backupDir), 'Backup directory created');
|
||||
assert.ok(fs.existsSync(path.join(backupDir, 'backup-manifest.json')), 'Manifest created');
|
||||
|
||||
const manifestContent = JSON.parse(fs.readFileSync(path.join(backupDir, 'backup-manifest.json'), 'utf8'));
|
||||
assert.strictEqual(manifestContent.backupDir, backupDir);
|
||||
assert.ok(manifestContent.createdAt);
|
||||
|
||||
// Verify files are copied
|
||||
const backupMemory = path.join(backupDir, '.scheduler-memory__memory-store.json');
|
||||
assert.ok(fs.existsSync(backupMemory), 'Memory file copied');
|
||||
|
||||
// captured should contain the 2 files
|
||||
assert.strictEqual(manifestContent.captured.length, 2);
|
||||
});
|
||||
|
||||
test('cmdBackup handles missing files gracefully', async () => {
|
||||
const cwd = path.join(tempBase, 'scenario-2');
|
||||
fs.mkdirSync(cwd, { recursive: true });
|
||||
// Do NOT setup files
|
||||
|
||||
const { manifest } = await cmdBackup({ cwd });
|
||||
|
||||
assert.strictEqual(manifest.captured.length, 0);
|
||||
assert.strictEqual(manifest.skipped.length, 2);
|
||||
assert.strictEqual(manifest.skipped[0].reason, 'not found');
|
||||
});
|
||||
|
||||
test('cmdBackup respects output override', async () => {
|
||||
const cwd = path.join(tempBase, 'scenario-3');
|
||||
fs.mkdirSync(cwd, { recursive: true });
|
||||
setupStateFiles(cwd);
|
||||
|
||||
const outputDir = 'custom-backup-location';
|
||||
const { backupDir } = await cmdBackup({ cwd, output: outputDir });
|
||||
|
||||
const expectedPath = path.resolve(cwd, outputDir);
|
||||
assert.strictEqual(backupDir, expectedPath);
|
||||
assert.ok(fs.existsSync(expectedPath));
|
||||
assert.ok(fs.existsSync(path.join(expectedPath, 'backup-manifest.json')), 'Manifest in custom output');
|
||||
});
|
||||
|
||||
test('listBackups lists created backups', async () => {
|
||||
const cwd = path.join(tempBase, 'scenario-4');
|
||||
fs.mkdirSync(cwd, { recursive: true });
|
||||
setupStateFiles(cwd);
|
||||
|
||||
// Create two backups
|
||||
await cmdBackup({ cwd });
|
||||
|
||||
// Ensure we have a slight delay or just rely on execution time for timestamp diff
|
||||
// Windows/Filesystem might have low resolution, but listBackups sorts by ISO string in manifest
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
|
||||
await cmdBackup({ cwd });
|
||||
|
||||
const backups = await listBackups({ cwd });
|
||||
assert.strictEqual(backups.length, 2);
|
||||
|
||||
// Verify sorting (newest first)
|
||||
const t0 = new Date(backups[0].createdAt).getTime();
|
||||
const t1 = new Date(backups[1].createdAt).getTime();
|
||||
assert.ok(t0 >= t1, 'Backups sorted newest first');
|
||||
|
||||
// Verify properties
|
||||
assert.ok(backups[0].id);
|
||||
assert.ok(backups[0].backupDir);
|
||||
assert.ok(Array.isArray(backups[0].captured));
|
||||
});
|
||||
@@ -0,0 +1,316 @@
|
||||
import { describe, it } from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import { cmdProposal } from '../src/cmd-proposal.mjs';
|
||||
import { ExitError } from '../src/errors.mjs';
|
||||
|
||||
describe('cmdProposal', () => {
|
||||
const noop = () => {};
|
||||
|
||||
describe('create', () => {
|
||||
it('should create a proposal successfully', async () => {
|
||||
const logs = [];
|
||||
const errors = [];
|
||||
const mockCreate = async (args) => {
|
||||
return { id: 'prop-123', status: 'open', ...args };
|
||||
};
|
||||
const mockReadFile = async () => 'file-content';
|
||||
|
||||
const deps = {
|
||||
createProposal: mockCreate,
|
||||
readFile: mockReadFile,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
const args = {
|
||||
agent: 'test-agent',
|
||||
target: 'src/foo.js',
|
||||
contentFile: 'new-content.txt',
|
||||
reason: 'fix bug',
|
||||
};
|
||||
|
||||
await cmdProposal('create', args, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
assert.strictEqual(errors.length, 0);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.id, 'prop-123');
|
||||
assert.strictEqual(output.newContent, 'file-content');
|
||||
assert.strictEqual(output.agent, 'test-agent');
|
||||
});
|
||||
|
||||
it('should throw if arguments are missing', async () => {
|
||||
const errors = [];
|
||||
const deps = {
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('create', {}, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Missing arguments'
|
||||
);
|
||||
assert.ok(errors[0].includes('Usage:'));
|
||||
});
|
||||
|
||||
it('should throw if file read fails', async () => {
|
||||
const errors = [];
|
||||
const mockReadFile = async () => { throw new Error('File not found'); };
|
||||
const deps = {
|
||||
readFile: mockReadFile,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
const args = {
|
||||
agent: 'test-agent',
|
||||
target: 'src/foo.js',
|
||||
contentFile: 'missing.txt',
|
||||
reason: 'fix bug',
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('create', args, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'File read error'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to read content file'));
|
||||
});
|
||||
|
||||
it('should throw if createProposal fails', async () => {
|
||||
const errors = [];
|
||||
const mockCreate = async () => { throw new Error('DB error'); };
|
||||
const mockReadFile = async () => 'content';
|
||||
const deps = {
|
||||
createProposal: mockCreate,
|
||||
readFile: mockReadFile,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
const args = {
|
||||
agent: 'test-agent',
|
||||
target: 'src/foo.js',
|
||||
contentFile: 'content.txt',
|
||||
reason: 'fix bug',
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('create', args, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Proposal creation failed'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to create proposal'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('list', () => {
|
||||
it('should list all proposals', async () => {
|
||||
const logs = [];
|
||||
const mockList = async () => [{ id: '1', status: 'open' }, { id: '2', status: 'closed' }];
|
||||
const deps = {
|
||||
listProposals: mockList,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: noop,
|
||||
};
|
||||
|
||||
await cmdProposal('list', {}, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.length, 2);
|
||||
});
|
||||
|
||||
it('should filter proposals by status', async () => {
|
||||
const logs = [];
|
||||
const mockList = async () => [{ id: '1', status: 'open' }, { id: '2', status: 'closed' }];
|
||||
const deps = {
|
||||
listProposals: mockList,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: noop,
|
||||
};
|
||||
|
||||
await cmdProposal('list', { status: 'open' }, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.length, 1);
|
||||
assert.strictEqual(output[0].id, '1');
|
||||
});
|
||||
|
||||
it('should handle list failure', async () => {
|
||||
const errors = [];
|
||||
const mockList = async () => { throw new Error('List error'); };
|
||||
const deps = {
|
||||
listProposals: mockList,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('list', {}, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'List failed'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to list proposals'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('apply', () => {
|
||||
it('should apply a proposal', async () => {
|
||||
const logs = [];
|
||||
const mockApply = async (id) => ({ id, status: 'applied' });
|
||||
const deps = {
|
||||
applyProposal: mockApply,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: noop,
|
||||
};
|
||||
|
||||
await cmdProposal('apply', { id: 'prop-1' }, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.status, 'applied');
|
||||
assert.strictEqual(output.id, 'prop-1');
|
||||
});
|
||||
|
||||
it('should throw if id is missing', async () => {
|
||||
const errors = [];
|
||||
const deps = {
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('apply', {}, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Missing id'
|
||||
);
|
||||
assert.ok(errors[0].includes('Usage:'));
|
||||
});
|
||||
|
||||
it('should handle apply failure', async () => {
|
||||
const errors = [];
|
||||
const mockApply = async () => { throw new Error('Apply error'); };
|
||||
const deps = {
|
||||
applyProposal: mockApply,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('apply', { id: 'prop-1' }, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Apply failed'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to apply proposal'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('reject', () => {
|
||||
it('should reject a proposal', async () => {
|
||||
const logs = [];
|
||||
const mockReject = async (id, reason) => ({ id, status: 'rejected', reason });
|
||||
const deps = {
|
||||
rejectProposal: mockReject,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: noop,
|
||||
};
|
||||
|
||||
await cmdProposal('reject', { id: 'prop-1', reason: 'bad code' }, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.status, 'rejected');
|
||||
assert.strictEqual(output.reason, 'bad code');
|
||||
});
|
||||
|
||||
it('should throw if arguments are missing', async () => {
|
||||
const errors = [];
|
||||
const deps = {
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('reject', { id: 'prop-1' }, deps), // missing reason
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Missing arguments'
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle reject failure', async () => {
|
||||
const errors = [];
|
||||
const mockReject = async () => { throw new Error('Reject error'); };
|
||||
const deps = {
|
||||
rejectProposal: mockReject,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('reject', { id: 'prop-1', reason: 'bad' }, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Reject failed'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to reject proposal'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('show', () => {
|
||||
it('should show a proposal', async () => {
|
||||
const logs = [];
|
||||
const mockGet = async (id) => ({ id, content: 'stuff' });
|
||||
const deps = {
|
||||
getProposal: mockGet,
|
||||
log: (msg) => logs.push(msg),
|
||||
error: noop,
|
||||
};
|
||||
|
||||
await cmdProposal('show', { id: 'prop-1' }, deps);
|
||||
|
||||
assert.strictEqual(logs.length, 1);
|
||||
const output = JSON.parse(logs[0]);
|
||||
assert.strictEqual(output.id, 'prop-1');
|
||||
assert.strictEqual(output.content, 'stuff');
|
||||
});
|
||||
|
||||
it('should throw if id is missing', async () => {
|
||||
const errors = [];
|
||||
const deps = {
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('show', {}, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Missing id'
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle show failure', async () => {
|
||||
const errors = [];
|
||||
const mockGet = async () => { throw new Error('Show error'); };
|
||||
const deps = {
|
||||
getProposal: mockGet,
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('show', { id: 'prop-1' }, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Show failed'
|
||||
);
|
||||
assert.ok(errors[0].includes('Failed to show proposal'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('unknown subcommand', () => {
|
||||
it('should throw ExitError for unknown subcommand', async () => {
|
||||
const errors = [];
|
||||
const deps = {
|
||||
log: noop,
|
||||
error: (msg) => errors.push(msg),
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => cmdProposal('foo', {}, deps),
|
||||
(err) => err instanceof ExitError && err.code === 1 && err.message === 'Unknown subcommand'
|
||||
);
|
||||
assert.ok(errors[0].includes('Unknown proposal subcommand'));
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,6 +1,7 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import http from 'node:http';
|
||||
import crypto from 'node:crypto';
|
||||
import { cmdDashboard } from '../src/dashboard.mjs';
|
||||
import { _resetTorchConfigCache } from '../src/torch-config.mjs';
|
||||
|
||||
@@ -147,4 +148,43 @@ test('Dashboard Authentication', async (t) => {
|
||||
_resetTorchConfigCache();
|
||||
}
|
||||
});
|
||||
|
||||
await t.test('validates correctly using scrypt hashed credentials', async () => {
|
||||
// Generate a valid scrypt hash
|
||||
const password = 'admin:hashedpassword';
|
||||
const salt = crypto.randomBytes(16);
|
||||
const hash = crypto.scryptSync(password, salt, 64);
|
||||
const storedAuth = `scrypt:${salt.toString('hex')}:${hash.toString('hex')}`;
|
||||
|
||||
process.env.TORCH_DASHBOARD_AUTH = storedAuth;
|
||||
_resetTorchConfigCache();
|
||||
|
||||
server = await cmdDashboard(0);
|
||||
testPort = server.address().port;
|
||||
|
||||
try {
|
||||
const makeRequest = (credentials) => {
|
||||
const auth = Buffer.from(credentials).toString('base64');
|
||||
return new Promise((resolve) => {
|
||||
http.get({
|
||||
host: '127.0.0.1',
|
||||
port: testPort,
|
||||
path: '/dashboard/',
|
||||
headers: { 'Authorization': `Basic ${auth}` }
|
||||
}, resolve);
|
||||
});
|
||||
};
|
||||
|
||||
// Correct password
|
||||
const resCorrect = await makeRequest(password);
|
||||
assert.notStrictEqual(resCorrect.statusCode, 401, 'correct hashed credentials must not be rejected');
|
||||
|
||||
// Incorrect password
|
||||
const resIncorrect = await makeRequest('admin:wrong');
|
||||
assert.strictEqual(resIncorrect.statusCode, 401, 'incorrect hashed credentials must be rejected');
|
||||
} finally {
|
||||
delete process.env.TORCH_DASHBOARD_AUTH;
|
||||
_resetTorchConfigCache();
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -91,7 +91,7 @@ test('cmdInit should validate install directory name', async (t) => {
|
||||
relays: []
|
||||
});
|
||||
} catch (e) {
|
||||
assert.notMatch(e.message, /Invalid directory name/);
|
||||
assert.doesNotMatch(e.message, /Invalid directory name/);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -105,7 +105,7 @@ test('cmdInit should validate install directory name', async (t) => {
|
||||
relays: []
|
||||
});
|
||||
} catch (e) {
|
||||
assert.notMatch(e.message, /Invalid directory name/);
|
||||
assert.doesNotMatch(e.message, /Invalid directory name/);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -119,7 +119,7 @@ test('cmdInit should validate install directory name', async (t) => {
|
||||
relays: []
|
||||
});
|
||||
} catch (e) {
|
||||
assert.notMatch(e.message, /Invalid directory name/);
|
||||
assert.doesNotMatch(e.message, /Invalid directory name/);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,192 +0,0 @@
|
||||
import { describe, it, beforeEach, afterEach, mock } from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import { publishLock, _resetRelayHealthState } from '../src/lock-ops.mjs';
|
||||
|
||||
function createScriptedPool(scriptedOutcomesByAttempt, relaysSeen) {
|
||||
let publishCallCount = 0;
|
||||
return {
|
||||
publish: (relays) => {
|
||||
publishCallCount += 1;
|
||||
relaysSeen.push({ publishAttempt: publishCallCount, relays: [...relays] });
|
||||
const attemptOutcomes = scriptedOutcomesByAttempt[publishCallCount - 1] || {};
|
||||
return relays.map((relay) => {
|
||||
const outcome = attemptOutcomes[relay] || { ok: true };
|
||||
return outcome.ok ? Promise.resolve('ok') : Promise.reject(new Error(outcome.message));
|
||||
});
|
||||
},
|
||||
close: () => {},
|
||||
getPublishCallCount: () => publishCallCount,
|
||||
};
|
||||
}
|
||||
|
||||
const parseTelemetry = (logs) => logs.map((line) => JSON.parse(line));
|
||||
|
||||
describe('publishLock retry behavior', { concurrency: false }, () => {
|
||||
beforeEach(() => {
|
||||
_resetRelayHealthState();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
mock.timers.reset();
|
||||
});
|
||||
|
||||
it('succeeds immediately on first attempt without retries', async () => {
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
const event = { id: 'evt-immediate' };
|
||||
const result = await publishLock(['wss://relay-a'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 1);
|
||||
assert.deepStrictEqual(relaysSeen, [{ publishAttempt: 1, relays: ['wss://relay-a'] }]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
assert.strictEqual(telemetry.filter((entry) => entry.event === 'lock_publish_retry').length, 0);
|
||||
const metEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_met');
|
||||
assert.ok(metEvent);
|
||||
assert.strictEqual(metEvent.publishAttempt, 1);
|
||||
});
|
||||
|
||||
it('retries a transient failure then succeeds within retry budget with bounded jitter', async () => {
|
||||
mock.timers.enable({ apis: ['Date', 'setTimeout'] });
|
||||
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const sleepCalls = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'connection reset by peer' } },
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
const result = await publishLock(['wss://relay-a'], { id: 'evt-retry-success' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 100,
|
||||
retryCapDelayMs: 500,
|
||||
randomFn: () => 0.25,
|
||||
sleepFn: async (delayMs) => {
|
||||
sleepCalls.push(delayMs);
|
||||
mock.timers.tick(delayMs);
|
||||
},
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result.id, 'evt-retry-success');
|
||||
assert.deepStrictEqual(sleepCalls, [25]);
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 2);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 1);
|
||||
assert.strictEqual(retryEvents[0].publishAttempt, 1);
|
||||
assert.strictEqual(retryEvents[0].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[0].nextDelayMs >= 0 && retryEvents[0].nextDelayMs <= 100);
|
||||
});
|
||||
|
||||
it('returns terminal relay_publish_quorum_failure after exhausting retry budget', async () => {
|
||||
mock.timers.enable({ apis: ['Date', 'setTimeout'] });
|
||||
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const sleepCalls = [];
|
||||
const randomValues = [0.1, 0.9];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
], relaysSeen);
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://relay-a'], { id: 'evt-exhausted' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 100,
|
||||
retryCapDelayMs: 250,
|
||||
randomFn: () => randomValues.shift() ?? 0,
|
||||
sleepFn: async (delayMs) => {
|
||||
sleepCalls.push(delayMs);
|
||||
mock.timers.tick(delayMs);
|
||||
},
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/error_category=relay_publish_quorum_failure/,
|
||||
);
|
||||
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 3);
|
||||
assert.deepStrictEqual(sleepCalls, [10, 180]);
|
||||
assert.deepStrictEqual(relaysSeen.map((entry) => entry.publishAttempt), [1, 2, 3]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 2);
|
||||
assert.strictEqual(retryEvents[0].publishAttempt, 1);
|
||||
assert.strictEqual(retryEvents[0].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[0].nextDelayMs >= 0 && retryEvents[0].nextDelayMs <= 100);
|
||||
assert.strictEqual(retryEvents[1].publishAttempt, 2);
|
||||
assert.strictEqual(retryEvents[1].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[1].nextDelayMs >= retryEvents[0].nextDelayMs);
|
||||
assert.ok(retryEvents[1].nextDelayMs <= 200);
|
||||
|
||||
const failedEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(failedEvent);
|
||||
assert.strictEqual(failedEvent.errorCategory, 'relay_publish_quorum_failure');
|
||||
assert.strictEqual(failedEvent.attempts, 3);
|
||||
});
|
||||
|
||||
it('short-circuits non-retryable failures without extra attempts', async () => {
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'validation failed: invalid signature' } },
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://relay-a'], { id: 'evt-permanent' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/error_category=relay_publish_non_retryable/,
|
||||
);
|
||||
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 1);
|
||||
assert.deepStrictEqual(relaysSeen, [{ publishAttempt: 1, relays: ['wss://relay-a'] }]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
assert.strictEqual(telemetry.filter((entry) => entry.event === 'lock_publish_retry').length, 0);
|
||||
|
||||
const failedEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(failedEvent);
|
||||
assert.strictEqual(failedEvent.errorCategory, 'relay_publish_non_retryable');
|
||||
assert.notStrictEqual(failedEvent.errorCategory, 'relay_publish_quorum_failure');
|
||||
});
|
||||
});
|
||||
@@ -2,7 +2,6 @@ import { describe, it, beforeEach } from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import {
|
||||
parseLockEvent,
|
||||
publishLock,
|
||||
queryLocks,
|
||||
_resetRelayHealthState,
|
||||
} from '../src/lock-ops.mjs';
|
||||
@@ -111,322 +110,4 @@ describe('lock-ops', () => {
|
||||
assert.strictEqual(locks[0].agent, 'agent1');
|
||||
});
|
||||
});
|
||||
|
||||
describe('publishLock', () => {
|
||||
it('retries transient failures and succeeds on a later attempt', async () => {
|
||||
const telemetry = [];
|
||||
const sleepCalls = [];
|
||||
let publishCalls = 0;
|
||||
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
if (publishCalls === 1) {
|
||||
return relays.map(() => Promise.reject(new Error('connection reset by peer')));
|
||||
}
|
||||
return relays.map(() => Promise.resolve('ok'));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-retry' };
|
||||
const result = await publishLock(['wss://primary-a', 'wss://primary-b'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 500,
|
||||
retryCapDelayMs: 8_000,
|
||||
randomFn: () => 0.5,
|
||||
sleepFn: async (ms) => {
|
||||
sleepCalls.push(ms);
|
||||
},
|
||||
telemetryLogger: (line) => {
|
||||
telemetry.push(JSON.parse(line));
|
||||
},
|
||||
healthLogger: () => {},
|
||||
diagnostics: {
|
||||
attemptId: 'attempt-1',
|
||||
correlationId: 'corr-1',
|
||||
},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(publishCalls, 2);
|
||||
assert.deepStrictEqual(sleepCalls, [250]);
|
||||
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 2);
|
||||
assert.deepStrictEqual(retryEvents[0], {
|
||||
event: 'lock_publish_retry',
|
||||
correlationId: 'corr-1',
|
||||
attemptId: 'attempt-1',
|
||||
publishAttempt: 1,
|
||||
relayUrl: 'wss://primary-a',
|
||||
errorCategory: 'connection_reset',
|
||||
elapsedMs: retryEvents[0].elapsedMs,
|
||||
nextDelayMs: 250,
|
||||
});
|
||||
assert.deepStrictEqual(retryEvents[1], {
|
||||
event: 'lock_publish_retry',
|
||||
correlationId: 'corr-1',
|
||||
attemptId: 'attempt-1',
|
||||
publishAttempt: 1,
|
||||
relayUrl: 'wss://primary-b',
|
||||
errorCategory: 'connection_reset',
|
||||
elapsedMs: retryEvents[1].elapsedMs,
|
||||
nextDelayMs: 250,
|
||||
});
|
||||
assert.ok(Number.isInteger(retryEvents[0].elapsedMs));
|
||||
assert.ok(Number.isInteger(retryEvents[1].elapsedMs));
|
||||
|
||||
const metEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_met');
|
||||
assert.ok(metEvent);
|
||||
assert.equal(metEvent.correlationId, 'corr-1');
|
||||
assert.equal(metEvent.attemptId, 'attempt-1');
|
||||
assert.equal(metEvent.publishAttempt, 2);
|
||||
assert.ok(Array.isArray(metEvent.retryTimeline));
|
||||
});
|
||||
|
||||
it('fails after retry budget is exhausted for persistent transient failures', async () => {
|
||||
let publishCalls = 0;
|
||||
const sleepCalls = [];
|
||||
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map(() => Promise.reject(new Error('relay unavailable')));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://primary-down'], { id: 'evt-exhausted' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
randomFn: () => 1,
|
||||
sleepFn: async (ms) => {
|
||||
sleepCalls.push(ms);
|
||||
},
|
||||
telemetryLogger: () => {},
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/Failed relay publish quorum in publish phase: 0\/1 successful \(required=1, timeout=200ms, attempts=3,/,
|
||||
);
|
||||
|
||||
assert.strictEqual(publishCalls, 3);
|
||||
assert.deepStrictEqual(sleepCalls, [500, 1000]);
|
||||
});
|
||||
|
||||
it('fails without retry for persistent validation failures', async () => {
|
||||
let publishCalls = 0;
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map(() => Promise.reject(new Error('validation failed: invalid signature')));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://primary-bad'], { id: 'evt-permanent' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
sleepFn: async () => {
|
||||
throw new Error('should not sleep for permanent failures');
|
||||
},
|
||||
telemetryLogger: () => {},
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/Failed relay publish quorum in publish phase: 0\/1 successful \(required=1, timeout=200ms, attempts=4,/,
|
||||
);
|
||||
|
||||
assert.strictEqual(publishCalls, 1);
|
||||
});
|
||||
|
||||
it('includes per-relay reason categories and retry metadata in failure diagnostics', async () => {
|
||||
const telemetry = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
if (relay.includes('dns')) return Promise.reject(new Error('getaddrinfo ENOTFOUND relay.example'));
|
||||
if (relay.includes('tcp')) return Promise.reject(new Error('connect ETIMEDOUT 1.2.3.4:443'));
|
||||
if (relay.includes('tls')) return Promise.reject(new Error('TLS handshake failure'));
|
||||
if (relay.includes('ws')) return Promise.reject(new Error('websocket: unexpected server response'));
|
||||
return Promise.reject(new Error('[publish:primary] Publish timed out after 200ms'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://dns', 'wss://tcp', 'wss://tls', 'wss://ws', 'relay-timeout'], { id: 'evt-diag' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
telemetryLogger: (line) => telemetry.push(JSON.parse(line)),
|
||||
healthLogger: () => {},
|
||||
diagnostics: { attemptId: 'attempt-42', correlationId: 'corr-42' },
|
||||
}),
|
||||
);
|
||||
|
||||
const summaryEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(summaryEvent);
|
||||
const failureEvents = telemetry.filter((entry) => entry.event === 'lock_publish_failure');
|
||||
const failureText = failureEvents.map((entry) => `${entry.relayUrl}:${entry.reason}`).join('\n');
|
||||
|
||||
assert.match(failureText, /wss:\/\/dns:dns_resolution/);
|
||||
assert.match(failureText, /wss:\/\/tcp:tcp_connect_timeout/);
|
||||
assert.match(failureText, /wss:\/\/tls:tls_handshake/);
|
||||
assert.match(failureText, /wss:\/\/ws:websocket_open_failure/);
|
||||
assert.match(failureText, /relay-timeout:publish_timeout/);
|
||||
|
||||
|
||||
assert.deepStrictEqual(summaryEvent.reasonDistribution, {
|
||||
dns_resolution: 1,
|
||||
tcp_connect_timeout: 1,
|
||||
tls_handshake: 1,
|
||||
websocket_open_failure: 1,
|
||||
publish_timeout: 1,
|
||||
});
|
||||
});
|
||||
|
||||
it('returns success when mixed relay outcomes still satisfy quorum', async () => {
|
||||
let publishCalls = 0;
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map((relay) => (
|
||||
relay === 'wss://relay-ok'
|
||||
? Promise.resolve('ok')
|
||||
: Promise.reject(new Error('validation failed: rejected event'))
|
||||
));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-mixed' };
|
||||
const result = await publishLock(['wss://relay-ok', 'wss://relay-bad'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
sleepFn: async () => {
|
||||
throw new Error('should not sleep when quorum is satisfied');
|
||||
},
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(publishCalls, 1);
|
||||
});
|
||||
|
||||
it('uses fallback relays to satisfy min success quorum', async () => {
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => (
|
||||
relay.includes('fallback-ok') ? Promise.resolve('ok') : Promise.reject(new Error('offline'))
|
||||
)),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-2' };
|
||||
const result = await publishLock(['wss://primary-bad'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => ['wss://fallback-ok'],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
});
|
||||
|
||||
it('quarantines repeatedly failing relays and still reaches quorum with one healthy relay', async () => {
|
||||
const callOrder = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
callOrder.push(relay);
|
||||
if (relay === 'wss://healthy') {
|
||||
return Promise.resolve('ok');
|
||||
}
|
||||
return Promise.reject(new Error('offline'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-health' };
|
||||
|
||||
for (let i = 0; i < 3; i += 1) {
|
||||
await publishLock(['wss://bad', 'wss://healthy'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 2,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
}
|
||||
|
||||
callOrder.length = 0;
|
||||
await publishLock(['wss://bad', 'wss://healthy'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 2,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.deepStrictEqual(callOrder, ['wss://healthy']);
|
||||
});
|
||||
|
||||
it('uses fallback and min active pool to reintroduce quarantined relay when needed', async () => {
|
||||
const attempts = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
attempts.push(relay);
|
||||
if (relay === 'wss://fallback-healthy') {
|
||||
return Promise.resolve('ok');
|
||||
}
|
||||
return Promise.reject(new Error('relay timeout'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-quorum' };
|
||||
await publishLock(['wss://primary-a', 'wss://primary-b'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => ['wss://fallback-healthy'],
|
||||
getMinActiveRelayPoolFn: () => 2,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 1,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.ok(attempts.includes('wss://fallback-healthy'));
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,508 @@
|
||||
import { describe, it, beforeEach, afterEach, mock } from 'node:test';
|
||||
import assert from 'node:assert';
|
||||
import { publishLock } from '../src/lock-publisher.mjs';
|
||||
import { defaultHealthManager } from '../src/relay-health-manager.mjs';
|
||||
|
||||
function _resetRelayHealthState() {
|
||||
defaultHealthManager.reset();
|
||||
}
|
||||
|
||||
function createScriptedPool(scriptedOutcomesByAttempt, relaysSeen) {
|
||||
let publishCallCount = 0;
|
||||
return {
|
||||
publish: (relays) => {
|
||||
publishCallCount += 1;
|
||||
relaysSeen.push({ publishAttempt: publishCallCount, relays: [...relays] });
|
||||
const attemptOutcomes = scriptedOutcomesByAttempt[publishCallCount - 1] || {};
|
||||
return relays.map((relay) => {
|
||||
const outcome = attemptOutcomes[relay] || { ok: true };
|
||||
return outcome.ok ? Promise.resolve('ok') : Promise.reject(new Error(outcome.message));
|
||||
});
|
||||
},
|
||||
close: () => {},
|
||||
getPublishCallCount: () => publishCallCount,
|
||||
};
|
||||
}
|
||||
|
||||
const parseTelemetry = (logs) => logs.map((line) => JSON.parse(line));
|
||||
|
||||
describe('LockPublisher', () => {
|
||||
beforeEach(() => {
|
||||
_resetRelayHealthState();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
mock.timers.reset();
|
||||
});
|
||||
|
||||
describe('publishLock basic and retry logic', () => {
|
||||
it('retries transient failures and succeeds on a later attempt', async () => {
|
||||
const telemetry = [];
|
||||
const sleepCalls = [];
|
||||
let publishCalls = 0;
|
||||
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
if (publishCalls === 1) {
|
||||
return relays.map(() => Promise.reject(new Error('connection reset by peer')));
|
||||
}
|
||||
return relays.map(() => Promise.resolve('ok'));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-retry' };
|
||||
const result = await publishLock(['wss://primary-a', 'wss://primary-b'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 500,
|
||||
retryCapDelayMs: 8_000,
|
||||
randomFn: () => 0.5,
|
||||
sleepFn: async (ms) => {
|
||||
sleepCalls.push(ms);
|
||||
},
|
||||
telemetryLogger: (line) => {
|
||||
telemetry.push(JSON.parse(line));
|
||||
},
|
||||
healthLogger: () => {},
|
||||
diagnostics: {
|
||||
attemptId: 'attempt-1',
|
||||
correlationId: 'corr-1',
|
||||
},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(publishCalls, 2);
|
||||
assert.deepStrictEqual(sleepCalls, [250]);
|
||||
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 2);
|
||||
assert.deepStrictEqual(retryEvents[0], {
|
||||
event: 'lock_publish_retry',
|
||||
correlationId: 'corr-1',
|
||||
attemptId: 'attempt-1',
|
||||
publishAttempt: 1,
|
||||
relayUrl: 'wss://primary-a',
|
||||
errorCategory: 'connection_reset',
|
||||
elapsedMs: retryEvents[0].elapsedMs,
|
||||
nextDelayMs: 250,
|
||||
});
|
||||
assert.deepStrictEqual(retryEvents[1], {
|
||||
event: 'lock_publish_retry',
|
||||
correlationId: 'corr-1',
|
||||
attemptId: 'attempt-1',
|
||||
publishAttempt: 1,
|
||||
relayUrl: 'wss://primary-b',
|
||||
errorCategory: 'connection_reset',
|
||||
elapsedMs: retryEvents[1].elapsedMs,
|
||||
nextDelayMs: 250,
|
||||
});
|
||||
});
|
||||
|
||||
it('fails after retry budget is exhausted for persistent transient failures', async () => {
|
||||
let publishCalls = 0;
|
||||
const sleepCalls = [];
|
||||
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map(() => Promise.reject(new Error('relay unavailable')));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://primary-down'], { id: 'evt-exhausted' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
randomFn: () => 1,
|
||||
sleepFn: async (ms) => {
|
||||
sleepCalls.push(ms);
|
||||
},
|
||||
telemetryLogger: () => {},
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/Failed relay publish quorum in publish phase: 0\/1 successful \(required=1, timeout=200ms, attempts=3,/,
|
||||
);
|
||||
|
||||
assert.strictEqual(publishCalls, 3);
|
||||
assert.deepStrictEqual(sleepCalls, [500, 1000]);
|
||||
});
|
||||
|
||||
it('fails without retry for persistent validation failures', async () => {
|
||||
let publishCalls = 0;
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map(() => Promise.reject(new Error('validation failed: invalid signature')));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://primary-bad'], { id: 'evt-permanent' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
sleepFn: async () => {
|
||||
throw new Error('should not sleep for permanent failures');
|
||||
},
|
||||
telemetryLogger: () => {},
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/Failed relay publish quorum in publish phase: 0\/1 successful \(required=1, timeout=200ms, attempts=4,/,
|
||||
);
|
||||
|
||||
assert.strictEqual(publishCalls, 1);
|
||||
});
|
||||
|
||||
it('includes per-relay reason categories and retry metadata in failure diagnostics', async () => {
|
||||
const telemetry = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
if (relay.includes('dns')) return Promise.reject(new Error('getaddrinfo ENOTFOUND relay.example'));
|
||||
if (relay.includes('tcp')) return Promise.reject(new Error('connect ETIMEDOUT 1.2.3.4:443'));
|
||||
if (relay.includes('tls')) return Promise.reject(new Error('TLS handshake failure'));
|
||||
if (relay.includes('ws')) return Promise.reject(new Error('websocket: unexpected server response'));
|
||||
return Promise.reject(new Error('[publish:primary] Publish timed out after 200ms'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://dns', 'wss://tcp', 'wss://tls', 'wss://ws', 'relay-timeout'], { id: 'evt-diag' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
telemetryLogger: (line) => telemetry.push(JSON.parse(line)),
|
||||
healthLogger: () => {},
|
||||
diagnostics: { attemptId: 'attempt-42', correlationId: 'corr-42' },
|
||||
}),
|
||||
);
|
||||
|
||||
const summaryEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(summaryEvent);
|
||||
const failureEvents = telemetry.filter((entry) => entry.event === 'lock_publish_failure');
|
||||
const failureText = failureEvents.map((entry) => `${entry.relayUrl}:${entry.reason}`).join('\n');
|
||||
|
||||
assert.match(failureText, /wss:\/\/dns:dns_resolution/);
|
||||
assert.match(failureText, /wss:\/\/tcp:tcp_connect_timeout/);
|
||||
assert.match(failureText, /wss:\/\/tls:tls_handshake/);
|
||||
assert.match(failureText, /wss:\/\/ws:websocket_open_failure/);
|
||||
assert.match(failureText, /relay-timeout:publish_timeout/);
|
||||
|
||||
|
||||
assert.deepStrictEqual(summaryEvent.reasonDistribution, {
|
||||
dns_resolution: 1,
|
||||
tcp_connect_timeout: 1,
|
||||
tls_handshake: 1,
|
||||
websocket_open_failure: 1,
|
||||
publish_timeout: 1,
|
||||
});
|
||||
});
|
||||
|
||||
it('returns success when mixed relay outcomes still satisfy quorum', async () => {
|
||||
let publishCalls = 0;
|
||||
const mockPool = {
|
||||
publish: (relays) => {
|
||||
publishCalls += 1;
|
||||
return relays.map((relay) => (
|
||||
relay === 'wss://relay-ok'
|
||||
? Promise.resolve('ok')
|
||||
: Promise.reject(new Error('validation failed: rejected event'))
|
||||
));
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-mixed' };
|
||||
const result = await publishLock(['wss://relay-ok', 'wss://relay-bad'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
sleepFn: async () => {
|
||||
throw new Error('should not sleep when quorum is satisfied');
|
||||
},
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(publishCalls, 1);
|
||||
});
|
||||
|
||||
it('uses fallback relays to satisfy min success quorum', async () => {
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => (
|
||||
relay.includes('fallback-ok') ? Promise.resolve('ok') : Promise.reject(new Error('offline'))
|
||||
)),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-2' };
|
||||
const result = await publishLock(['wss://primary-bad'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => ['wss://fallback-ok'],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
});
|
||||
|
||||
it('quarantines repeatedly failing relays and still reaches quorum with one healthy relay', async () => {
|
||||
const callOrder = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
callOrder.push(relay);
|
||||
if (relay === 'wss://healthy') {
|
||||
return Promise.resolve('ok');
|
||||
}
|
||||
return Promise.reject(new Error('offline'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-health' };
|
||||
|
||||
for (let i = 0; i < 3; i += 1) {
|
||||
await publishLock(['wss://bad', 'wss://healthy'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 2,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
}
|
||||
|
||||
callOrder.length = 0;
|
||||
await publishLock(['wss://bad', 'wss://healthy'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 2,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.deepStrictEqual(callOrder, ['wss://healthy']);
|
||||
});
|
||||
|
||||
it('uses fallback and min active pool to reintroduce quarantined relay when needed', async () => {
|
||||
const attempts = [];
|
||||
const mockPool = {
|
||||
publish: (relays) => relays.map((relay) => {
|
||||
attempts.push(relay);
|
||||
if (relay === 'wss://fallback-healthy') {
|
||||
return Promise.resolve('ok');
|
||||
}
|
||||
return Promise.reject(new Error('relay timeout'));
|
||||
}),
|
||||
close: () => {},
|
||||
};
|
||||
|
||||
const event = { id: 'evt-quorum' };
|
||||
await publishLock(['wss://primary-a', 'wss://primary-b'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => ['wss://fallback-healthy'],
|
||||
getMinActiveRelayPoolFn: () => 2,
|
||||
retryAttempts: 1,
|
||||
failureThreshold: 1,
|
||||
quarantineCooldownMs: 60_000,
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.ok(attempts.includes('wss://fallback-healthy'));
|
||||
});
|
||||
});
|
||||
|
||||
describe('scripted retry scenarios', () => {
|
||||
it('succeeds immediately on first attempt without retries', async () => {
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
const event = { id: 'evt-immediate' };
|
||||
const result = await publishLock(['wss://relay-a'], event, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result, event);
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 1);
|
||||
assert.deepStrictEqual(relaysSeen, [{ publishAttempt: 1, relays: ['wss://relay-a'] }]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
assert.strictEqual(telemetry.filter((entry) => entry.event === 'lock_publish_retry').length, 0);
|
||||
const metEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_met');
|
||||
assert.ok(metEvent);
|
||||
assert.strictEqual(metEvent.publishAttempt, 1);
|
||||
});
|
||||
|
||||
it('retries a transient failure then succeeds within retry budget with bounded jitter', async () => {
|
||||
mock.timers.enable({ apis: ['Date', 'setTimeout'] });
|
||||
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const sleepCalls = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'connection reset by peer' } },
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
const result = await publishLock(['wss://relay-a'], { id: 'evt-retry-success' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 100,
|
||||
retryCapDelayMs: 500,
|
||||
randomFn: () => 0.25,
|
||||
sleepFn: async (delayMs) => {
|
||||
sleepCalls.push(delayMs);
|
||||
mock.timers.tick(delayMs);
|
||||
},
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
});
|
||||
|
||||
assert.strictEqual(result.id, 'evt-retry-success');
|
||||
assert.deepStrictEqual(sleepCalls, [25]);
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 2);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 1);
|
||||
assert.strictEqual(retryEvents[0].publishAttempt, 1);
|
||||
assert.strictEqual(retryEvents[0].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[0].nextDelayMs >= 0 && retryEvents[0].nextDelayMs <= 100);
|
||||
});
|
||||
|
||||
it('returns terminal relay_publish_quorum_failure after exhausting retry budget', async () => {
|
||||
mock.timers.enable({ apis: ['Date', 'setTimeout'] });
|
||||
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const sleepCalls = [];
|
||||
const randomValues = [0.1, 0.9];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
{ 'wss://relay-a': { ok: false, message: 'relay unavailable' } },
|
||||
], relaysSeen);
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://relay-a'], { id: 'evt-exhausted' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 3,
|
||||
retryBaseDelayMs: 100,
|
||||
retryCapDelayMs: 250,
|
||||
randomFn: () => randomValues.shift() ?? 0,
|
||||
sleepFn: async (delayMs) => {
|
||||
sleepCalls.push(delayMs);
|
||||
mock.timers.tick(delayMs);
|
||||
},
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/error_category=relay_publish_quorum_failure/,
|
||||
);
|
||||
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 3);
|
||||
assert.deepStrictEqual(sleepCalls, [10, 180]);
|
||||
assert.deepStrictEqual(relaysSeen.map((entry) => entry.publishAttempt), [1, 2, 3]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
const retryEvents = telemetry.filter((entry) => entry.event === 'lock_publish_retry');
|
||||
assert.strictEqual(retryEvents.length, 2);
|
||||
assert.strictEqual(retryEvents[0].publishAttempt, 1);
|
||||
assert.strictEqual(retryEvents[0].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[0].nextDelayMs >= 0 && retryEvents[0].nextDelayMs <= 100);
|
||||
assert.strictEqual(retryEvents[1].publishAttempt, 2);
|
||||
assert.strictEqual(retryEvents[1].relayUrl, 'wss://relay-a');
|
||||
assert.ok(retryEvents[1].nextDelayMs >= retryEvents[0].nextDelayMs);
|
||||
assert.ok(retryEvents[1].nextDelayMs <= 200);
|
||||
|
||||
const failedEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(failedEvent);
|
||||
assert.strictEqual(failedEvent.errorCategory, 'relay_publish_quorum_failure');
|
||||
assert.strictEqual(failedEvent.attempts, 3);
|
||||
});
|
||||
|
||||
it('short-circuits non-retryable failures without extra attempts', async () => {
|
||||
const telemetryLogs = [];
|
||||
const relaysSeen = [];
|
||||
const mockPool = createScriptedPool([
|
||||
{ 'wss://relay-a': { ok: false, message: 'validation failed: invalid signature' } },
|
||||
{ 'wss://relay-a': { ok: true } },
|
||||
], relaysSeen);
|
||||
|
||||
await assert.rejects(
|
||||
() => publishLock(['wss://relay-a'], { id: 'evt-permanent' }, {
|
||||
poolFactory: () => mockPool,
|
||||
getPublishTimeoutMsFn: () => 200,
|
||||
getMinSuccessfulRelayPublishesFn: () => 1,
|
||||
getRelayFallbacksFn: () => [],
|
||||
getMinActiveRelayPoolFn: () => 1,
|
||||
retryAttempts: 4,
|
||||
telemetryLogger: (line) => telemetryLogs.push(line),
|
||||
healthLogger: () => {},
|
||||
}),
|
||||
/error_category=relay_publish_non_retryable/,
|
||||
);
|
||||
|
||||
assert.strictEqual(mockPool.getPublishCallCount(), 1);
|
||||
assert.deepStrictEqual(relaysSeen, [{ publishAttempt: 1, relays: ['wss://relay-a'] }]);
|
||||
|
||||
const telemetry = parseTelemetry(telemetryLogs);
|
||||
assert.strictEqual(telemetry.filter((entry) => entry.event === 'lock_publish_retry').length, 0);
|
||||
|
||||
const failedEvent = telemetry.find((entry) => entry.event === 'lock_publish_quorum_failed');
|
||||
assert.ok(failedEvent);
|
||||
assert.strictEqual(failedEvent.errorCategory, 'relay_publish_non_retryable');
|
||||
assert.notStrictEqual(failedEvent.errorCategory, 'relay_publish_quorum_failure');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -77,3 +77,16 @@ test('blocks decrypted/session-sensitive data from durable promotion without san
|
||||
assert.equal(events[1].durable_eligible, true);
|
||||
assert.equal(cache.getMetrics().runtime_sensitive_events_blocked, 1);
|
||||
});
|
||||
|
||||
test('prunes cache entries based on predicate', () => {
|
||||
const cache = createMemoryCache();
|
||||
cache.set('key1', 'value1');
|
||||
cache.set('key2', 'value2');
|
||||
cache.set('other', 'value3');
|
||||
|
||||
cache.prune((key) => key.startsWith('key'));
|
||||
|
||||
assert.equal(cache.get('key1'), undefined);
|
||||
assert.equal(cache.get('key2'), undefined);
|
||||
assert.equal(cache.get('other'), 'value3');
|
||||
});
|
||||
+69
-29
@@ -5,8 +5,9 @@ import { getRoster, _resetRosterCache, _setRosterDependencies, _restoreRosterDep
|
||||
|
||||
// Mock dependencies
|
||||
const mockFs = {
|
||||
existsSync: mock.fn(),
|
||||
readFileSync: mock.fn(),
|
||||
promises: {
|
||||
readFile: mock.fn(),
|
||||
},
|
||||
};
|
||||
|
||||
const mockLoadTorchConfig = mock.fn();
|
||||
@@ -25,18 +26,18 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
console.error = mockConsoleError;
|
||||
|
||||
_resetRosterCache();
|
||||
mockFs.existsSync.mock.resetCalls();
|
||||
mockFs.readFileSync.mock.resetCalls();
|
||||
mockFs.promises.readFile.mock.resetCalls();
|
||||
mockLoadTorchConfig.mock.resetCalls();
|
||||
|
||||
// Default: config returns empty nostrLock
|
||||
mockLoadTorchConfig.mock.mockImplementation(async () => ({ nostrLock: {} }));
|
||||
|
||||
// Default: fs.existsSync returns false (no files found)
|
||||
mockFs.existsSync.mock.mockImplementation(() => false);
|
||||
|
||||
// Default: fs.readFileSync returns empty object
|
||||
mockFs.readFileSync.mock.mockImplementation(() => '{}');
|
||||
// Default: fs.promises.readFile returns ENOENT
|
||||
mockFs.promises.readFile.mock.mockImplementation(async () => {
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
// Inject mocks
|
||||
_setRosterDependencies({
|
||||
@@ -63,11 +64,20 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
});
|
||||
|
||||
it('loads internal module roster if user/cwd rosters are missing', async () => {
|
||||
// User/CWD missing
|
||||
mockFs.existsSync.mock.mockImplementation(() => false);
|
||||
// When reading file, if it's not USER or CWD (implied by default ENOENT), check ROSTER_FILE logic?
|
||||
// Wait, the logic tries USER -> CWD -> ROSTER.
|
||||
// So if first two fail (default), third one should succeed for this test.
|
||||
|
||||
// When reading file, return internal roster content
|
||||
mockFs.readFileSync.mock.mockImplementation(() => {
|
||||
// We need to verify that it eventually reads internal roster (ROSTER_FILE).
|
||||
// But since we don't know the exact path of ROSTER_FILE easily in test (it depends on import.meta.url),
|
||||
// we can just say "if not USER or CWD, return content".
|
||||
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE || filepath === CWD_ROSTER_FILE) {
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
}
|
||||
return JSON.stringify({ daily: ['internal-daily'], weekly: ['internal-weekly'] });
|
||||
});
|
||||
|
||||
@@ -76,12 +86,13 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
});
|
||||
|
||||
it('loads roster from torch/roster.json (User Roster) if present', async () => {
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === USER_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation((filepath) => {
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE) {
|
||||
return JSON.stringify({ daily: ['user-agent-daily'], weekly: ['user-agent-weekly'] });
|
||||
}
|
||||
throw new Error('ENOENT');
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
const daily = await getRoster('daily');
|
||||
@@ -89,16 +100,21 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
|
||||
assert.deepStrictEqual(daily, ['user-agent-daily']);
|
||||
assert.deepStrictEqual(weekly, ['user-agent-weekly']);
|
||||
assert.strictEqual(mockFs.readFileSync.mock.calls.length, 1); // Should be cached after first call
|
||||
|
||||
// Should be cached after first call
|
||||
// Note: getRoster calls loadCanonicalRoster each time but it caches result internally.
|
||||
// However, since we call getRoster twice, and result is cached, readFile should be called once.
|
||||
assert.strictEqual(mockFs.promises.readFile.mock.calls.length, 1);
|
||||
});
|
||||
|
||||
it('loads roster from roster.json (CWD Roster) if present and torch/roster.json is missing', async () => {
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === CWD_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation((filepath) => {
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === CWD_ROSTER_FILE) {
|
||||
return JSON.stringify({ daily: ['cwd-agent-daily'], weekly: ['cwd-agent-weekly'] });
|
||||
}
|
||||
throw new Error('ENOENT');
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
const daily = await getRoster('daily');
|
||||
@@ -106,20 +122,32 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
});
|
||||
|
||||
it('falls back to default if roster file is malformed', async () => {
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === USER_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation(() => '{ invalid json }');
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE) {
|
||||
return '{ invalid json }';
|
||||
}
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
// Should catch error and return fallback
|
||||
const daily = await getRoster('daily');
|
||||
assert.ok(daily.includes('audit-agent'));
|
||||
|
||||
// Should have tried to read file
|
||||
assert.strictEqual(mockFs.readFileSync.mock.calls.length, 1);
|
||||
assert.strictEqual(mockFs.promises.readFile.mock.calls.length, 1);
|
||||
});
|
||||
|
||||
it('falls back to default if roster file is missing daily/weekly arrays', async () => {
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === USER_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation(() => JSON.stringify({ other: [] }));
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE) {
|
||||
return JSON.stringify({ other: [] });
|
||||
}
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
const daily = await getRoster('daily');
|
||||
assert.ok(daily.includes('audit-agent'));
|
||||
@@ -129,8 +157,14 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
process.env.NOSTR_LOCK_DAILY_ROSTER = 'env-agent-daily';
|
||||
|
||||
// Setup file to exist
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === USER_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation(() => JSON.stringify({ daily: ['file-agent'] }));
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE) {
|
||||
return JSON.stringify({ daily: ['file-agent'] });
|
||||
}
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
const daily = await getRoster('daily');
|
||||
assert.deepStrictEqual(daily, ['env-agent-daily']);
|
||||
@@ -142,8 +176,14 @@ describe('Roster (Unit Tests with Dependency Injection)', () => {
|
||||
}));
|
||||
|
||||
// Setup file to exist
|
||||
mockFs.existsSync.mock.mockImplementation((filepath) => filepath === USER_ROSTER_FILE);
|
||||
mockFs.readFileSync.mock.mockImplementation(() => JSON.stringify({ daily: ['file-agent'] }));
|
||||
mockFs.promises.readFile.mock.mockImplementation(async (filepath) => {
|
||||
if (filepath === USER_ROSTER_FILE) {
|
||||
return JSON.stringify({ daily: ['file-agent'] });
|
||||
}
|
||||
const err = new Error('ENOENT');
|
||||
err.code = 'ENOENT';
|
||||
throw err;
|
||||
});
|
||||
|
||||
const daily = await getRoster('daily');
|
||||
assert.deepStrictEqual(daily, ['config-agent-daily']);
|
||||
|
||||
+3738
File diff suppressed because it is too large.
Load diff
+3737
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user