Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 xingyue
|
f93e6901ac |
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@uncaged/nerve-cli",
|
||||
"version": "0.1.4",
|
||||
"version": "0.1.2",
|
||||
"type": "module",
|
||||
"bin": {
|
||||
"nerve": "dist/cli.js"
|
||||
|
||||
@@ -4,21 +4,15 @@
|
||||
*/
|
||||
|
||||
import type {
|
||||
ArchiveLogsDayResult as DaemonArchiveLogsDayResult,
|
||||
ArchiveLogsOptions as DaemonArchiveLogsOptions,
|
||||
ArchiveLogsResult as DaemonArchiveLogsResult,
|
||||
LogEntry as DaemonLogEntry,
|
||||
LogQuery as DaemonLogQuery,
|
||||
LogStore as DaemonLogStore,
|
||||
WorkflowRun as DaemonWorkflowRun,
|
||||
WorkflowRunStatus as DaemonWorkflowRunStatus,
|
||||
} from "@uncaged/nerve-daemon";
|
||||
import { describe, expectTypeOf, it } from "vitest";
|
||||
import { describe, it, expectTypeOf } from "vitest";
|
||||
|
||||
import type {
|
||||
ArchiveLogsDayResult,
|
||||
ArchiveLogsOptions,
|
||||
ArchiveLogsResult,
|
||||
LogEntry,
|
||||
LogQuery,
|
||||
LogStore,
|
||||
@@ -48,26 +42,6 @@ describe("daemon-types drift guard", () => {
|
||||
});
|
||||
|
||||
it("LogStore has all required methods", () => {
|
||||
expectTypeOf<LogStore>().toMatchTypeOf<
|
||||
Pick<
|
||||
DaemonLogStore,
|
||||
| "query"
|
||||
| "getWorkflowRun"
|
||||
| "getActiveWorkflowRuns"
|
||||
| "getAllWorkflowRuns"
|
||||
| "upsertWorkflowRun"
|
||||
| "archiveLogs"
|
||||
| "close"
|
||||
>
|
||||
>();
|
||||
});
|
||||
|
||||
it("ArchiveLogs types match daemon", () => {
|
||||
expectTypeOf<ArchiveLogsOptions>().toMatchTypeOf<DaemonArchiveLogsOptions>();
|
||||
expectTypeOf<DaemonArchiveLogsOptions>().toMatchTypeOf<ArchiveLogsOptions>();
|
||||
expectTypeOf<ArchiveLogsResult>().toMatchTypeOf<DaemonArchiveLogsResult>();
|
||||
expectTypeOf<DaemonArchiveLogsResult>().toMatchTypeOf<ArchiveLogsResult>();
|
||||
expectTypeOf<ArchiveLogsDayResult>().toMatchTypeOf<DaemonArchiveLogsDayResult>();
|
||||
expectTypeOf<DaemonArchiveLogsDayResult>().toMatchTypeOf<ArchiveLogsDayResult>();
|
||||
expectTypeOf<LogStore>().toMatchTypeOf<Pick<DaemonLogStore, "query" | "getWorkflowRun" | "getActiveWorkflowRuns" | "getAllWorkflowRuns" | "upsertWorkflowRun" | "close">>();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,295 +0,0 @@
|
||||
/**
|
||||
* Tests for `nerve sense list` — formatting helpers and IPC round-trip.
|
||||
*
|
||||
* Covers:
|
||||
* - formatDuration helper
|
||||
* - formatSenseList output
|
||||
* - sensesFromConfig (static fallback from nerve.yaml)
|
||||
* - listSensesViaDaemon IPC round-trip via real Unix socket
|
||||
*/
|
||||
|
||||
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { createServer } from "node:net";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
||||
|
||||
import { listSensesViaDaemon } from "../daemon-client.js";
|
||||
import type { SenseInfo } from "../daemon-client.js";
|
||||
import { formatDuration, formatSenseList, sensesFromConfig } from "../commands/sense.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fixtures
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const SAMPLE_SENSES: SenseInfo[] = [
|
||||
{ name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 1_700_000_000_000 },
|
||||
{ name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
|
||||
{ name: "active-tasks", group: "tasks", throttle: 10000, timeout: 30000, lastSignalTs: null },
|
||||
];
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// formatDuration
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("formatDuration", () => {
|
||||
it("returns '—' for null", () => {
|
||||
expect(formatDuration(null)).toBe("—");
|
||||
});
|
||||
|
||||
it("formats sub-minute durations as seconds", () => {
|
||||
expect(formatDuration(0)).toBe("0s");
|
||||
expect(formatDuration(1000)).toBe("1s");
|
||||
expect(formatDuration(59000)).toBe("59s");
|
||||
});
|
||||
|
||||
it("formats minute-range durations as Xm Ys", () => {
|
||||
expect(formatDuration(60000)).toBe("1m 0s");
|
||||
expect(formatDuration(90000)).toBe("1m 30s");
|
||||
expect(formatDuration(3599000)).toBe("59m 59s");
|
||||
});
|
||||
|
||||
it("formats hour-range durations as Xh Ym", () => {
|
||||
expect(formatDuration(3600000)).toBe("1h 0m");
|
||||
expect(formatDuration(3660000)).toBe("1h 1m");
|
||||
expect(formatDuration(7200000)).toBe("2h 0m");
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// formatSenseList
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("formatSenseList", () => {
|
||||
it("returns empty message when no senses", () => {
|
||||
const output = formatSenseList([]);
|
||||
expect(output).toContain("No senses registered");
|
||||
});
|
||||
|
||||
it("shows sense count in header", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
expect(output).toContain("3");
|
||||
});
|
||||
|
||||
it("shows each sense name", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
expect(output).toContain("cpu-usage");
|
||||
expect(output).toContain("disk-usage");
|
||||
expect(output).toContain("active-tasks");
|
||||
});
|
||||
|
||||
it("shows group for each sense", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
expect(output).toContain("system");
|
||||
expect(output).toContain("tasks");
|
||||
});
|
||||
|
||||
it("shows throttle and timeout durations", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
// cpu-usage: throttle=5s, timeout=3s
|
||||
expect(output).toContain("5s");
|
||||
expect(output).toContain("3s");
|
||||
// disk-usage: timeout=null → '—'
|
||||
expect(output).toContain("—");
|
||||
});
|
||||
|
||||
it("shows '(never)' when lastSignalTs is null", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
expect(output).toContain("(never)");
|
||||
});
|
||||
|
||||
it("shows ISO timestamp when lastSignalTs is set", () => {
|
||||
const output = formatSenseList(SAMPLE_SENSES);
|
||||
// cpu-usage has lastSignalTs = 1_700_000_000_000
|
||||
expect(output).toContain(new Date(1_700_000_000_000).toISOString());
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// sensesFromConfig — static fallback from nerve.yaml
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("sensesFromConfig", () => {
|
||||
let tmpDir: string;
|
||||
|
||||
beforeEach(() => {
|
||||
tmpDir = mkdtempSync(join(tmpdir(), "nerve-sense-list-test-"));
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rmSync(tmpDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it("returns empty array when file does not exist", () => {
|
||||
const result = sensesFromConfig(join(tmpDir, "nonexistent.yaml"));
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
|
||||
it("returns empty array when file has invalid YAML", () => {
|
||||
const path = join(tmpDir, "nerve.yaml");
|
||||
writeFileSync(path, "not: valid: yaml: :::");
|
||||
const result = sensesFromConfig(path);
|
||||
expect(result).toEqual([]);
|
||||
});
|
||||
|
||||
it("parses senses from valid nerve.yaml", () => {
|
||||
const path = join(tmpDir, "nerve.yaml");
|
||||
writeFileSync(
|
||||
path,
|
||||
`
|
||||
senses:
|
||||
cpu-usage:
|
||||
group: system
|
||||
throttle: 5s
|
||||
timeout: 3s
|
||||
disk-usage:
|
||||
group: system
|
||||
throttle: 30s
|
||||
reflexes: []
|
||||
`.trim(),
|
||||
);
|
||||
const result = sensesFromConfig(path);
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result[0]).toMatchObject({ name: "cpu-usage", group: "system", lastSignalTs: null });
|
||||
expect(result[1]).toMatchObject({ name: "disk-usage", group: "system", lastSignalTs: null });
|
||||
});
|
||||
|
||||
it("always sets lastSignalTs to null (static fallback)", () => {
|
||||
const path = join(tmpDir, "nerve.yaml");
|
||||
writeFileSync(
|
||||
path,
|
||||
`
|
||||
senses:
|
||||
my-sense:
|
||||
group: default
|
||||
reflexes: []
|
||||
`.trim(),
|
||||
);
|
||||
const result = sensesFromConfig(path);
|
||||
expect(result[0].lastSignalTs).toBeNull();
|
||||
});
|
||||
|
||||
it("populates throttle and timeout from config", () => {
|
||||
const path = join(tmpDir, "nerve.yaml");
|
||||
writeFileSync(
|
||||
path,
|
||||
`
|
||||
senses:
|
||||
my-sense:
|
||||
group: default
|
||||
throttle: 10s
|
||||
timeout: 5s
|
||||
reflexes: []
|
||||
`.trim(),
|
||||
);
|
||||
const result = sensesFromConfig(path);
|
||||
expect(result[0].throttle).toBe(10000);
|
||||
expect(result[0].timeout).toBe(5000);
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// listSensesViaDaemon — IPC round-trip via real Unix socket
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("listSensesViaDaemon", () => {
|
||||
let sockDir: string;
|
||||
let sockPath: string;
|
||||
|
||||
beforeEach(() => {
|
||||
sockDir = mkdtempSync(join(tmpdir(), "nerve-sense-list-ipc-"));
|
||||
sockPath = join(sockDir, "nerve.sock");
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rmSync(sockDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it("resolves with { ok: true, senses: [] } when daemon returns empty list", async () => {
|
||||
const server = createServer((s) => {
|
||||
s.on("data", (chunk: Buffer) => {
|
||||
const line = chunk.toString("utf8").trim();
|
||||
try {
|
||||
const req = JSON.parse(line) as { type: string };
|
||||
if (req.type === "list-senses") {
|
||||
s.write(`${JSON.stringify({ ok: true, senses: [] })}\n`);
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await listSensesViaDaemon(sockPath);
|
||||
expect(result).toEqual({ ok: true, senses: [] });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
|
||||
it("resolves with populated senses array", async () => {
|
||||
const senses: SenseInfo[] = [
|
||||
{ name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 12345 },
|
||||
];
|
||||
const server = createServer((s) => {
|
||||
s.on("data", () => {
|
||||
s.write(`${JSON.stringify({ ok: true, senses })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await listSensesViaDaemon(sockPath);
|
||||
expect(result).toEqual({ ok: true, senses });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
|
||||
it("resolves with { ok: false, error } when daemon returns an error", async () => {
|
||||
const server = createServer((s) => {
|
||||
s.on("data", () => {
|
||||
s.write(`${JSON.stringify({ ok: false, error: "something went wrong" })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await listSensesViaDaemon(sockPath);
|
||||
expect(result).toEqual({ ok: false, error: "something went wrong" });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
|
||||
it("rejects when no daemon is listening on the socket", async () => {
|
||||
await expect(listSensesViaDaemon(sockPath)).rejects.toThrow(/Cannot connect to daemon/);
|
||||
});
|
||||
|
||||
it("sends a list-senses IPC message to the daemon", async () => {
|
||||
const received: unknown[] = [];
|
||||
const server = createServer((s) => {
|
||||
s.on("data", (chunk: Buffer) => {
|
||||
const line = chunk.toString("utf8").trim();
|
||||
try {
|
||||
received.push(JSON.parse(line));
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
s.write(`${JSON.stringify({ ok: true, senses: [] })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
await listSensesViaDaemon(sockPath);
|
||||
expect(received).toHaveLength(1);
|
||||
expect(received[0]).toMatchObject({ type: "list-senses" });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,110 +0,0 @@
|
||||
/**
|
||||
* Tests for the sense CLI helper — triggerSenseViaDaemon IPC round-trip.
|
||||
*
|
||||
* Uses a real Unix socket server to validate the full client/server
|
||||
* protocol without requiring a running daemon process.
|
||||
*/
|
||||
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { createServer } from "node:net";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
||||
|
||||
import { triggerSenseViaDaemon } from "../daemon-client.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Test setup
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
let sockDir: string;
|
||||
let sockPath: string;
|
||||
|
||||
beforeEach(() => {
|
||||
sockDir = mkdtempSync(join(tmpdir(), "nerve-sense-test-"));
|
||||
sockPath = join(sockDir, "nerve.sock");
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rmSync(sockDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// triggerSenseViaDaemon — IPC round-trip via real Unix socket
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("triggerSenseViaDaemon", () => {
|
||||
it("resolves { ok: true } when daemon responds ok", async () => {
|
||||
const received: unknown[] = [];
|
||||
|
||||
const server = createServer((s) => {
|
||||
s.on("data", (chunk: Buffer) => {
|
||||
const line = chunk.toString("utf8").trim();
|
||||
try {
|
||||
received.push(JSON.parse(line));
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
s.write(`${JSON.stringify({ ok: true })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await triggerSenseViaDaemon(sockPath, "cpu-usage");
|
||||
expect(result).toEqual({ ok: true });
|
||||
// Verify the correct IPC message was sent
|
||||
expect(received).toHaveLength(1);
|
||||
expect(received[0]).toMatchObject({ type: "trigger-sense", sense: "cpu-usage" });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
|
||||
it("resolves { ok: false, error } when daemon rejects the sense", async () => {
|
||||
const server = createServer((s) => {
|
||||
s.on("data", () => {
|
||||
s.write(`${JSON.stringify({ ok: false, error: 'Unknown sense: "no-such-sense"' })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await triggerSenseViaDaemon(sockPath, "no-such-sense");
|
||||
expect(result).toEqual({ ok: false, error: 'Unknown sense: "no-such-sense"' });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
|
||||
it("rejects when no daemon is listening on the socket", async () => {
|
||||
await expect(triggerSenseViaDaemon(sockPath, "cpu-usage")).rejects.toThrow(
|
||||
/Cannot connect to daemon/,
|
||||
);
|
||||
});
|
||||
|
||||
it("sends the sense name exactly as provided", async () => {
|
||||
const received: unknown[] = [];
|
||||
|
||||
const server = createServer((s) => {
|
||||
s.on("data", (chunk: Buffer) => {
|
||||
const line = chunk.toString("utf8").trim();
|
||||
try {
|
||||
received.push(JSON.parse(line));
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
s.write(`${JSON.stringify({ ok: true })}\n`);
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
await triggerSenseViaDaemon(sockPath, "my-custom-sense");
|
||||
expect(received[0]).toMatchObject({ sense: "my-custom-sense" });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -6,7 +6,6 @@ import { senseCommand } from "./commands/sense.js";
|
||||
import { startCommand } from "./commands/start.js";
|
||||
import { statusCommand } from "./commands/status.js";
|
||||
import { stopCommand } from "./commands/stop.js";
|
||||
import { storeCommand } from "./commands/store.js";
|
||||
import { validateCommand } from "./commands/validate.js";
|
||||
import { workflowCommand } from "./commands/workflow.js";
|
||||
|
||||
@@ -23,7 +22,6 @@ const main = defineCommand({
|
||||
logs: logsCommand,
|
||||
validate: validateCommand,
|
||||
sense: senseCommand,
|
||||
store: storeCommand,
|
||||
workflow: workflowCommand,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -219,6 +219,23 @@ const initWorkspaceCommand = defineCommand({
|
||||
},
|
||||
});
|
||||
|
||||
async function tryRequireSqlite(nerveRoot: string): Promise<boolean> {
|
||||
try {
|
||||
const modulePath = join(nerveRoot, "node_modules", "better-sqlite3");
|
||||
// Use a child process to test if the native module loads
|
||||
const { execFile } = await import("node:child_process");
|
||||
const { promisify } = await import("node:util");
|
||||
const execFileAsync = promisify(execFile);
|
||||
await execFileAsync("node", ["-e", `require(${JSON.stringify(modulePath)})`], {
|
||||
cwd: nerveRoot,
|
||||
timeout: 10_000,
|
||||
});
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function runInitWorkspace(force: boolean): Promise<void> {
|
||||
const nerveRoot = getNerveRoot();
|
||||
|
||||
@@ -242,20 +259,36 @@ async function runInitWorkspace(force: boolean): Promise<void> {
|
||||
);
|
||||
|
||||
process.stdout.write("Installing dependencies…\n");
|
||||
const { cmd, installArgs } = await detectPackageManager();
|
||||
try {
|
||||
const { cmd, installArgs } = await detectPackageManager();
|
||||
await runCommand(cmd, installArgs, nerveRoot);
|
||||
} catch {
|
||||
process.stdout.write(
|
||||
`⚠️ Install failed. Try manually:\n cd ${nerveRoot} && ${cmd} ${installArgs.join(" ")}\n`,
|
||||
);
|
||||
}
|
||||
|
||||
process.stdout.write("Rebuilding native module better-sqlite3…\n");
|
||||
try {
|
||||
await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
|
||||
} catch {
|
||||
// Verify better-sqlite3 native module — rebuild up to 2 times if broken
|
||||
const sqlitePath = join(nerveRoot, "node_modules", "better-sqlite3");
|
||||
if (existsSync(sqlitePath)) {
|
||||
for (let attempt = 1; attempt <= 2; attempt++) {
|
||||
if (await tryRequireSqlite(nerveRoot)) break;
|
||||
process.stdout.write(
|
||||
"⚠️ rebuild better-sqlite3 failed — if the daemon fails to start, reinstall from the workspace directory.\n",
|
||||
`${attempt === 1 ? "Building" : "Retrying build of"} native module better-sqlite3 (attempt ${attempt}/2)…\n`,
|
||||
);
|
||||
try {
|
||||
await runCommand(cmd, ["rebuild", "better-sqlite3"], nerveRoot);
|
||||
} catch {
|
||||
// will be caught by the verify below
|
||||
}
|
||||
}
|
||||
if (!(await tryRequireSqlite(nerveRoot))) {
|
||||
process.stdout.write(
|
||||
`⚠️ better-sqlite3 native module is not working. The daemon will fail to start.\n` +
|
||||
` Fix: cd ${nerveRoot} && ${cmd} rebuild better-sqlite3\n` +
|
||||
` Or: npm install --build-from-source better-sqlite3\n`,
|
||||
);
|
||||
}
|
||||
} catch {
|
||||
process.stdout.write("⚠️ Install failed — you may need to install dependencies manually.\n");
|
||||
}
|
||||
|
||||
if (!existsSync(join(nerveRoot, ".git"))) {
|
||||
|
||||
@@ -1,105 +1,7 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { parseNerveConfig } from "@uncaged/nerve-core";
|
||||
import { defineCommand } from "citty";
|
||||
|
||||
import { listSensesViaDaemon, triggerSenseViaDaemon } from "../daemon-client.js";
|
||||
import type { SenseInfo } from "../daemon-client.js";
|
||||
import { getNerveRoot, getSocketPath, isRunning } from "../workspace.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Formatting helpers (exported for tests)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export function formatDuration(ms: number | null): string {
|
||||
if (ms === null) return "—";
|
||||
const totalSeconds = Math.floor(ms / 1000);
|
||||
if (totalSeconds < 60) return `${totalSeconds}s`;
|
||||
const minutes = Math.floor(totalSeconds / 60);
|
||||
const seconds = totalSeconds % 60;
|
||||
if (minutes < 60) return `${minutes}m ${seconds}s`;
|
||||
const hours = Math.floor(minutes / 60);
|
||||
const remainingMinutes = minutes % 60;
|
||||
return `${hours}h ${remainingMinutes}m`;
|
||||
}
|
||||
|
||||
export function formatSenseList(senses: SenseInfo[]): string {
|
||||
if (senses.length === 0) {
|
||||
return "📭 No senses registered in nerve.yaml.\n";
|
||||
}
|
||||
|
||||
const lines: string[] = [`📡 Registered senses (${senses.length}):\n`];
|
||||
for (const s of senses) {
|
||||
lines.push(`\n ${s.name}\n`);
|
||||
lines.push(` group: ${s.group}\n`);
|
||||
lines.push(` throttle: ${formatDuration(s.throttle)}\n`);
|
||||
lines.push(` timeout: ${formatDuration(s.timeout)}\n`);
|
||||
const lastSignal =
|
||||
s.lastSignalTs !== null ? new Date(s.lastSignalTs).toISOString() : "(never)";
|
||||
lines.push(` last signal: ${lastSignal}\n`);
|
||||
}
|
||||
return lines.join("");
|
||||
}
|
||||
|
||||
/** Build a SenseInfo list from nerve.yaml when daemon is not running. */
|
||||
export function sensesFromConfig(configPath: string): SenseInfo[] {
|
||||
let raw: string;
|
||||
try {
|
||||
raw = readFileSync(configPath, "utf8");
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
const result = parseNerveConfig(raw);
|
||||
if (!result.ok) return [];
|
||||
return Object.entries(result.value.senses).map(([name, cfg]) => ({
|
||||
name,
|
||||
group: cfg.group,
|
||||
throttle: cfg.throttle,
|
||||
timeout: cfg.timeout,
|
||||
lastSignalTs: null,
|
||||
}));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// nerve sense list
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const senseListCommand = defineCommand({
|
||||
meta: {
|
||||
name: "list",
|
||||
description: "List all registered senses and their status",
|
||||
},
|
||||
async run() {
|
||||
if (!isRunning()) {
|
||||
// Daemon not running — show static info from nerve.yaml
|
||||
process.stderr.write(
|
||||
"⚠️ Daemon is not running — showing static config only (no last signal time).\n\n",
|
||||
);
|
||||
const configPath = join(getNerveRoot(), "nerve.yaml");
|
||||
const senses = sensesFromConfig(configPath);
|
||||
process.stdout.write(formatSenseList(senses));
|
||||
return;
|
||||
}
|
||||
|
||||
const socketPath = getSocketPath();
|
||||
let response: { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
|
||||
try {
|
||||
response = await listSensesViaDaemon(socketPath);
|
||||
} catch (e) {
|
||||
const msg = e instanceof Error ? e.message : String(e);
|
||||
process.stderr.write(`❌ Failed to contact daemon: ${msg}\n`);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
if (!response.ok) {
|
||||
process.stderr.write(`❌ Daemon error: ${response.error}\n`);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
process.stdout.write(formatSenseList(response.senses));
|
||||
},
|
||||
});
|
||||
import { triggerSenseViaDaemon } from "../daemon-client.js";
|
||||
import { getSocketPath, isRunning } from "../workspace.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// nerve sense trigger <name>
|
||||
@@ -151,7 +53,6 @@ export const senseCommand = defineCommand({
|
||||
description: "Interact with sense computes",
|
||||
},
|
||||
subCommands: {
|
||||
list: senseListCommand,
|
||||
trigger: senseTriggerCommand,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -1,70 +0,0 @@
|
||||
import { existsSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { defineCommand } from "citty";
|
||||
|
||||
import { loadDaemonModule } from "../workspace-daemon.js";
|
||||
import { getNerveRoot } from "../workspace.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// nerve store archive
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const storeArchiveCommand = defineCommand({
|
||||
meta: {
|
||||
name: "archive",
|
||||
description:
|
||||
"Export logs older than 30 days from logs.db to data/archive/logs/YYYY-MM-DD.jsonl and delete those rows (RFC-001 §5.4)",
|
||||
},
|
||||
args: {
|
||||
vacuum: {
|
||||
type: "boolean",
|
||||
description: "Run SQLite VACUUM after archiving",
|
||||
default: false,
|
||||
},
|
||||
},
|
||||
async run({ args }) {
|
||||
const nerveRoot = getNerveRoot();
|
||||
const dbPath = join(nerveRoot, "data", "logs.db");
|
||||
if (!existsSync(dbPath)) {
|
||||
process.stderr.write("❌ No data/logs.db found — start the daemon at least once.\n");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const { createLogStore } = await loadDaemonModule(nerveRoot);
|
||||
const store = createLogStore(dbPath);
|
||||
|
||||
try {
|
||||
const result = store.archiveLogs({ vacuum: args.vacuum });
|
||||
if (result.days.length === 0) {
|
||||
process.stdout.write(
|
||||
"✅ Nothing to archive (no eligible UTC days beyond the 30-day window).\n",
|
||||
);
|
||||
} else {
|
||||
process.stdout.write(`✅ Archived ${result.days.length} day(s):\n`);
|
||||
for (const d of result.days) {
|
||||
process.stdout.write(` ${d.day} rows=${d.rowCount} ${d.filePath}\n`);
|
||||
}
|
||||
}
|
||||
if (result.vacuumed) {
|
||||
process.stdout.write(" VACUUM completed.\n");
|
||||
}
|
||||
} finally {
|
||||
store.close();
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// nerve store
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export const storeCommand = defineCommand({
|
||||
meta: {
|
||||
name: "store",
|
||||
description: "Maintain local Nerve SQLite stores (log cold-archive, …)",
|
||||
},
|
||||
subCommands: {
|
||||
archive: storeArchiveCommand,
|
||||
},
|
||||
});
|
||||
@@ -13,16 +13,6 @@ const RESPONSE_TIMEOUT_MS = 5_000;
|
||||
|
||||
type TriggerResponse = { ok: true } | { ok: false; error: string };
|
||||
|
||||
export type SenseInfo = {
|
||||
name: string;
|
||||
group: string;
|
||||
throttle: number | null;
|
||||
timeout: number | null;
|
||||
lastSignalTs: number | null;
|
||||
};
|
||||
|
||||
type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
|
||||
|
||||
function parseDaemonResponse(line: string): TriggerResponse {
|
||||
try {
|
||||
const obj = JSON.parse(line) as unknown;
|
||||
@@ -114,77 +104,3 @@ export function triggerSenseViaDaemon(
|
||||
): Promise<TriggerResponse> {
|
||||
return sendAndReceive(socketPath, { type: "trigger-sense", sense });
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a list-senses message to the running daemon via its Unix socket.
|
||||
* Resolves with the list of registered senses or rejects on connection/timeout errors.
|
||||
*/
|
||||
export function listSensesViaDaemon(socketPath: string): Promise<ListSensesResponse> {
|
||||
return new Promise((resolve, reject) => {
|
||||
let socket: Socket | null = null;
|
||||
let settled = false;
|
||||
|
||||
function settle(result: ListSensesResponse | Error): void {
|
||||
if (settled) return;
|
||||
settled = true;
|
||||
if (socket !== null) {
|
||||
socket.destroy();
|
||||
socket = null;
|
||||
}
|
||||
if (result instanceof Error) {
|
||||
reject(result);
|
||||
} else {
|
||||
resolve(result);
|
||||
}
|
||||
}
|
||||
|
||||
const connectTimer = setTimeout(() => {
|
||||
settle(new Error(`Timed out connecting to daemon socket: ${socketPath}`));
|
||||
}, CONNECT_TIMEOUT_MS);
|
||||
|
||||
socket = connect(socketPath, () => {
|
||||
clearTimeout(connectTimer);
|
||||
|
||||
const responseTimer = setTimeout(() => {
|
||||
settle(new Error("Timed out waiting for daemon response"));
|
||||
}, RESPONSE_TIMEOUT_MS);
|
||||
|
||||
let buf = "";
|
||||
socket?.on("data", (chunk: Buffer) => {
|
||||
buf += chunk.toString("utf8");
|
||||
const lines = buf.split("\n");
|
||||
buf = lines.pop() ?? "";
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (trimmed.length === 0) continue;
|
||||
clearTimeout(responseTimer);
|
||||
try {
|
||||
const obj = JSON.parse(trimmed) as unknown;
|
||||
if (obj !== null && typeof obj === "object") {
|
||||
const r = obj as Record<string, unknown>;
|
||||
if (r.ok === false && typeof r.error === "string") {
|
||||
settle({ ok: false, error: r.error });
|
||||
return;
|
||||
}
|
||||
if (r.ok === true && Array.isArray(r.senses)) {
|
||||
settle({ ok: true, senses: r.senses as SenseInfo[] });
|
||||
return;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// fall through
|
||||
}
|
||||
settle({ ok: false, error: `Unexpected daemon response: ${trimmed}` });
|
||||
return;
|
||||
}
|
||||
});
|
||||
|
||||
socket?.write(`${JSON.stringify({ type: "list-senses" })}\n`);
|
||||
});
|
||||
|
||||
socket.on("error", (err) => {
|
||||
clearTimeout(connectTimer);
|
||||
settle(new Error(`Cannot connect to daemon: ${err.message}`));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -40,24 +40,6 @@ export type LogQuery = {
|
||||
limit?: number;
|
||||
};
|
||||
|
||||
export type ArchiveLogsOptions = {
|
||||
now?: number;
|
||||
vacuum?: boolean;
|
||||
maxDays?: number;
|
||||
retentionMs?: number;
|
||||
};
|
||||
|
||||
export type ArchiveLogsDayResult = {
|
||||
day: string;
|
||||
rowCount: number;
|
||||
filePath: string;
|
||||
};
|
||||
|
||||
export type ArchiveLogsResult = {
|
||||
days: ArchiveLogsDayResult[];
|
||||
vacuumed: boolean;
|
||||
};
|
||||
|
||||
/** Subset of daemon LogStore used by the CLI workflow commands. */
|
||||
export type LogStore = {
|
||||
query: (filter?: LogQuery) => LogEntry[];
|
||||
@@ -65,6 +47,5 @@ export type LogStore = {
|
||||
getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
|
||||
getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
|
||||
upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
|
||||
archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
|
||||
close: () => void;
|
||||
};
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@uncaged/nerve-core",
|
||||
"version": "0.1.2",
|
||||
"version": "0.1.1",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@uncaged/nerve-daemon",
|
||||
"version": "0.1.3",
|
||||
"version": "0.1.1",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
|
||||
@@ -91,7 +91,6 @@ function makeLogStore(
|
||||
}),
|
||||
getTriggerPayload: vi.fn(() => ({ value: 42 })),
|
||||
getThreadEvents: vi.fn(() => [{ type: "thread_start", triggerPayload: {} }]),
|
||||
archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
|
||||
close: vi.fn(),
|
||||
};
|
||||
return store;
|
||||
|
||||
@@ -1,234 +0,0 @@
|
||||
/**
|
||||
* Unit + integration tests for daemon-ipc.ts — trigger-sense request type.
|
||||
*
|
||||
* Tests cover:
|
||||
* - parseRequest correctly accepts/rejects trigger-sense messages
|
||||
* - createDaemonIpcServer routes trigger-sense to opts.triggerSense
|
||||
* - Error response when triggerSense throws (unknown sense)
|
||||
* - Success response on valid sense trigger
|
||||
*/
|
||||
|
||||
import { rmSync } from "node:fs";
|
||||
import { connect } from "node:net";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
import { createDaemonIpcServer } from "../daemon-ipc.js";
|
||||
import type { DaemonIpcServer } from "../daemon-ipc.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
let sockPath: string;
|
||||
let server: DaemonIpcServer | null = null;
|
||||
|
||||
function makeMockWorkflowManager() {
|
||||
return {
|
||||
startWorkflow: vi.fn(),
|
||||
stop: vi.fn(async () => {}),
|
||||
totalActiveCount: vi.fn(() => 0),
|
||||
drainAndRespawn: vi.fn(async () => {}),
|
||||
updateConfig: vi.fn(),
|
||||
getActiveWorkflowRuns: vi.fn(() => []),
|
||||
};
|
||||
}
|
||||
|
||||
function sendRaw(path: string, message: object): Promise<object> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const sock = connect(path, () => {
|
||||
let buf = "";
|
||||
sock.on("data", (chunk: Buffer) => {
|
||||
buf += chunk.toString("utf8");
|
||||
const lines = buf.split("\n");
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (trimmed.length === 0) continue;
|
||||
try {
|
||||
resolve(JSON.parse(trimmed) as object);
|
||||
} catch {
|
||||
reject(new Error(`Invalid JSON response: ${trimmed}`));
|
||||
}
|
||||
sock.destroy();
|
||||
return;
|
||||
}
|
||||
buf = lines[lines.length - 1] ?? "";
|
||||
});
|
||||
sock.write(`${JSON.stringify(message)}\n`);
|
||||
});
|
||||
sock.on("error", reject);
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
sockPath = join(tmpdir(), `nerve-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
if (server !== null) {
|
||||
await server.close();
|
||||
server = null;
|
||||
}
|
||||
try {
|
||||
rmSync(sockPath);
|
||||
} catch {
|
||||
// already removed
|
||||
}
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// trigger-sense: valid request → ok: true
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("daemon-ipc — trigger-sense", () => {
|
||||
it("responds ok:true when triggerSense succeeds", async () => {
|
||||
const triggerSense = vi.fn();
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "cpu-usage" });
|
||||
|
||||
expect(resp).toEqual({ ok: true });
|
||||
expect(triggerSense).toHaveBeenCalledOnce();
|
||||
expect(triggerSense).toHaveBeenCalledWith("cpu-usage");
|
||||
});
|
||||
|
||||
it("responds ok:false with error message when triggerSense throws", async () => {
|
||||
const triggerSense = vi.fn(() => {
|
||||
throw new Error('Unknown sense: "no-such-sense"');
|
||||
});
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "no-such-sense" });
|
||||
|
||||
expect(resp).toEqual({ ok: false, error: 'Unknown sense: "no-such-sense"' });
|
||||
expect(triggerSense).toHaveBeenCalledWith("no-such-sense");
|
||||
});
|
||||
|
||||
it("responds ok:false for trigger-sense with empty sense name", async () => {
|
||||
const triggerSense = vi.fn();
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "trigger-sense", sense: "" });
|
||||
|
||||
expect(resp).toEqual({ ok: false, error: "Invalid request" });
|
||||
expect(triggerSense).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("responds ok:false for trigger-sense missing sense field", async () => {
|
||||
const triggerSense = vi.fn();
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "trigger-sense" });
|
||||
|
||||
expect(resp).toEqual({ ok: false, error: "Invalid request" });
|
||||
expect(triggerSense).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does NOT call triggerSense for trigger-workflow requests", async () => {
|
||||
const triggerSense = vi.fn();
|
||||
const wfManager = makeMockWorkflowManager();
|
||||
server = createDaemonIpcServer(sockPath, wfManager as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, {
|
||||
type: "trigger-workflow",
|
||||
workflow: "my-workflow",
|
||||
payload: {},
|
||||
});
|
||||
|
||||
expect(resp).toEqual({ ok: true });
|
||||
expect(triggerSense).not.toHaveBeenCalled();
|
||||
expect(wfManager.startWorkflow).toHaveBeenCalledWith("my-workflow", {});
|
||||
});
|
||||
|
||||
it("responds ok:false for completely unknown request type", async () => {
|
||||
const triggerSense = vi.fn();
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense,
|
||||
listSenses: vi.fn(() => []),
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "unknown-type", data: "x" });
|
||||
|
||||
expect(resp).toEqual({ ok: false, error: "Invalid request" });
|
||||
expect(triggerSense).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// list-senses: valid request → ok: true with senses array
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("daemon-ipc — list-senses", () => {
|
||||
it("responds ok:true with empty senses array when listSenses returns []", async () => {
|
||||
const listSenses = vi.fn(() => []);
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense: vi.fn(),
|
||||
listSenses,
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "list-senses" });
|
||||
|
||||
expect(resp).toEqual({ ok: true, senses: [] });
|
||||
expect(listSenses).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("responds ok:true with senses populated from listSenses", async () => {
|
||||
const sensesData = [
|
||||
{ name: "cpu-usage", group: "system", throttle: 5000, timeout: 3000, lastSignalTs: 1000 },
|
||||
{ name: "disk-usage", group: "system", throttle: 30000, timeout: null, lastSignalTs: null },
|
||||
];
|
||||
const listSenses = vi.fn(() => sensesData);
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense: vi.fn(),
|
||||
listSenses,
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "list-senses" });
|
||||
|
||||
expect(resp).toEqual({ ok: true, senses: sensesData });
|
||||
expect(listSenses).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("responds ok:false when listSenses throws", async () => {
|
||||
const listSenses = vi.fn(() => {
|
||||
throw new Error("internal error");
|
||||
});
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense: vi.fn(),
|
||||
listSenses,
|
||||
});
|
||||
|
||||
const resp = await sendRaw(sockPath, { type: "list-senses" });
|
||||
|
||||
expect(resp).toEqual({ ok: false, error: "internal error" });
|
||||
});
|
||||
|
||||
it("does NOT call listSenses for trigger-sense requests", async () => {
|
||||
const listSenses = vi.fn(() => []);
|
||||
server = createDaemonIpcServer(sockPath, makeMockWorkflowManager() as never, {
|
||||
triggerSense: vi.fn(),
|
||||
listSenses,
|
||||
});
|
||||
|
||||
await sendRaw(sockPath, { type: "trigger-sense", sense: "cpu-usage" });
|
||||
|
||||
expect(listSenses).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -77,7 +77,6 @@ function makeLogStore() {
|
||||
getActiveWorkflowRuns: vi.fn(() => []),
|
||||
getTriggerPayload: vi.fn(() => null),
|
||||
getThreadEvents: vi.fn(() => []),
|
||||
archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
|
||||
close: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,200 +0,0 @@
|
||||
/**
|
||||
* Unit tests for kernel.triggerSense() — IPC issue #36.
|
||||
*
|
||||
* These tests use a mock child_process and a mock LogStore so they do NOT
|
||||
* require better-sqlite3 to be present in the test environment.
|
||||
*/
|
||||
|
||||
import { EventEmitter } from "node:events";
|
||||
|
||||
import type { NerveConfig } from "@uncaged/nerve-core";
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mock child_process.fork before importing kernel
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
const mockChildren: MockChild[] = [];
|
||||
|
||||
type MockChild = EventEmitter & {
|
||||
send: ReturnType<typeof vi.fn>;
|
||||
kill: ReturnType<typeof vi.fn>;
|
||||
connected: boolean;
|
||||
pid: number;
|
||||
};
|
||||
|
||||
function makeMockChild(pid = 1): MockChild {
|
||||
const child = new EventEmitter() as MockChild;
|
||||
child.connected = true;
|
||||
child.send = vi.fn((msg: unknown) => {
|
||||
if (
|
||||
msg !== null &&
|
||||
typeof msg === "object" &&
|
||||
(msg as Record<string, unknown>).type === "shutdown"
|
||||
) {
|
||||
setImmediate(() => {
|
||||
child.connected = false;
|
||||
child.emit("exit", 0, null);
|
||||
});
|
||||
}
|
||||
});
|
||||
child.kill = vi.fn((_signal?: string) => {
|
||||
child.connected = false;
|
||||
child.emit("exit", null, _signal ?? "SIGKILL");
|
||||
});
|
||||
child.pid = pid;
|
||||
return child;
|
||||
}
|
||||
|
||||
vi.mock("node:child_process", () => ({
|
||||
fork: vi.fn((_script: string, _args: string[], _opts: unknown) => {
|
||||
const child = makeMockChild(mockChildren.length + 1);
|
||||
mockChildren.push(child);
|
||||
return child;
|
||||
}),
|
||||
}));
|
||||
|
||||
// Import after mock is set up
|
||||
const { createKernel } = await import("../kernel.js");
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mock LogStore factory (avoids better-sqlite3 dependency)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function makeMockLogStore() {
|
||||
return {
|
||||
append: vi.fn(),
|
||||
query: vi.fn(() => []),
|
||||
getMeta: vi.fn(() => null),
|
||||
setMeta: vi.fn(),
|
||||
upsertWorkflowRun: vi.fn(),
|
||||
appendWithWorkflowUpdate: vi.fn(),
|
||||
getWorkflowRun: vi.fn(() => null),
|
||||
getActiveWorkflowRuns: vi.fn(() => []),
|
||||
getAllWorkflowRuns: vi.fn(() => []),
|
||||
getTriggerPayload: vi.fn(() => null),
|
||||
getThreadEvents: vi.fn(() => []),
|
||||
archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
|
||||
close: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Config helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
|
||||
return {
|
||||
senses: {
|
||||
"cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
|
||||
},
|
||||
reflexes: [],
|
||||
workflows: null,
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("kernel.triggerSense()", () => {
|
||||
beforeEach(() => {
|
||||
mockChildren.length = 0;
|
||||
vi.useFakeTimers({ shouldAdvanceTime: true });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it("throws for an unknown sense name", async () => {
|
||||
const config = makeConfig();
|
||||
const kernel = createKernel(config, "/tmp/nerve-test", {
|
||||
workerScript: null,
|
||||
logStore: makeMockLogStore() as never,
|
||||
});
|
||||
|
||||
expect(() => kernel.triggerSense("no-such-sense")).toThrow(/Unknown sense/);
|
||||
|
||||
await kernel.stop();
|
||||
});
|
||||
|
||||
it("sends a compute message to the worker for the correct group", async () => {
|
||||
const config = makeConfig({
|
||||
senses: {
|
||||
"cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
|
||||
"net-io": { group: "network", throttle: null, timeout: null, gracePeriod: null },
|
||||
},
|
||||
reflexes: [],
|
||||
});
|
||||
const kernel = createKernel(config, "/tmp/nerve-test", {
|
||||
workerScript: null,
|
||||
logStore: makeMockLogStore() as never,
|
||||
});
|
||||
|
||||
// Two groups → two workers
|
||||
expect(mockChildren.length).toBe(2);
|
||||
|
||||
// Workers are keyed by group: groups iteration order matches the insertion
|
||||
// order from Object.values(config.senses). Find the worker for "system".
|
||||
const systemWorkerIdx = Array.from(kernel.groups).indexOf("system");
|
||||
const systemWorker = mockChildren[systemWorkerIdx];
|
||||
|
||||
kernel.triggerSense("cpu-usage");
|
||||
|
||||
expect(systemWorker.send).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ type: "compute", sense: "cpu-usage" }),
|
||||
);
|
||||
|
||||
await kernel.stop();
|
||||
});
|
||||
|
||||
it("sends a compute message to the correct worker when multiple senses share a group", async () => {
|
||||
const config = makeConfig({
|
||||
senses: {
|
||||
"cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
|
||||
"disk-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
|
||||
},
|
||||
reflexes: [],
|
||||
});
|
||||
const kernel = createKernel(config, "/tmp/nerve-test", {
|
||||
workerScript: null,
|
||||
logStore: makeMockLogStore() as never,
|
||||
});
|
||||
|
||||
// Both senses share the "system" group → one worker only
|
||||
expect(mockChildren.length).toBe(1);
|
||||
const worker = mockChildren[0];
|
||||
|
||||
kernel.triggerSense("disk-usage");
|
||||
|
||||
expect(worker.send).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ type: "compute", sense: "disk-usage" }),
|
||||
);
|
||||
|
||||
await kernel.stop();
|
||||
});
|
||||
|
||||
it("does not send to a disconnected worker (does not throw)", async () => {
|
||||
// Use real timers so kernel.stop() waitForExit can rely on SIGKILL timeout
|
||||
vi.useRealTimers();
|
||||
|
||||
const config = makeConfig();
|
||||
const kernel = createKernel(config, "/tmp/nerve-test", {
|
||||
workerScript: null,
|
||||
logStore: makeMockLogStore() as never,
|
||||
});
|
||||
|
||||
const worker = mockChildren[0];
|
||||
worker.connected = false;
|
||||
|
||||
// Should not throw even when the worker is disconnected
|
||||
expect(() => kernel.triggerSense("cpu-usage")).not.toThrow();
|
||||
expect(worker.send).not.toHaveBeenCalledWith(
|
||||
expect.objectContaining({ type: "compute" }),
|
||||
);
|
||||
|
||||
await kernel.stop();
|
||||
}, 10_000);
|
||||
});
|
||||
@@ -80,7 +80,6 @@ function makeLogStore() {
|
||||
getActiveWorkflowRuns: vi.fn(() => []),
|
||||
getTriggerPayload: vi.fn(() => null),
|
||||
getThreadEvents: vi.fn(() => []),
|
||||
archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
|
||||
close: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,40 +0,0 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import {
|
||||
assertValidUtcDay,
|
||||
compareIsoDays,
|
||||
lastArchivableUtcDay,
|
||||
nextUtcDay,
|
||||
prevUtcDay,
|
||||
utcDateStringFromMs,
|
||||
utcDayEndExclusiveMs,
|
||||
utcDayStartMs,
|
||||
} from "../log-archive.js";
|
||||
|
||||
describe("log-archive UTC helpers", () => {
|
||||
it("lastArchivableUtcDay matches RFC-style boundary (exclusive end of day ≤ boundary)", () => {
|
||||
const boundary = Date.UTC(2026, 1, 2, 12, 0, 0); // 2026-02-02 12:00 UTC
|
||||
expect(lastArchivableUtcDay(boundary)).toBe("2026-02-01");
|
||||
});
|
||||
|
||||
it("round-trips UTC day bounds", () => {
|
||||
expect(utcDayStartMs("2026-02-01")).toBe(Date.UTC(2026, 1, 1));
|
||||
expect(utcDayEndExclusiveMs("2026-02-01")).toBe(Date.UTC(2026, 1, 2));
|
||||
expect(utcDateStringFromMs(Date.UTC(2026, 1, 1, 23, 59))).toBe("2026-02-01");
|
||||
});
|
||||
|
||||
it("nextUtcDay / prevUtcDay", () => {
|
||||
expect(nextUtcDay("2026-02-01")).toBe("2026-02-02");
|
||||
expect(prevUtcDay("2026-02-01")).toBe("2026-01-31");
|
||||
});
|
||||
|
||||
it("compareIsoDays sorts lexicographically for YYYY-MM-DD", () => {
|
||||
expect(compareIsoDays("2026-01-01", "2026-02-01")).toBeLessThan(0);
|
||||
expect(compareIsoDays("2026-02-01", "2026-02-01")).toBe(0);
|
||||
});
|
||||
|
||||
it("assertValidUtcDay rejects invalid calendars", () => {
|
||||
expect(() => assertValidUtcDay("2026-02-31")).toThrow();
|
||||
expect(() => assertValidUtcDay("bad")).toThrow();
|
||||
});
|
||||
});
|
||||
@@ -1,139 +0,0 @@
|
||||
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
||||
|
||||
import { LOG_ARCHIVE_META_KEY, createLogStore } from "../log-store.js";
|
||||
import type { LogStore } from "../log-store.js";
|
||||
|
||||
const DAY_MS = 86_400_000;
|
||||
|
||||
/** `now` such that 2026-02-01 is the last archivable UTC day under a 30-day window. */
|
||||
function nowForLastArchivableFeb1(): number {
|
||||
const boundary = Date.UTC(2026, 1, 2, 12, 0, 0);
|
||||
return boundary + 30 * DAY_MS;
|
||||
}
|
||||
|
||||
describe("LogStore — cold archive (RFC-001 §5.4)", () => {
|
||||
let tmpDir: string;
|
||||
let store: LogStore;
|
||||
|
||||
beforeEach(() => {
|
||||
tmpDir = mkdtempSync(join(tmpdir(), "nerve-archive-"));
|
||||
store = createLogStore(join(tmpDir, "data", "logs.db"));
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
store.close();
|
||||
rmSync(tmpDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it("exports one UTC day to JSONL, deletes rows, advances archived_up_to", () => {
|
||||
const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
store.append({ source: "system", type: "x", refId: null, payload: '{"a":1}', ts });
|
||||
store.append({ source: "reflex", type: "y", refId: "z", payload: null, ts: ts + 1 });
|
||||
|
||||
const now = nowForLastArchivableFeb1();
|
||||
const result = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
expect(result.days).toHaveLength(1);
|
||||
expect(result.days[0].day).toBe("2026-02-01");
|
||||
expect(result.days[0].rowCount).toBe(2);
|
||||
|
||||
const jsonlPath = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
|
||||
expect(result.days[0].filePath).toBe(jsonlPath);
|
||||
|
||||
const lines = readFileSync(jsonlPath, "utf8").trim().split("\n");
|
||||
expect(lines).toHaveLength(2);
|
||||
const o = JSON.parse(lines[0] ?? "{}") as Record<string, unknown>;
|
||||
expect(o.source).toBe("system");
|
||||
expect(o.refId).toBeNull();
|
||||
|
||||
expect(store.query()).toHaveLength(0);
|
||||
expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBe("2026-02-01");
|
||||
});
|
||||
|
||||
it("returns nothing for an empty logs table", () => {
|
||||
const r = store.archiveLogs({ now: nowForLastArchivableFeb1(), retentionMs: 30 * DAY_MS });
|
||||
expect(r.days).toHaveLength(0);
|
||||
expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBeNull();
|
||||
});
|
||||
|
||||
it("does nothing when all logs are inside the hot window", () => {
|
||||
const now = Date.UTC(2026, 3, 23, 12, 0, 0);
|
||||
const ts = now - 5 * DAY_MS;
|
||||
store.append({ source: "system", type: "warm", refId: null, payload: null, ts });
|
||||
const r = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
expect(r.days).toHaveLength(0);
|
||||
expect(store.query()).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("second archive with same clock is a no-op (watermark already caught up)", () => {
|
||||
const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
store.append({ source: "system", type: "x", refId: null, payload: null, ts });
|
||||
const now = nowForLastArchivableFeb1();
|
||||
store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
const path = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
|
||||
const first = readFileSync(path, "utf8");
|
||||
|
||||
const second = store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
expect(second.days).toHaveLength(0);
|
||||
expect(readFileSync(path, "utf8")).toBe(first);
|
||||
});
|
||||
|
||||
it("overwrites JSONL when the same UTC day is archived again after watermark rewind", () => {
|
||||
const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
store.append({ source: "a", type: "1", refId: null, payload: null, ts });
|
||||
const now = nowForLastArchivableFeb1();
|
||||
store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
store.setMeta(LOG_ARCHIVE_META_KEY, "2026-01-31");
|
||||
store.append({ source: "b", type: "2", refId: null, payload: null, ts: ts + 100 });
|
||||
store.archiveLogs({ now, retentionMs: 30 * DAY_MS });
|
||||
|
||||
const path = join(tmpDir, "data", "archive", "logs", "2026-02-01.jsonl");
|
||||
const lines = readFileSync(path, "utf8").trim().split("\n");
|
||||
expect(lines).toHaveLength(1);
|
||||
expect(JSON.parse(lines[0] ?? "{}").source).toBe("b");
|
||||
});
|
||||
|
||||
it("respects maxDays across invocations", () => {
|
||||
const t1 = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
const t2 = Date.UTC(2026, 1, 2, 10, 0, 0);
|
||||
store.append({ source: "system", type: "a", refId: null, payload: null, ts: t1 });
|
||||
store.append({ source: "system", type: "b", refId: null, payload: null, ts: t2 });
|
||||
|
||||
const now = Date.UTC(2027, 0, 1, 12, 0, 0);
|
||||
const r1 = store.archiveLogs({ now, retentionMs: 30 * DAY_MS, maxDays: 1 });
|
||||
expect(r1.days).toHaveLength(1);
|
||||
expect(r1.days[0].day).toBe("2026-02-01");
|
||||
|
||||
const r2 = store.archiveLogs({ now, retentionMs: 30 * DAY_MS, maxDays: 1 });
|
||||
expect(r2.days).toHaveLength(1);
|
||||
expect(r2.days[0].day).toBe("2026-02-02");
|
||||
expect(store.getMeta(LOG_ARCHIVE_META_KEY)).toBe("2026-02-02");
|
||||
expect(store.query()).toHaveLength(0);
|
||||
});
|
||||
|
||||
it("starts from earliest log day when it is before watermark+1", () => {
|
||||
store.setMeta(LOG_ARCHIVE_META_KEY, "2026-01-10");
|
||||
const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
store.append({ source: "x", type: "p", refId: null, payload: null, ts });
|
||||
const result = store.archiveLogs({ now: nowForLastArchivableFeb1(), retentionMs: 30 * DAY_MS });
|
||||
expect(result.days.map((d) => d.day)).toContain("2026-02-01");
|
||||
});
|
||||
|
||||
it("throws on invalid archived_up_to watermark", () => {
|
||||
store.setMeta(LOG_ARCHIVE_META_KEY, "not-a-date");
|
||||
expect(() => store.archiveLogs({ now: Date.now() })).toThrow();
|
||||
});
|
||||
|
||||
it("runs VACUUM when vacuum: true", () => {
|
||||
const ts = Date.UTC(2026, 1, 1, 10, 0, 0);
|
||||
store.append({ source: "system", type: "x", refId: null, payload: null, ts });
|
||||
const r = store.archiveLogs({
|
||||
now: nowForLastArchivableFeb1(),
|
||||
retentionMs: 30 * DAY_MS,
|
||||
vacuum: true,
|
||||
});
|
||||
expect(r.vacuumed).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -74,7 +74,6 @@ function makeLogStore() {
|
||||
getActiveWorkflowRuns: vi.fn(() => []),
|
||||
getTriggerPayload: vi.fn(() => null),
|
||||
getThreadEvents: vi.fn(() => []),
|
||||
archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
|
||||
close: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -5,9 +5,7 @@
|
||||
* Protocol: newline-delimited JSON messages.
|
||||
* Each request: { type: "trigger-workflow"; workflow: string; payload: unknown }
|
||||
* | { type: "trigger-sense"; sense: string }
|
||||
* | { type: "list-senses" }
|
||||
* Each response: { ok: true } | { ok: false; error: string }
|
||||
* | { ok: true; senses: SenseInfo[] } (for list-senses)
|
||||
*/
|
||||
|
||||
import { rmSync } from "node:fs";
|
||||
@@ -28,26 +26,9 @@ export type TriggerSenseRequest = {
|
||||
sense: string;
|
||||
};
|
||||
|
||||
/** JSON message sent by the CLI to list registered senses. */
|
||||
export type ListSensesRequest = {
|
||||
type: "list-senses";
|
||||
};
|
||||
type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest;
|
||||
|
||||
/** Runtime info about a single sense returned by list-senses. */
|
||||
export type SenseInfo = {
|
||||
name: string;
|
||||
group: string;
|
||||
throttle: number | null;
|
||||
timeout: number | null;
|
||||
lastSignalTs: number | null;
|
||||
};
|
||||
|
||||
type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest | ListSensesRequest;
|
||||
|
||||
type DaemonResponse =
|
||||
| { ok: true }
|
||||
| { ok: false; error: string }
|
||||
| { ok: true; senses: SenseInfo[] };
|
||||
type DaemonResponse = { ok: true } | { ok: false; error: string };
|
||||
|
||||
export type DaemonIpcServer = {
|
||||
close: () => Promise<void>;
|
||||
@@ -66,9 +47,6 @@ function parseRequest(line: string): DaemonRequest | null {
|
||||
if (typeof req.sense !== "string" || req.sense.length === 0) return null;
|
||||
return { type: "trigger-sense", sense: req.sense };
|
||||
}
|
||||
if (req.type === "list-senses") {
|
||||
return { type: "list-senses" };
|
||||
}
|
||||
return null;
|
||||
} catch {
|
||||
return null;
|
||||
@@ -78,8 +56,6 @@ function parseRequest(line: string): DaemonRequest | null {
|
||||
export type DaemonIpcServerOptions = {
|
||||
/** Called when a trigger-sense request arrives. Should throw if the sense is unknown. */
|
||||
triggerSense: (senseName: string) => void;
|
||||
/** Called when a list-senses request arrives. Returns sense info for all registered senses. */
|
||||
listSenses: () => SenseInfo[];
|
||||
};
|
||||
|
||||
export function createDaemonIpcServer(
|
||||
@@ -108,17 +84,11 @@ export function createDaemonIpcServer(
|
||||
try {
|
||||
if (req.type === "trigger-workflow") {
|
||||
workflowManager.startWorkflow(req.workflow, req.payload);
|
||||
const resp: DaemonResponse = { ok: true };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} else if (req.type === "trigger-sense") {
|
||||
opts.triggerSense(req.sense);
|
||||
const resp: DaemonResponse = { ok: true };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} else if (req.type === "list-senses") {
|
||||
const senses = opts.listSenses();
|
||||
const resp: DaemonResponse = { ok: true, senses };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
}
|
||||
const resp: DaemonResponse = { ok: true };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} catch (err) {
|
||||
const msg = err instanceof Error ? err.message : String(err);
|
||||
const resp: DaemonResponse = { ok: false, error: msg };
|
||||
|
||||
@@ -32,16 +32,13 @@ export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
|
||||
export { createFileWatcher } from "./file-watcher.js";
|
||||
export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";
|
||||
|
||||
export { createLogStore, LOG_ARCHIVE_META_KEY } from "./log-store.js";
|
||||
export { createLogStore } from "./log-store.js";
|
||||
export type {
|
||||
LogStore,
|
||||
LogEntry,
|
||||
LogQuery,
|
||||
WorkflowRun,
|
||||
WorkflowRunStatus,
|
||||
ArchiveLogsDayResult,
|
||||
ArchiveLogsOptions,
|
||||
ArchiveLogsResult,
|
||||
} from "./log-store.js";
|
||||
|
||||
export { createWorkflowManager } from "./workflow-manager.js";
|
||||
|
||||
@@ -22,7 +22,7 @@ import type { NerveConfig, Signal } from "@uncaged/nerve-core";
|
||||
import { parseNerveConfig } from "@uncaged/nerve-core";
|
||||
|
||||
import { createDaemonIpcServer } from "./daemon-ipc.js";
|
||||
import type { DaemonIpcServer, SenseInfo } from "./daemon-ipc.js";
|
||||
import type { DaemonIpcServer } from "./daemon-ipc.js";
|
||||
import { createFileWatcher } from "./file-watcher.js";
|
||||
import type { FileWatcher } from "./file-watcher.js";
|
||||
import type { ComputeMessage, ShutdownMessage } from "./ipc.js";
|
||||
@@ -85,12 +85,9 @@ function resolveWorkerScript(): string {
|
||||
}
|
||||
|
||||
function spawnWorker(nerveRoot: string, group: string, workerScript: string): ChildProcess {
|
||||
const child = fork(workerScript, ["--group", group, "--root", nerveRoot], {
|
||||
return fork(workerScript, ["--group", group, "--root", nerveRoot], {
|
||||
stdio: ["ignore", "inherit", "inherit", "ipc"],
|
||||
});
|
||||
// Prevent unhandled EPIPE when writing to a child whose IPC channel closed
|
||||
child.on("error", () => {});
|
||||
return child;
|
||||
}
|
||||
|
||||
function sendCompute(worker: ChildProcess, senseName: string): void {
|
||||
@@ -521,23 +518,6 @@ export function createKernel(
|
||||
if (options.ipcSocketPath != null) {
|
||||
ipcServer = createDaemonIpcServer(options.ipcSocketPath, workflowManager, {
|
||||
triggerSense,
|
||||
listSenses(): SenseInfo[] {
|
||||
return Object.entries(config.senses).map(([name, senseConfig]) => {
|
||||
const entries = logStore.query({
|
||||
source: "reflex",
|
||||
type: "run_complete",
|
||||
refId: name,
|
||||
});
|
||||
const lastEntry = entries.length > 0 ? entries[entries.length - 1] : null;
|
||||
return {
|
||||
name,
|
||||
group: senseConfig.group,
|
||||
throttle: senseConfig.throttle,
|
||||
timeout: senseConfig.timeout,
|
||||
lastSignalTs: lastEntry !== null ? lastEntry.ts : null,
|
||||
};
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
/** Log cold-archive helpers (RFC-001 §5.4) — UTC calendar days, JSONL export. */
|
||||
|
||||
export const LOG_ARCHIVE_META_KEY = "archived_up_to";
|
||||
|
||||
export const DEFAULT_LOG_RETENTION_MS = 30 * 86_400_000;
|
||||
|
||||
export type ArchiveLogsOptions = {
|
||||
/** Wall clock for retention boundary (default: `Date.now()`). */
|
||||
now?: number;
|
||||
/** Run `VACUUM` after archiving (outside the per-day transaction). */
|
||||
vacuum?: boolean;
|
||||
/** Max UTC days to process in one call (default: unlimited). */
|
||||
maxDays?: number;
|
||||
/** Override default 30-day retention (tests). */
|
||||
retentionMs?: number;
|
||||
};
|
||||
|
||||
export type ArchiveLogsDayResult = {
|
||||
day: string;
|
||||
rowCount: number;
|
||||
filePath: string;
|
||||
};
|
||||
|
||||
export type ArchiveLogsResult = {
|
||||
days: ArchiveLogsDayResult[];
|
||||
vacuumed: boolean;
|
||||
};
|
||||
|
||||
export function utcDateStringFromMs(ms: number): string {
|
||||
return new Date(ms).toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
function parseUtcDayParts(day: string): [number, number, number] {
|
||||
const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(day);
|
||||
if (m === null) {
|
||||
throw new Error(`Invalid UTC day (expected YYYY-MM-DD): ${day}`);
|
||||
}
|
||||
const y = Number(m[1]);
|
||||
const mo = Number(m[2]);
|
||||
const d = Number(m[3]);
|
||||
const t = Date.UTC(y, mo - 1, d);
|
||||
if (utcDateStringFromMs(t) !== day) {
|
||||
throw new Error(`Invalid UTC calendar day: ${day}`);
|
||||
}
|
||||
return [y, mo, d];
|
||||
}
|
||||
|
||||
export function assertValidUtcDay(day: string): void {
|
||||
parseUtcDayParts(day);
|
||||
}
|
||||
|
||||
export function utcDayStartMs(day: string): number {
|
||||
const [y, mo, d] = parseUtcDayParts(day);
|
||||
return Date.UTC(y, mo - 1, d);
|
||||
}
|
||||
|
||||
export function utcDayEndExclusiveMs(day: string): number {
|
||||
return utcDayStartMs(day) + 86_400_000;
|
||||
}
|
||||
|
||||
export function prevUtcDay(day: string): string {
|
||||
return utcDateStringFromMs(utcDayStartMs(day) - 86_400_000);
|
||||
}
|
||||
|
||||
export function nextUtcDay(day: string): string {
|
||||
return utcDateStringFromMs(utcDayEndExclusiveMs(day));
|
||||
}
|
||||
|
||||
/** Last UTC calendar day D such that the exclusive end of D is ≤ boundaryMs. */
|
||||
export function lastArchivableUtcDay(boundaryMs: number): string {
|
||||
return prevUtcDay(utcDateStringFromMs(boundaryMs));
|
||||
}
|
||||
|
||||
export function compareIsoDays(a: string, b: string): number {
|
||||
if (a < b) return -1;
|
||||
if (a > b) return 1;
|
||||
return 0;
|
||||
}
|
||||
@@ -7,27 +7,11 @@
|
||||
* Also provides a `meta` key-value table for bookkeeping (e.g. archive watermarks).
|
||||
*/
|
||||
|
||||
import { mkdirSync, writeFileSync } from "node:fs";
|
||||
import { dirname, join } from "node:path";
|
||||
import { mkdirSync } from "node:fs";
|
||||
import { dirname } from "node:path";
|
||||
import Database from "better-sqlite3";
|
||||
import type BetterSqlite3 from "better-sqlite3";
|
||||
|
||||
import {
|
||||
DEFAULT_LOG_RETENTION_MS,
|
||||
LOG_ARCHIVE_META_KEY,
|
||||
assertValidUtcDay,
|
||||
compareIsoDays,
|
||||
lastArchivableUtcDay,
|
||||
nextUtcDay,
|
||||
utcDateStringFromMs,
|
||||
utcDayEndExclusiveMs,
|
||||
utcDayStartMs,
|
||||
} from "./log-archive.js";
|
||||
import type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
|
||||
|
||||
export { LOG_ARCHIVE_META_KEY } from "./log-archive.js";
|
||||
export type { ArchiveLogsDayResult, ArchiveLogsOptions, ArchiveLogsResult } from "./log-archive.js";
|
||||
|
||||
export type LogEntry = {
|
||||
id?: number;
|
||||
source: string;
|
||||
@@ -121,12 +105,6 @@ export type LogStore = {
|
||||
* Used for crash recovery to rebuild ThreadState.
|
||||
*/
|
||||
getThreadEvents: (runId: string) => Array<{ type: string; [key: string]: unknown }>;
|
||||
/**
|
||||
* Export logs older than the retention window to `data/archive/logs/YYYY-MM-DD.jsonl`,
|
||||
* then delete those rows and advance `meta.archived_up_to` in one transaction per day
|
||||
* (RFC-001 §5.4).
|
||||
*/
|
||||
archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
|
||||
close: () => void;
|
||||
};
|
||||
|
||||
@@ -160,78 +138,6 @@ CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
|
||||
CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow);
|
||||
`;
|
||||
|
||||
type SqlLogRow = {
|
||||
id: number;
|
||||
source: string;
|
||||
type: string;
|
||||
ref_id: string | null;
|
||||
payload: string | null;
|
||||
ts: number;
|
||||
};
|
||||
|
||||
function buildJsonlBody(rows: SqlLogRow[]): string {
|
||||
if (rows.length === 0) return "";
|
||||
const lines = rows.map((r) =>
|
||||
JSON.stringify({
|
||||
id: r.id,
|
||||
source: r.source,
|
||||
type: r.type,
|
||||
refId: r.ref_id,
|
||||
payload: r.payload,
|
||||
ts: r.ts,
|
||||
}),
|
||||
);
|
||||
return `${lines.join("\n")}\n`;
|
||||
}
|
||||
|
||||
function runOptionalVacuum(sqlite: BetterSqlite3.Database, vacuum?: boolean): boolean {
|
||||
if (vacuum !== true) return false;
|
||||
sqlite.exec("VACUUM");
|
||||
return true;
|
||||
}
|
||||
|
||||
function resolveArchiveStartDay(watermark: string | null, minDay: string): string {
|
||||
if (watermark === null) return minDay;
|
||||
const afterWatermark = nextUtcDay(watermark);
|
||||
return compareIsoDays(minDay, afterWatermark) < 0 ? minDay : afterWatermark;
|
||||
}
|
||||
|
||||
function runArchiveDayLoop(
|
||||
dbPath: string,
|
||||
options: ArchiveLogsOptions,
|
||||
selectLogsForDayStmt: BetterSqlite3.Statement,
|
||||
archiveDayTx: (day: string, start: number, endExclusive: number) => void,
|
||||
startDay: string,
|
||||
lastDay: string,
|
||||
): ArchiveLogsDayResult[] {
|
||||
const archiveDir = join(dirname(dbPath), "archive", "logs");
|
||||
mkdirSync(archiveDir, { recursive: true });
|
||||
|
||||
const days: ArchiveLogsDayResult[] = [];
|
||||
let d = startDay;
|
||||
let processed = 0;
|
||||
|
||||
while (compareIsoDays(d, lastDay) <= 0) {
|
||||
if (options.maxDays !== undefined && processed >= options.maxDays) {
|
||||
break;
|
||||
}
|
||||
|
||||
const start = utcDayStartMs(d);
|
||||
const endExclusive = utcDayEndExclusiveMs(d);
|
||||
const rows = selectLogsForDayStmt.all({ start, endExclusive }) as SqlLogRow[];
|
||||
|
||||
const filePath = join(archiveDir, `${d}.jsonl`);
|
||||
writeFileSync(filePath, buildJsonlBody(rows), "utf8");
|
||||
archiveDayTx(d, start, endExclusive);
|
||||
|
||||
days.push({ day: d, rowCount: rows.length, filePath });
|
||||
processed += 1;
|
||||
d = nextUtcDay(d);
|
||||
}
|
||||
|
||||
return days;
|
||||
}
|
||||
|
||||
export function createLogStore(dbPath: string): LogStore {
|
||||
mkdirSync(dirname(dbPath), { recursive: true });
|
||||
|
||||
@@ -280,14 +186,6 @@ export function createLogStore(dbPath: string): LogStore {
|
||||
"SELECT run_id, workflow, status, ts FROM workflow_runs WHERE workflow = ? ORDER BY ts DESC",
|
||||
);
|
||||
|
||||
const minLogTsStmt = sqlite.prepare("SELECT MIN(ts) AS m FROM logs");
|
||||
const selectLogsForDayStmt = sqlite.prepare(
|
||||
"SELECT id, source, type, ref_id, payload, ts FROM logs WHERE ts >= @start AND ts < @endExclusive ORDER BY id ASC",
|
||||
);
|
||||
const deleteLogsForDayStmt = sqlite.prepare(
|
||||
"DELETE FROM logs WHERE ts >= @start AND ts < @endExclusive",
|
||||
);
|
||||
|
||||
const upsertWorkflowRunTx = sqlite.transaction(
|
||||
(entry: Omit<LogEntry, "id">, run: WorkflowRun) => {
|
||||
const info = insertStmt.run({
|
||||
@@ -460,52 +358,6 @@ export function createLogStore(dbPath: string): LogStore {
|
||||
return result;
|
||||
}
|
||||
|
||||
const archiveDayTx = sqlite.transaction((day: string, start: number, endExclusive: number) => {
|
||||
deleteLogsForDayStmt.run({ start, endExclusive });
|
||||
setMetaStmt.run({ key: LOG_ARCHIVE_META_KEY, value: day });
|
||||
});
|
||||
|
||||
function readWatermark(): string | null {
|
||||
const raw = getMeta(LOG_ARCHIVE_META_KEY);
|
||||
if (raw === null) return null;
|
||||
assertValidUtcDay(raw);
|
||||
return raw;
|
||||
}
|
||||
|
||||
function firstLogUtcDay(): string | null {
|
||||
const row = minLogTsStmt.get() as { m: number | null } | undefined;
|
||||
const m = row?.m;
|
||||
if (m === null || m === undefined) return null;
|
||||
return utcDateStringFromMs(m);
|
||||
}
|
||||
|
||||
function archiveLogs(options: ArchiveLogsOptions = {}): ArchiveLogsResult {
|
||||
const now = options.now ?? Date.now();
|
||||
const retentionMs = options.retentionMs ?? DEFAULT_LOG_RETENTION_MS;
|
||||
const lastDay = lastArchivableUtcDay(now - retentionMs);
|
||||
|
||||
const watermark = readWatermark();
|
||||
const minDay = firstLogUtcDay();
|
||||
if (minDay === null) {
|
||||
return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
|
||||
}
|
||||
|
||||
const startDay = resolveArchiveStartDay(watermark, minDay);
|
||||
if (compareIsoDays(startDay, lastDay) > 0) {
|
||||
return { days: [], vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
|
||||
}
|
||||
|
||||
const days = runArchiveDayLoop(
|
||||
dbPath,
|
||||
options,
|
||||
selectLogsForDayStmt,
|
||||
archiveDayTx,
|
||||
startDay,
|
||||
lastDay,
|
||||
);
|
||||
return { days, vacuumed: runOptionalVacuum(sqlite, options.vacuum) };
|
||||
}
|
||||
|
||||
function close(): void {
|
||||
sqlite.close();
|
||||
}
|
||||
@@ -522,7 +374,6 @@ export function createLogStore(dbPath: string): LogStore {
|
||||
getAllWorkflowRuns,
|
||||
getTriggerPayload,
|
||||
getThreadEvents,
|
||||
archiveLogs,
|
||||
close,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -86,12 +86,9 @@ function spawnWorkflowWorker(
|
||||
workflowName: string,
|
||||
workerScript: string,
|
||||
): ChildProcess {
|
||||
const child = fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
|
||||
return fork(workerScript, ["--workflow", workflowName, "--root", nerveRoot], {
|
||||
stdio: ["ignore", "inherit", "inherit", "ipc"],
|
||||
});
|
||||
// Prevent unhandled EPIPE when writing to a child whose IPC channel closed
|
||||
child.on("error", () => {});
|
||||
return child;
|
||||
}
|
||||
|
||||
function sendStartThread(worker: ChildProcess, msg: StartThreadMessage): void {
|
||||
|
||||
Reference in New Issue
Block a user