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"
|
||||
|
||||
@@ -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()));
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -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,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -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}`));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
});
|
||||
@@ -1,199 +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(() => []),
|
||||
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);
|
||||
});
|
||||
@@ -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 };
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -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