Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 xiaoju
|
509ba4448f |
@@ -7,31 +7,28 @@ Nerve is a lightweight daemon that continuously observes external state through
|
||||
## Core Concepts
|
||||
|
||||
```
|
||||
External World → Sense ─┬→ Signal → Reflex → Sense (scheduled compute)
|
||||
│
|
||||
└→ Workflow (Sense return with workflow directive) → Log
|
||||
External World → Sense → Signal → Reflex → Workflow → Log
|
||||
↑ ↑
|
||||
"what to observe" "what to do"
|
||||
```
|
||||
|
||||
| Concept | Metaphor | Role |
|
||||
|---------|----------|------|
|
||||
| **Sense** | 👁️ Perception | A `compute()` function that samples or derives data. Each sense has its own SQLite database. |
|
||||
| **Reflex** | ⚡ Reaction | Declarative rules that **only schedule Sense computes** (interval and/or `on` signal names). Reflex YAML cannot reference workflows. |
|
||||
| **Signal** | 📡 Notification | Emitted when a sense returns a non-null value that is routed as a normal signal (see Sense → Workflow below). Other reflexes can listen via `on`. |
|
||||
| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles and a Moderator. Started from a Sense return value or from CLI/daemon IPC—not from reflex YAML. |
|
||||
| **Reflex** | ⚡ Reaction | Declarative trigger — interval-based, event-driven, or both. Connects senses to actions. |
|
||||
| **Signal** | 📡 Notification | Emitted when a sense returns non-null. Other reflexes can listen for signals. |
|
||||
| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles (actors) and a Moderator (coordinator). |
|
||||
| **Log** | 📝 Record | Immutable audit trail. Queryable by senses, but **cannot** trigger reflexes (prevents feedback loops). |
|
||||
|
||||
**Sense → Workflow:** if `compute()` returns a plain object with a string field `workflow` in the form `name|maxRounds|prompt` (only the first two `|` delimit name and rounds; the rest is the prompt), the engine starts that workflow and **does not** emit a Signal for that return. `workflow: null` or `""` means “emit a signal” and strip the key from the payload. Invalid `workflow` strings are treated like a normal signal (directive stripped). See `@uncaged/nerve-core` `routeSenseComputeOutput` / `parseSenseWorkflowDirective`.
|
||||
|
||||
Three extension points for **what / when / multi-step action** — reflexes never replace Sense-driven workflow launches.
|
||||
Three extension points, fully orthogonal — a Sense doesn't know when it runs, a Reflex doesn't know what it computes, a Workflow doesn't know why it was triggered.
|
||||
|
||||
## Packages
|
||||
|
||||
| Package | Description |
|
||||
|---------|-------------|
|
||||
| [`@uncaged/nerve-core`](./packages/core) | Shared types, config parser, Sense→workflow routing, daemon IPC protocol |
|
||||
| [`@uncaged/nerve-store`](./packages/store) | Append-only log SQLite, JSONL archive, CAS blob store, workflow run rows |
|
||||
| [`@uncaged/nerve-daemon`](./packages/daemon) | Kernel, workers, signal bus, reflex scheduler, workflow manager, file watcher, IPC |
|
||||
| [`@uncaged/nerve-cli`](./packages/cli) | CLI (`nerve`) — init, validate, daemon, dev, logs, sense, store, workflow |
|
||||
| [`@uncaged/nerve-core`](./packages/core) | Shared types and config parser |
|
||||
| [`@uncaged/nerve-daemon`](./packages/daemon) | The observation engine — kernel, sense runtime, reflex scheduler, workflow manager |
|
||||
| [`@uncaged/nerve-cli`](./packages/cli) | CLI tool (`nerve`) — init, start, stop, logs, query |
|
||||
|
||||
## Quick Start
|
||||
|
||||
@@ -73,17 +70,15 @@ nerve logs # view logs
|
||||
|
||||
## Configuration
|
||||
|
||||
`nerve.yaml` declares senses, reflexes (sense-only), optional workflows (concurrency), and optional engine `max_rounds`:
|
||||
`nerve.yaml` declares senses, reflexes, and workflows:
|
||||
|
||||
```yaml
|
||||
max_rounds: 100 # default moderator cap (e.g. CLI workflow trigger)
|
||||
|
||||
senses:
|
||||
cpu-usage:
|
||||
group: system # senses in the same group share a worker process
|
||||
throttle: 10s # min interval between computes
|
||||
timeout: 30s # max compute duration
|
||||
grace_period: 5s # wait before first compute after startup
|
||||
gracePeriod: 5s # wait before first compute after startup
|
||||
|
||||
reflexes:
|
||||
- kind: sense
|
||||
@@ -91,6 +86,10 @@ reflexes:
|
||||
interval: 30s # periodic trigger
|
||||
on: [disk-pressure] # also trigger on signals from other senses
|
||||
|
||||
- kind: workflow
|
||||
workflow: cleanup
|
||||
on: [disk-pressure] # start a workflow when signal fires
|
||||
|
||||
workflows:
|
||||
cleanup:
|
||||
concurrency: 1
|
||||
@@ -98,66 +97,43 @@ workflows:
|
||||
code-review:
|
||||
concurrency: 3
|
||||
overflow: queue
|
||||
max_queue: 20
|
||||
```
|
||||
|
||||
YAML must **not** include `workflow:` under `reflexes` — the parser rejects it. Declare workflows under `workflows:` and start them from Sense `compute()` or `nerve workflow trigger`.
|
||||
|
||||
**Example — Sense starts a workflow** (`senses/disk-pressure/compute.ts`):
|
||||
|
||||
```typescript
|
||||
export async function compute() {
|
||||
const full = await diskNearlyFull();
|
||||
if (!full) return null;
|
||||
return {
|
||||
path: "/data",
|
||||
workflow: "cleanup|10|Disk partition nearly full", // name|maxRounds|prompt
|
||||
};
|
||||
}
|
||||
maxQueue: 20
|
||||
```
|
||||
|
||||
## Architecture
|
||||
|
||||
```
|
||||
┌────────────────────────────────────────────────────────────────────────┐
|
||||
│ Kernel │
|
||||
│ │
|
||||
│ ┌──────────────┐ watches nerve.yaml / senses / workflows │
|
||||
│ │ File Watcher ├──────────────────────────────────────────┐ │
|
||||
│ └──────────────┘ │ │
|
||||
│ ┌──────────────┐ CLI ↔ newline JSON (trigger-workflow, │ │
|
||||
│ │ Daemon IPC │ trigger-sense, list-senses) │ │
|
||||
│ └──────┬───────┘ ▼ │
|
||||
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
|
||||
│ │ │ Worker │ │ Worker │ │ Worker │ (1 per│
|
||||
│ │ │ (group A)│ │ (group B)│ │ (group C)│ group) │
|
||||
│ │ │ sense-1 │ │ sense-3 │ │ sense-5 │ │
|
||||
│ │ │ sense-2 │ │ sense-4 │ │ │ │
|
||||
│ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
|
||||
│ │ │ │ │ │
|
||||
│ │ └──────────────┼──────────────┘ │
|
||||
│ │ ▼ │
|
||||
│ │ ┌──────────────┐ │
|
||||
│ │ │ Signal Bus │ │
|
||||
│ │ └──────┬───────┘ │
|
||||
│ │ ▼ │
|
||||
│ │ ┌──────────────────┐ │
|
||||
│ │ │ Reflex Scheduler│ │
|
||||
│ │ └────────┬─────────┘ │
|
||||
│ │ ▼ │
|
||||
│ │ ┌───────────────────┐ │
|
||||
│ └───────────────────►│ Workflow Manager │──→ @uncaged/nerve-store │
|
||||
│ └───────────────────┘ (logs.db, …) │
|
||||
└────────────────────────────────────────────────────────────────────────┘
|
||||
┌─────────────────────────────────────────────────────────┐
|
||||
│ Kernel │
|
||||
│ │
|
||||
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
|
||||
│ │ Worker │ │ Worker │ │ Worker │ (1 per │
|
||||
│ │ (group A)│ │ (group B)│ │ (group C)│ group) │
|
||||
│ │ sense-1 │ │ sense-3 │ │ sense-5 │ │
|
||||
│ │ sense-2 │ │ sense-4 │ │ │ │
|
||||
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
|
||||
│ │ │ │ │
|
||||
│ └──────────────┼──────────────┘ │
|
||||
│ ▼ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ Signal Bus │ │
|
||||
│ └──────┬───────┘ │
|
||||
│ ▼ │
|
||||
│ ┌──────────────────┐ │
|
||||
│ │ Reflex Scheduler │ │
|
||||
│ └────────┬─────────┘ │
|
||||
│ ▼ │
|
||||
│ ┌───────────────────┐ │
|
||||
│ │ Workflow Manager │──→ Log Store (SQLite) │
|
||||
│ └───────────────────┘ │
|
||||
└─────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
- **Worker pool** — one child process per sense group; isolation between groups.
|
||||
- **Worker processes** — one per sense group, forked by the kernel. Isolated compute execution.
|
||||
- **Signal Bus** — in-memory pub/sub for signal distribution.
|
||||
- **Reflex Scheduler** — interval timers + signal subscriptions, with throttle/coalesce.
|
||||
- **Workflow Manager** — concurrency (drop/queue), per-workflow workers, crash recovery.
|
||||
- **File watcher** — hot reload for config, sense modules, and workflow modules.
|
||||
- **Daemon IPC** — Unix domain socket; used by the CLI when the daemon is running.
|
||||
- **Log / blob storage** — implemented in `@uncaged/nerve-store` (WAL SQLite, JSONL archive, CAS blobs).
|
||||
- **Workflow Manager** — concurrency control (drop/queue), thread lifecycle tracking.
|
||||
- **Log Store** — WAL-mode SQLite via `node:sqlite`, with archival and retention policies.
|
||||
|
||||
## Tech Stack
|
||||
|
||||
|
||||
+14
-32
@@ -21,59 +21,41 @@ nerve init # Initialize a nerve workspace (installs deps, scaff
|
||||
nerve validate # Validate nerve.yaml configuration
|
||||
```
|
||||
|
||||
### Daemon management
|
||||
### Daemon Management
|
||||
|
||||
```bash
|
||||
nerve daemon start # Start the daemon (background)
|
||||
nerve daemon stop # Stop the daemon
|
||||
nerve daemon status # Show pid, uptime, sense names from nerve.yaml (process must exist)
|
||||
nerve daemon restart # Stop then start
|
||||
nerve daemon logs # Tail daemon process logs (file under workspace logs/)
|
||||
nerve daemon status # Check daemon health
|
||||
nerve daemon restart # Restart the daemon
|
||||
nerve daemon logs # Tail daemon logs
|
||||
```
|
||||
|
||||
### Development
|
||||
|
||||
```bash
|
||||
nerve dev # Foreground kernel with file watcher + IPC (Ctrl+C stops)
|
||||
nerve dev # Run in foreground mode (no daemon, Ctrl+C to stop)
|
||||
```
|
||||
|
||||
### Querying & status
|
||||
### Querying
|
||||
|
||||
```bash
|
||||
nerve logs # Tail or page the daemon text log file (path in footer; default ~/.uncaged-nerve/logs/nerve.log)
|
||||
nerve status # Short daemon health summary (aliases daemon status)
|
||||
```
|
||||
|
||||
Structured rows in `data/logs.db` are surfaced via **`nerve workflow inspect`** / **`nerve workflow list`** (and `LogStore` in code), not via `nerve logs`.
|
||||
|
||||
### Sense
|
||||
|
||||
```bash
|
||||
nerve sense list # List senses (live fields from daemon IPC when running)
|
||||
nerve sense trigger <name> # IPC trigger-sense — queue a compute for that sense
|
||||
nerve sense query <name> # Read-only SQL on data/senses/<name>.db (optional SQL args)
|
||||
nerve sense schema <name> # Print CREATE TABLE statements for that sense DB
|
||||
```
|
||||
|
||||
### Store maintenance
|
||||
|
||||
```bash
|
||||
nerve store archive # Move old log rows to JSONL under data/archive/logs/… (optional --vacuum)
|
||||
nerve logs # View structured logs
|
||||
nerve sense query <name> # Query a sense's SQLite database
|
||||
nerve sense schema <name> # Show a sense's database schema
|
||||
nerve status # Daemon health summary
|
||||
```
|
||||
|
||||
### Workflows
|
||||
|
||||
```bash
|
||||
nerve workflow list # Queued/started runs (add --all for terminal states; --workflow, --limit, --offset)
|
||||
nerve workflow inspect <runId> # Run metadata + paginated workflow log lines
|
||||
nerve workflow thread <runId> # Role rounds from persisted messages (--before, --budget)
|
||||
nerve workflow trigger <name> # IPC trigger-workflow (daemon must be running)
|
||||
# Optional JSON: --payload '{"prompt":"…","maxRounds":50}'
|
||||
nerve workflow list # List workflow runs
|
||||
nerve workflow show <runId> # Show workflow run details
|
||||
```
|
||||
|
||||
`nerve workflow trigger` sends a `trigger-workflow` line on the daemon Unix socket (same protocol as `@uncaged/nerve-core` / `parseDaemonIpcRequest`). It does not read `nerve.yaml` workflow definitions beyond what the running daemon already loaded.
|
||||
### Top-level Aliases
|
||||
|
||||
### Top-level aliases
|
||||
For convenience, these aliases are available:
|
||||
|
||||
```bash
|
||||
nerve start → nerve daemon start
|
||||
|
||||
@@ -10,7 +10,9 @@
|
||||
},
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": ["dist"],
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
|
||||
@@ -514,7 +514,7 @@ describe("triggerWorkflowViaDaemon", () => {
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await triggerWorkflowViaDaemon(sockPath, "my-workflow", "", 100);
|
||||
const result = await triggerWorkflowViaDaemon(sockPath, "my-workflow", {});
|
||||
expect(result).toEqual({ ok: true });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
@@ -530,7 +530,7 @@ describe("triggerWorkflowViaDaemon", () => {
|
||||
await new Promise<void>((r) => server.listen(sockPath, r));
|
||||
|
||||
try {
|
||||
const result = await triggerWorkflowViaDaemon(sockPath, "missing", "", 100);
|
||||
const result = await triggerWorkflowViaDaemon(sockPath, "missing", {});
|
||||
expect(result).toEqual({ ok: false, error: "unknown workflow" });
|
||||
} finally {
|
||||
await new Promise<void>((r) => server.close(() => r()));
|
||||
@@ -538,7 +538,7 @@ describe("triggerWorkflowViaDaemon", () => {
|
||||
});
|
||||
|
||||
it("rejects when no daemon is listening on the socket", async () => {
|
||||
await expect(triggerWorkflowViaDaemon(sockPath, "my-workflow", "", 100)).rejects.toThrow(
|
||||
await expect(triggerWorkflowViaDaemon(sockPath, "my-workflow", {})).rejects.toThrow(
|
||||
/Cannot connect to daemon/,
|
||||
);
|
||||
});
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
import { existsSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
|
||||
import type { DaemonIpcTriggerResponse } from "@uncaged/nerve-core";
|
||||
import { DEFAULT_ENGINE_MAX_ROUNDS, isPlainRecord } from "@uncaged/nerve-core";
|
||||
import { isPlainRecord } from "@uncaged/nerve-core";
|
||||
import { defineCommand } from "citty";
|
||||
import { stringify } from "yaml";
|
||||
|
||||
@@ -514,8 +513,7 @@ const workflowTriggerCommand = defineCommand({
|
||||
},
|
||||
payload: {
|
||||
type: "string",
|
||||
description:
|
||||
'JSON with optional "prompt" (string) and "maxRounds" (number) for the workflow run (default: {})',
|
||||
description: "JSON payload to pass as trigger payload (default: {})",
|
||||
default: "{}",
|
||||
},
|
||||
},
|
||||
@@ -528,23 +526,15 @@ const workflowTriggerCommand = defineCommand({
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
let prompt = "";
|
||||
let maxRounds = DEFAULT_ENGINE_MAX_ROUNDS;
|
||||
if (isPlainRecord(triggerPayload)) {
|
||||
const p = triggerPayload;
|
||||
if (typeof p.prompt === "string") prompt = p.prompt;
|
||||
if (typeof p.maxRounds === "number") maxRounds = p.maxRounds;
|
||||
}
|
||||
|
||||
if (!isRunning()) {
|
||||
process.stderr.write("❌ Nerve daemon is not running. Start it with `nerve start`.\n");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const socketPath = getSocketPath();
|
||||
let response: DaemonIpcTriggerResponse;
|
||||
let response: { ok: true } | { ok: false; error: string };
|
||||
try {
|
||||
response = await triggerWorkflowViaDaemon(socketPath, args.name, prompt, maxRounds);
|
||||
response = await triggerWorkflowViaDaemon(socketPath, args.name, triggerPayload);
|
||||
} catch (e) {
|
||||
const msg = e instanceof Error ? e.message : String(e);
|
||||
process.stderr.write(`❌ Failed to contact daemon: ${msg}\n`);
|
||||
|
||||
@@ -8,12 +8,7 @@
|
||||
import { connect } from "node:net";
|
||||
import type { Socket } from "node:net";
|
||||
|
||||
import type {
|
||||
DaemonIpcListSensesResponse,
|
||||
DaemonIpcRequest,
|
||||
DaemonIpcTriggerResponse,
|
||||
SenseInfo,
|
||||
} from "@uncaged/nerve-core";
|
||||
import type { SenseInfo } from "@uncaged/nerve-core";
|
||||
import { isPlainRecord } from "@uncaged/nerve-core";
|
||||
|
||||
const CONNECT_TIMEOUT_MS = 3_000;
|
||||
@@ -21,6 +16,10 @@ const RESPONSE_TIMEOUT_MS = 5_000;
|
||||
|
||||
export type { SenseInfo };
|
||||
|
||||
type TriggerResponse = { ok: true } | { ok: false; error: string };
|
||||
|
||||
type ListSensesResponse = { ok: true; senses: SenseInfo[] } | { ok: false; error: string };
|
||||
|
||||
function isSenseInfo(value: unknown): value is SenseInfo {
|
||||
if (!isPlainRecord(value)) return false;
|
||||
return (
|
||||
@@ -32,7 +31,7 @@ function isSenseInfo(value: unknown): value is SenseInfo {
|
||||
);
|
||||
}
|
||||
|
||||
function parseDaemonResponse(line: string): DaemonIpcTriggerResponse {
|
||||
function parseDaemonResponse(line: string): TriggerResponse {
|
||||
try {
|
||||
const obj: unknown = JSON.parse(line);
|
||||
if (isPlainRecord(obj)) {
|
||||
@@ -46,7 +45,7 @@ function parseDaemonResponse(line: string): DaemonIpcTriggerResponse {
|
||||
return { ok: false, error: `Unexpected daemon response: ${line}` };
|
||||
}
|
||||
|
||||
function parseListSensesResponse(line: string): DaemonIpcListSensesResponse {
|
||||
function parseListSensesResponse(line: string): ListSensesResponse {
|
||||
try {
|
||||
const obj: unknown = JSON.parse(line);
|
||||
if (isPlainRecord(obj)) {
|
||||
@@ -68,7 +67,7 @@ function parseListSensesResponse(line: string): DaemonIpcListSensesResponse {
|
||||
*/
|
||||
function sendAndReceive<T>(
|
||||
socketPath: string,
|
||||
message: DaemonIpcRequest,
|
||||
message: object,
|
||||
parseFirstLine: (trimmed: string) => T,
|
||||
responseTimeoutMs: number = RESPONSE_TIMEOUT_MS,
|
||||
): Promise<T> {
|
||||
@@ -133,35 +132,27 @@ function sendAndReceive<T>(
|
||||
export function triggerWorkflowViaDaemon(
|
||||
socketPath: string,
|
||||
workflow: string,
|
||||
prompt: string,
|
||||
maxRounds: number,
|
||||
): Promise<DaemonIpcTriggerResponse> {
|
||||
const message: DaemonIpcRequest = {
|
||||
type: "trigger-workflow",
|
||||
workflow,
|
||||
prompt,
|
||||
maxRounds,
|
||||
};
|
||||
return sendAndReceive(socketPath, message, parseDaemonResponse);
|
||||
payload: unknown,
|
||||
): Promise<TriggerResponse> {
|
||||
return sendAndReceive(
|
||||
socketPath,
|
||||
{ type: "trigger-workflow", workflow, payload },
|
||||
parseDaemonResponse,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Send a trigger-sense message to the running daemon via its Unix socket.
|
||||
* Resolves with the daemon's response or rejects on connection/timeout errors.
|
||||
*/
|
||||
export function triggerSenseViaDaemon(
|
||||
socketPath: string,
|
||||
sense: string,
|
||||
): Promise<DaemonIpcTriggerResponse> {
|
||||
const message: DaemonIpcRequest = { type: "trigger-sense", sense };
|
||||
return sendAndReceive(socketPath, message, parseDaemonResponse);
|
||||
export function triggerSenseViaDaemon(socketPath: string, sense: string): Promise<TriggerResponse> {
|
||||
return sendAndReceive(socketPath, { type: "trigger-sense", sense }, parseDaemonResponse);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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<DaemonIpcListSensesResponse> {
|
||||
const message: DaemonIpcRequest = { type: "list-senses" };
|
||||
return sendAndReceive(socketPath, message, parseListSensesResponse);
|
||||
export function listSensesViaDaemon(socketPath: string): Promise<ListSensesResponse> {
|
||||
return sendAndReceive(socketPath, { type: "list-senses" }, parseListSensesResponse);
|
||||
}
|
||||
|
||||
+3
-29
@@ -4,12 +4,9 @@ Shared types and configuration parser for the [nerve](../../README.md) observati
|
||||
|
||||
## What's Inside
|
||||
|
||||
- **Type definitions** — `Signal`, `SenseConfig`, `SenseInfo`, `SenseReflexConfig`, `ReflexConfig` (sense-only), `WorkflowConfig`, `NerveConfig`, and related types
|
||||
- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into `NerveConfig` (rejects reflex entries that declare a `workflow` key; reflexes only schedule senses)
|
||||
- **Sense → workflow routing** — `parseSenseWorkflowDirective`, `routeSenseComputeOutput`, and types `ParsedSenseWorkflowDirective`, `SenseComputeRoute`
|
||||
- **Daemon IPC protocol** — request/response types (`DaemonIpcRequest`, `DaemonIpcResponse`, …) and `parseDaemonIpcRequest` for newline-delimited JSON on the CLI ↔ daemon socket
|
||||
- **Workflow automaton types** — `START` / `END` sentinel constants, `WorkflowMessage`, `StartSignal`, `RoleSignal`, `Moderator`, `WorkflowDefinition`, `Role`, `SenseResult`, plus `DEFAULT_ENGINE_MAX_ROUNDS`
|
||||
- **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions for parse paths)
|
||||
- **Type definitions** — `Signal`, `SenseConfig`, `ReflexConfig`, `WorkflowConfig`, `NerveConfig`, and all related types
|
||||
- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into a typed `NerveConfig`
|
||||
- **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions)
|
||||
|
||||
## Usage
|
||||
|
||||
@@ -23,29 +20,6 @@ if (result.ok) {
|
||||
}
|
||||
```
|
||||
|
||||
### Sense return → signal vs workflow
|
||||
|
||||
```typescript
|
||||
import { parseSenseWorkflowDirective, routeSenseComputeOutput } from "@uncaged/nerve-core";
|
||||
|
||||
const directive = parseSenseWorkflowDirective("my-workflow|8|Hello from sense");
|
||||
if (directive.ok) {
|
||||
console.log(directive.value.workflowName, directive.value.maxRounds, directive.value.prompt);
|
||||
}
|
||||
|
||||
const route = routeSenseComputeOutput({
|
||||
metric: 42,
|
||||
workflow: "my-workflow|8|Run now",
|
||||
});
|
||||
if (route.kind === "launch") {
|
||||
// engine starts workflow; no Signal to the bus for this return
|
||||
console.log(route.launch);
|
||||
} else {
|
||||
// normal signal with payload
|
||||
console.log(route.payload);
|
||||
}
|
||||
```
|
||||
|
||||
## Duration Format
|
||||
|
||||
Config fields like `throttle`, `timeout`, and `interval` accept human-readable durations:
|
||||
|
||||
@@ -3,7 +3,9 @@
|
||||
"version": "0.4.0",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"files": ["dist"],
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
|
||||
@@ -1,51 +0,0 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import { parseDaemonIpcRequest } from "../daemon-ipc-protocol.js";
|
||||
|
||||
describe("parseDaemonIpcRequest", () => {
|
||||
it("parses trigger-workflow", () => {
|
||||
expect(
|
||||
parseDaemonIpcRequest(
|
||||
JSON.stringify({
|
||||
type: "trigger-workflow",
|
||||
workflow: "wf",
|
||||
prompt: "go",
|
||||
maxRounds: 3,
|
||||
}),
|
||||
),
|
||||
).toEqual({
|
||||
type: "trigger-workflow",
|
||||
workflow: "wf",
|
||||
prompt: "go",
|
||||
maxRounds: 3,
|
||||
});
|
||||
});
|
||||
|
||||
it("rejects trigger-workflow with empty workflow", () => {
|
||||
expect(
|
||||
parseDaemonIpcRequest(
|
||||
JSON.stringify({
|
||||
type: "trigger-workflow",
|
||||
workflow: "",
|
||||
prompt: "",
|
||||
maxRounds: 1,
|
||||
}),
|
||||
),
|
||||
).toBeNull();
|
||||
});
|
||||
|
||||
it("parses trigger-sense and list-senses", () => {
|
||||
expect(parseDaemonIpcRequest(JSON.stringify({ type: "trigger-sense", sense: "x" }))).toEqual({
|
||||
type: "trigger-sense",
|
||||
sense: "x",
|
||||
});
|
||||
expect(parseDaemonIpcRequest(JSON.stringify({ type: "list-senses" }))).toEqual({
|
||||
type: "list-senses",
|
||||
});
|
||||
});
|
||||
|
||||
it("returns null for invalid JSON or unknown type", () => {
|
||||
expect(parseDaemonIpcRequest("not json")).toBeNull();
|
||||
expect(parseDaemonIpcRequest(JSON.stringify({ type: "nope" }))).toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -1,85 +0,0 @@
|
||||
/**
|
||||
* Daemon Unix-socket IPC protocol (CLI → daemon).
|
||||
* Newline-delimited JSON: one request object per line from the client,
|
||||
* one response object per line from the daemon.
|
||||
*/
|
||||
|
||||
import { isPlainRecord } from "./is-plain-record.js";
|
||||
import type { SenseInfo } from "./types.js";
|
||||
|
||||
/** Client → daemon: start a workflow run. */
|
||||
export type DaemonIpcTriggerWorkflowRequest = {
|
||||
type: "trigger-workflow";
|
||||
workflow: string;
|
||||
prompt: string;
|
||||
maxRounds: number;
|
||||
};
|
||||
|
||||
/** Client → daemon: run a sense compute on demand. */
|
||||
export type DaemonIpcTriggerSenseRequest = {
|
||||
type: "trigger-sense";
|
||||
sense: string;
|
||||
};
|
||||
|
||||
/** Client → daemon: list registered senses. */
|
||||
export type DaemonIpcListSensesRequest = {
|
||||
type: "list-senses";
|
||||
};
|
||||
|
||||
/** Union of all JSON requests the daemon IPC server accepts. */
|
||||
export type DaemonIpcRequest =
|
||||
| DaemonIpcTriggerWorkflowRequest
|
||||
| DaemonIpcTriggerSenseRequest
|
||||
| DaemonIpcListSensesRequest;
|
||||
|
||||
/** Successful trigger / trigger-sense reply (no body). */
|
||||
export type DaemonIpcTriggerOkResponse = { ok: true };
|
||||
|
||||
export type DaemonIpcErrorResponse = { ok: false; error: string };
|
||||
|
||||
/** Replies for trigger-workflow and trigger-sense. */
|
||||
export type DaemonIpcTriggerResponse = DaemonIpcTriggerOkResponse | DaemonIpcErrorResponse;
|
||||
|
||||
/** Reply for list-senses. */
|
||||
export type DaemonIpcListSensesResponse =
|
||||
| { ok: true; senses: SenseInfo[] }
|
||||
| DaemonIpcErrorResponse;
|
||||
|
||||
/** Any JSON response the daemon may write on the IPC socket. */
|
||||
export type DaemonIpcResponse =
|
||||
| DaemonIpcTriggerOkResponse
|
||||
| DaemonIpcErrorResponse
|
||||
| { ok: true; senses: SenseInfo[] };
|
||||
|
||||
/**
|
||||
* Parse a single line of JSON into a {@link DaemonIpcRequest}, or null if invalid.
|
||||
* Kept in core with the request types so CLI and daemon stay aligned at compile time.
|
||||
*/
|
||||
export function parseDaemonIpcRequest(line: string): DaemonIpcRequest | null {
|
||||
try {
|
||||
const obj: unknown = JSON.parse(line);
|
||||
if (!isPlainRecord(obj)) return null;
|
||||
const req = obj;
|
||||
if (req.type === "trigger-workflow") {
|
||||
if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
|
||||
if (typeof req.prompt !== "string") return null;
|
||||
if (typeof req.maxRounds !== "number") return null;
|
||||
return {
|
||||
type: "trigger-workflow",
|
||||
workflow: req.workflow,
|
||||
prompt: req.prompt,
|
||||
maxRounds: req.maxRounds,
|
||||
};
|
||||
}
|
||||
if (req.type === "trigger-sense") {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -32,16 +32,3 @@ export {
|
||||
parseSenseWorkflowDirective,
|
||||
routeSenseComputeOutput,
|
||||
} from "./sense-workflow-directive.js";
|
||||
|
||||
export type {
|
||||
DaemonIpcTriggerWorkflowRequest,
|
||||
DaemonIpcTriggerSenseRequest,
|
||||
DaemonIpcListSensesRequest,
|
||||
DaemonIpcRequest,
|
||||
DaemonIpcTriggerOkResponse,
|
||||
DaemonIpcErrorResponse,
|
||||
DaemonIpcTriggerResponse,
|
||||
DaemonIpcListSensesResponse,
|
||||
DaemonIpcResponse,
|
||||
} from "./daemon-ipc-protocol.js";
|
||||
export { parseDaemonIpcRequest } from "./daemon-ipc-protocol.js";
|
||||
|
||||
+18
-53
@@ -4,33 +4,18 @@ The observation engine runtime for [nerve](../../README.md) — runs senses, rou
|
||||
|
||||
## Architecture
|
||||
|
||||
| Module | Source (indicative) | Responsibility |
|
||||
|--------|---------------------|----------------|
|
||||
| **Kernel** | `kernel.ts` | Orchestrator — worker pool, signal bus, reflex scheduler, workflow manager, optional file watcher and daemon IPC, config reload hooks |
|
||||
| **Worker pool** | `worker-pool.ts` | Fork and supervise one child process per sense group; restart/shutdown; crash cleanup hooks for scheduler state |
|
||||
| **Kernel sense groups** | `kernel-sense-groups.ts` | Derive sense groups from config; list senses per group for scheduling |
|
||||
| **Sense runtime** | sense worker + Drizzle | Per-sense SQLite (`node:sqlite`), migrations, peer DB reads |
|
||||
| **Sense worker** | `sense-worker.ts` (fork target) | Child process entry — runs `compute()` per sense in a group |
|
||||
| **Signal bus** | `signal-bus.ts` | In-memory pub/sub for sense signals |
|
||||
| **Reflex scheduler** | `reflex-scheduler.ts` | Interval + `on` subscriptions, throttle/coalesce |
|
||||
| **Workflow manager** | `workflow-manager.ts` | One worker per workflow name, concurrency (drop/queue), queue caps |
|
||||
| **Workflow worker** | `workflow-worker.ts` | Child process — runs RFC-002 threads (`start-thread`, `resume-thread` IPC) |
|
||||
| **IPC (parent ↔ workers)** | `ipc.ts` | Typed messages for sense and workflow workers (includes `resume-thread` for recovery) |
|
||||
| **Log / workflow persistence** | via `@uncaged/nerve-store` | Structured logs, `workflow_runs`, thread messages (used for recovery) |
|
||||
| **Blob store** | `@uncaged/nerve-store` | CAS under `data/blobs/` — sense workers construct `createBlobStore(join(nerveRoot, "data", "blobs"))` for artifact writes |
|
||||
| **File watcher** | `file-watcher.ts` | Watches workspace paths for config / sense / workflow file changes |
|
||||
| **Kernel file watch** | `kernel-file-watch.ts` | Maps watcher events to `reloadConfig`, sense group restart, workflow `drainAndRespawn` |
|
||||
| **Daemon IPC** | `daemon-ipc.ts` | Unix socket server — parses `@uncaged/nerve-core` `DaemonIpcRequest`, dispatches trigger-workflow / trigger-sense / list-senses |
|
||||
|
||||
## Crash recovery (workflow workers)
|
||||
|
||||
If a workflow worker exits unexpectedly while threads are active:
|
||||
|
||||
- In-flight runs are marked **`crashed`** in the log store; the manager respawns a fresh worker.
|
||||
- Runs still in **`started`** state can be **`resume-thread`**’d: the manager rebuilds the message chain from persisted workflow log rows and sends `resume-thread` to the new worker.
|
||||
- **Crash-loop backoff:** repeated crashes for the same workflow name are counted in a sliding window (`60s`); after **`5`** crashes in that window, the manager **stops respawning** that worker and logs the condition (avoids tight crash loops).
|
||||
|
||||
Hot reload (`drainAndRespawn`) uses a controlled drain: in-flight runs may be marked **`interrupted`** when the old worker is torn down after a timeout — that path is distinct from unexpected crash recovery.
|
||||
| Module | Responsibility |
|
||||
|--------|---------------|
|
||||
| **Kernel** | Top-level orchestrator — spawns workers, wires up signal bus, scheduler, and workflow manager. Supports hot reload and graceful shutdown. |
|
||||
| **Sense Runtime** | Per-sense SQLite database (via `node:sqlite` + Drizzle ORM), migration runner, peer DB read access. |
|
||||
| **Sense Worker** | Forked child process — one per sense group. Runs compute functions in isolation. |
|
||||
| **Signal Bus** | In-memory pub/sub. Sense computes emit signals; reflexes and workflows subscribe. |
|
||||
| **Reflex Scheduler** | Drives compute triggers — interval timers, signal-based events, throttle/coalesce logic. |
|
||||
| **Workflow Manager** | Concurrency control (drop/queue), thread lifecycle, worker process management (RFC-002). |
|
||||
| **Log Store** | Structured log storage in WAL-mode SQLite. Supports retention policies, archival to JSONL, and workflow run tracking. |
|
||||
| **Blob Store** | Binary artifact storage for workflow outputs. |
|
||||
| **File Watcher** | Watches `nerve.yaml` and sense files for hot reload. |
|
||||
| **Daemon IPC** | Unix socket server for CLI ↔ daemon communication. |
|
||||
|
||||
## Key Design Decisions
|
||||
|
||||
@@ -41,44 +26,24 @@ Hot reload (`drainAndRespawn`) uses a controlled drain: in-flight runs may be ma
|
||||
|
||||
## Usage
|
||||
|
||||
The daemon is typically started via the CLI (`nerve daemon start` / `nerve dev`), but you can embed the kernel:
|
||||
The daemon is typically started via the CLI (`nerve daemon start`), but can be used programmatically:
|
||||
|
||||
```typescript
|
||||
import { readFileSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { parseNerveConfig } from "@uncaged/nerve-core";
|
||||
import { createKernel } from "@uncaged/nerve-daemon";
|
||||
|
||||
const nerveRoot = "/path/to/workspace";
|
||||
const yamlPath = join(nerveRoot, "nerve.yaml");
|
||||
const parsed = parseNerveConfig(readFileSync(yamlPath, "utf8"));
|
||||
if (!parsed.ok) {
|
||||
throw parsed.error;
|
||||
}
|
||||
|
||||
const kernel = createKernel(parsed.value, nerveRoot, {
|
||||
enableFileWatcher: true,
|
||||
ipcSocketPath: join(nerveRoot, "nerve.sock"),
|
||||
});
|
||||
|
||||
const kernel = await createKernel(nerveRoot);
|
||||
await kernel.ready;
|
||||
|
||||
// Trigger a sense manually
|
||||
kernel.triggerSense("cpu-usage");
|
||||
|
||||
// Check health
|
||||
const health = kernel.getHealth();
|
||||
|
||||
// Graceful shutdown
|
||||
await kernel.stop();
|
||||
```
|
||||
|
||||
`createKernel(config, nerveRoot, options?)` — `config` is a parsed `NerveConfig`; `nerveRoot` is the workspace root (contains `nerve.yaml`, `data/`, etc.). Optional `KernelOptions`:
|
||||
|
||||
| Field | Meaning |
|
||||
|-------|---------|
|
||||
| `workerScript` | Override path to the sense worker entry script (defaults to the package’s resolved worker) |
|
||||
| `enableFileWatcher` | Watch config / senses / workflows for hot reload |
|
||||
| `logStore` | Inject a `LogStore` instance (defaults to `createLogStore(join(nerveRoot, "data", "logs.db"))`) |
|
||||
| `ipcSocketPath` | When non-null, listen for daemon IPC on this Unix socket path |
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
|
||||
@@ -4,7 +4,9 @@
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": ["dist"],
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
* Unit + integration tests for daemon-ipc.ts — trigger-sense request type.
|
||||
*
|
||||
* Tests cover:
|
||||
* - parseDaemonIpcRequest (core) / server correctly accept or reject trigger-sense messages
|
||||
* - 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
|
||||
|
||||
@@ -2,24 +2,83 @@
|
||||
* Daemon IPC server — listens on a Unix domain socket so that the CLI
|
||||
* can send commands (e.g. trigger-workflow, trigger-sense) to the running daemon process.
|
||||
*
|
||||
* Protocol: newline-delimited JSON — request/response types and
|
||||
* `parseDaemonIpcRequest` live in `@uncaged/nerve-core`.
|
||||
* 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";
|
||||
import { type Server, type Socket, createServer } from "node:net";
|
||||
|
||||
import type { DaemonIpcResponse, SenseInfo } from "@uncaged/nerve-core";
|
||||
import { parseDaemonIpcRequest } from "@uncaged/nerve-core";
|
||||
import type { SenseInfo } from "@uncaged/nerve-core";
|
||||
import { isPlainRecord } from "@uncaged/nerve-core";
|
||||
|
||||
import type { WorkflowManager } from "./workflow-manager.js";
|
||||
|
||||
export type { SenseInfo };
|
||||
|
||||
/** JSON message sent by the CLI to trigger a workflow. */
|
||||
export type TriggerWorkflowRequest = {
|
||||
type: "trigger-workflow";
|
||||
workflow: string;
|
||||
prompt: string;
|
||||
maxRounds: number;
|
||||
};
|
||||
|
||||
/** JSON message sent by the CLI to trigger a sense compute on-demand. */
|
||||
export type TriggerSenseRequest = {
|
||||
type: "trigger-sense";
|
||||
sense: string;
|
||||
};
|
||||
|
||||
/** JSON message sent by the CLI to list registered senses. */
|
||||
export type ListSensesRequest = {
|
||||
type: "list-senses";
|
||||
};
|
||||
|
||||
type DaemonRequest = TriggerWorkflowRequest | TriggerSenseRequest | ListSensesRequest;
|
||||
|
||||
type DaemonResponse =
|
||||
| { ok: true }
|
||||
| { ok: false; error: string }
|
||||
| { ok: true; senses: SenseInfo[] };
|
||||
|
||||
export type DaemonIpcServer = {
|
||||
close: () => Promise<void>;
|
||||
};
|
||||
|
||||
function parseRequest(line: string): DaemonRequest | null {
|
||||
try {
|
||||
const obj: unknown = JSON.parse(line);
|
||||
if (!isPlainRecord(obj)) return null;
|
||||
const req = obj;
|
||||
if (req.type === "trigger-workflow") {
|
||||
if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
|
||||
if (typeof req.prompt !== "string") return null;
|
||||
if (typeof req.maxRounds !== "number") return null;
|
||||
return {
|
||||
type: "trigger-workflow",
|
||||
workflow: req.workflow,
|
||||
prompt: req.prompt,
|
||||
maxRounds: req.maxRounds,
|
||||
};
|
||||
}
|
||||
if (req.type === "trigger-sense") {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
export type DaemonIpcServerOptions = {
|
||||
/** Called when a trigger-sense request arrives. Should throw if the sense is unknown. */
|
||||
triggerSense: (senseName: string) => void;
|
||||
@@ -43,9 +102,9 @@ export function createDaemonIpcServer(
|
||||
const trimmed = line.trim();
|
||||
if (trimmed.length === 0) return;
|
||||
|
||||
const req = parseDaemonIpcRequest(trimmed);
|
||||
const req = parseRequest(trimmed);
|
||||
if (req === null) {
|
||||
const resp: DaemonIpcResponse = { ok: false, error: "Invalid request" };
|
||||
const resp: DaemonResponse = { ok: false, error: "Invalid request" };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
return;
|
||||
}
|
||||
@@ -56,23 +115,20 @@ export function createDaemonIpcServer(
|
||||
prompt: req.prompt,
|
||||
maxRounds: req.maxRounds,
|
||||
});
|
||||
const resp: DaemonIpcResponse = { ok: true };
|
||||
const resp: DaemonResponse = { ok: true };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} else if (req.type === "trigger-sense") {
|
||||
opts.triggerSense(req.sense);
|
||||
const resp: DaemonIpcResponse = { ok: true };
|
||||
const resp: DaemonResponse = { ok: true };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} else if (req.type === "list-senses") {
|
||||
const senses = opts.listSenses();
|
||||
const resp: DaemonIpcResponse = { ok: true, senses };
|
||||
const resp: DaemonResponse = { ok: true, senses };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
} else {
|
||||
const _exhaustive: never = req;
|
||||
void _exhaustive;
|
||||
}
|
||||
} catch (err) {
|
||||
const msg = err instanceof Error ? err.message : String(err);
|
||||
const resp: DaemonIpcResponse = { ok: false, error: msg };
|
||||
const resp: DaemonResponse = { ok: false, error: msg };
|
||||
socket.write(`${JSON.stringify(resp)}\n`);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,7 +30,7 @@ export {
|
||||
export { createKernel } from "./kernel.js";
|
||||
export type { Kernel, KernelOptions, KernelHealth } from "./kernel.js";
|
||||
|
||||
export type { SenseInfo } from "@uncaged/nerve-core";
|
||||
export type { SenseInfo } from "./daemon-ipc.js";
|
||||
|
||||
export { createFileWatcher } from "./file-watcher.js";
|
||||
export type { FileWatcher, FileChange, FileChangeHandler } from "./file-watcher.js";
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
# @uncaged/nerve-store
|
||||
|
||||
Persistent storage for the [nerve](../../README.md) daemon — append-only structured logs, optional JSONL cold archive, and content-addressable blobs.
|
||||
|
||||
## LogStore (`createLogStore`, `log-store.ts`)
|
||||
|
||||
- **Append-only log table** — rows with `source`, `type`, `refId`, `payload`, `ts` (string payloads for ad hoc fields)
|
||||
- **SQLite WAL** — `DatabaseSync` from `node:sqlite`
|
||||
- **Workflow run tracking** — materialized `workflow_runs` table plus helpers to list active runs, upsert status transitions, and read **thread messages** / **role rounds** for CLI and crash recovery
|
||||
- **Meta key-value** — small `meta` table (e.g. archive watermarks)
|
||||
|
||||
Public exports include `LogStore`, `LogEntry`, `LogQuery`, `WorkflowRun`, `WorkflowRunStatus`, `ThreadRoundRow`, `GetThreadRoundsParams`, and archive-related types re-exported from `log-archive`.
|
||||
|
||||
## WorkflowRunStatus
|
||||
|
||||
Runs progress through a small state machine. Typical paths:
|
||||
|
||||
1. **`queued`** → **`started`** when a worker picks up the thread
|
||||
2. **`started`** → **`completed`** | **`failed`** | **`crashed`** | **`interrupted`** | **`dropped`**
|
||||
|
||||
Semantics in the daemon/store layer:
|
||||
|
||||
- **`completed` / `failed`** — normal terminal outcomes from the workflow worker
|
||||
- **`crashed`** — worker exited unexpectedly; manager may respawn and **`resume-thread`** eligible **`started`** runs
|
||||
- **`interrupted`** — e.g. hot-reload drain killed an in-flight thread after timeout
|
||||
- **`dropped`** — concurrency **`overflow: drop`** rejected a new run, or **`overflow: queue`** evicted an queued item when the queue was full
|
||||
|
||||
## LogArchive (`log-archive.ts`)
|
||||
|
||||
- **`archiveLogs`** / helpers — export eligible UTC days of old rows to **`data/archive/logs/YYYY-MM-DD.jsonl`**, delete archived rows from SQLite, optional **`VACUUM`**
|
||||
- Used by **`nerve store archive`** in `@uncaged/nerve-cli`
|
||||
|
||||
## BlobStore (`createBlobStore`, `blob-store.ts`)
|
||||
|
||||
- **Content-addressable storage** — `write` returns lowercase **sha256** hex; files live under **`data/blobs/<2-hex>/<62-hex>`**
|
||||
- **`read` / `exists`** — path must match digest on disk (tamper detection)
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
pnpm add @uncaged/nerve-store
|
||||
```
|
||||
|
||||
Requires Node.js ≥ 22.5 (same as the rest of the stack).
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
@@ -4,7 +4,9 @@
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": ["dist"],
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
{
|
||||
"name": "@uncaged/nerve-workflow-utils",
|
||||
"version": "0.4.0",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": ["dist"],
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"scripts": {
|
||||
"prepublishOnly": "bash ../../scripts/prepublish-check.sh",
|
||||
"build": "rslib build",
|
||||
"test": "vitest run"
|
||||
},
|
||||
"dependencies": {
|
||||
"@uncaged/nerve-core": "workspace:*",
|
||||
"zod": "^4.3.6"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@rslib/core": "^0.21.3",
|
||||
"@types/node": "^22.0.0",
|
||||
"vitest": "^4.1.5"
|
||||
}
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
import { defineConfig } from "@rslib/core";
|
||||
|
||||
export default defineConfig({
|
||||
lib: [
|
||||
{
|
||||
format: "esm",
|
||||
dts: true,
|
||||
},
|
||||
],
|
||||
source: {
|
||||
entry: {
|
||||
index: "src/index.ts",
|
||||
},
|
||||
},
|
||||
output: {
|
||||
target: "node",
|
||||
cleanDistPath: true,
|
||||
},
|
||||
});
|
||||
@@ -1,110 +0,0 @@
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { z } from "zod";
|
||||
|
||||
import { llmExtract } from "../llm-extract.js";
|
||||
|
||||
describe("llmExtract", () => {
|
||||
afterEach(() => {
|
||||
vi.unstubAllGlobals();
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
|
||||
it("parses tool call arguments and validates with the zod schema", async () => {
|
||||
const schema = z
|
||||
.object({
|
||||
name: z.string(),
|
||||
description: z.string(),
|
||||
})
|
||||
.describe("Extract sense metadata from plan");
|
||||
|
||||
const fetchMock = vi.fn().mockResolvedValue({
|
||||
ok: true,
|
||||
status: 200,
|
||||
text: async () =>
|
||||
JSON.stringify({
|
||||
choices: [
|
||||
{
|
||||
message: {
|
||||
tool_calls: [
|
||||
{
|
||||
function: {
|
||||
name: "extract",
|
||||
arguments: JSON.stringify({ name: "cpu-usage", description: "CPU load" }),
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
}),
|
||||
});
|
||||
|
||||
vi.stubGlobal("fetch", fetchMock);
|
||||
|
||||
const result = await llmExtract({
|
||||
text: "some plan",
|
||||
schema,
|
||||
provider: {
|
||||
baseUrl: "https://example.com/v1",
|
||||
apiKey: "k",
|
||||
model: "m",
|
||||
},
|
||||
});
|
||||
|
||||
expect(result.ok).toBe(true);
|
||||
if (!result.ok) {
|
||||
return;
|
||||
}
|
||||
expect(result.value).toEqual({ name: "cpu-usage", description: "CPU load" });
|
||||
|
||||
expect(fetchMock).toHaveBeenCalledTimes(1);
|
||||
const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
|
||||
expect(init.method).toBe("POST");
|
||||
expect(init.headers).toMatchObject({
|
||||
Authorization: "Bearer k",
|
||||
"Content-Type": "application/json",
|
||||
});
|
||||
const body = JSON.parse(init.body as string) as {
|
||||
model: string;
|
||||
tool_choice: { function: { name: string } };
|
||||
};
|
||||
expect(body.model).toBe("m");
|
||||
expect(body.tool_choice.function.name).toBeDefined();
|
||||
});
|
||||
|
||||
it("returns schema_validation_failed when arguments do not match the schema", async () => {
|
||||
const schema = z.object({ n: z.number() });
|
||||
|
||||
vi.stubGlobal(
|
||||
"fetch",
|
||||
vi.fn().mockResolvedValue({
|
||||
ok: true,
|
||||
status: 200,
|
||||
text: async () =>
|
||||
JSON.stringify({
|
||||
choices: [
|
||||
{
|
||||
message: {
|
||||
tool_calls: [
|
||||
{ function: { name: "extract", arguments: JSON.stringify({ n: "oops" }) } },
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
}),
|
||||
}),
|
||||
);
|
||||
|
||||
const result = await llmExtract({
|
||||
text: "x",
|
||||
schema,
|
||||
provider: { baseUrl: "https://example.com", apiKey: "k", model: "m" },
|
||||
});
|
||||
|
||||
expect(result.ok).toBe(false);
|
||||
if (result.ok) {
|
||||
return;
|
||||
}
|
||||
expect(result.error.kind).toBe("schema_validation_failed");
|
||||
});
|
||||
});
|
||||
@@ -1,39 +0,0 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import { spawnSafe } from "../spawn-safe.js";
|
||||
|
||||
describe("spawnSafe", () => {
|
||||
it("passes argv literally without shell interpretation (injection-safe)", async () => {
|
||||
const injection = "$(echo BAD)";
|
||||
const result = await spawnSafe(
|
||||
process.execPath,
|
||||
["-e", "process.stdout.write(process.argv[1] ?? '')", injection],
|
||||
{ cwd: null, env: null, timeoutMs: 10_000 },
|
||||
);
|
||||
|
||||
expect(result.ok).toBe(true);
|
||||
if (!result.ok) {
|
||||
return;
|
||||
}
|
||||
expect(result.value.stdout).toBe(injection);
|
||||
expect(result.value.exitCode).toBe(0);
|
||||
});
|
||||
|
||||
it("returns err on non-zero exit", async () => {
|
||||
const result = await spawnSafe(process.execPath, ["-e", "process.exit(7)"], {
|
||||
cwd: null,
|
||||
env: null,
|
||||
timeoutMs: 10_000,
|
||||
});
|
||||
|
||||
expect(result.ok).toBe(false);
|
||||
if (result.ok) {
|
||||
return;
|
||||
}
|
||||
expect(result.error.kind).toBe("non_zero_exit");
|
||||
if (result.error.kind !== "non_zero_exit") {
|
||||
return;
|
||||
}
|
||||
expect(result.error.exitCode).toBe(7);
|
||||
});
|
||||
});
|
||||
@@ -1,47 +0,0 @@
|
||||
import { readFileSync } from "node:fs";
|
||||
import { resolve } from "node:path";
|
||||
import { type Result, err, ok } from "@uncaged/nerve-core";
|
||||
|
||||
export type ReadNerveYamlOptions = {
|
||||
nerveRoot: string;
|
||||
};
|
||||
|
||||
export type NerveYamlError = {
|
||||
code: "PATH_TRAVERSAL" | "READ_FAILED";
|
||||
message: string;
|
||||
};
|
||||
|
||||
/**
|
||||
* Reads `nerve.yaml` from a Nerve data directory (typically `~/.uncaged-nerve`).
|
||||
* Returns Result to avoid throwing on expected failures (missing file, bad perms).
|
||||
* Validates that the resolved path stays within nerveRoot to prevent path traversal.
|
||||
*/
|
||||
export function readNerveYaml(options: ReadNerveYamlOptions): Result<string, NerveYamlError> {
|
||||
const root = resolve(options.nerveRoot);
|
||||
const target = resolve(root, "nerve.yaml");
|
||||
|
||||
if (!target.startsWith(root)) {
|
||||
return err({
|
||||
code: "PATH_TRAVERSAL",
|
||||
message: `Resolved path "${target}" escapes nerveRoot "${root}"`,
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
return ok(readFileSync(target, "utf-8"));
|
||||
} catch (e) {
|
||||
return err({
|
||||
code: "READ_FAILED",
|
||||
message: e instanceof Error ? e.message : String(e),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shared context for workflow agents: how Nerve fits together and common CLI verbs.
|
||||
*/
|
||||
export const nerveAgentContext = `
|
||||
Nerve observes the world through **Senses** (each has its own SQLite DB and a \`compute()\` function).
|
||||
**Reflexes** (YAML) schedule sense runs or start **Workflows** on intervals or signals.
|
||||
The \`nerve\` CLI manages config, triggers, and queries; keep paths and commands aligned with the host nerve.yaml and senses directory.
|
||||
`.trim();
|
||||
@@ -1,48 +0,0 @@
|
||||
import { type Result, ok } from "@uncaged/nerve-core";
|
||||
|
||||
import { type SpawnEnv, type SpawnError, spawnSafe } from "./spawn-safe.js";
|
||||
|
||||
export type CursorAgentMode = "plan" | "ask" | "default";
|
||||
|
||||
export type CursorAgentOptions = {
|
||||
prompt: string;
|
||||
mode: CursorAgentMode;
|
||||
cwd: string;
|
||||
env: SpawnEnv | null;
|
||||
timeoutMs: number | null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Invokes `cursor-agent` with the prompt passed as a single argv slot (`shell: false`).
|
||||
*/
|
||||
export async function cursorAgent(
|
||||
options: CursorAgentOptions,
|
||||
): Promise<Result<string, SpawnError>> {
|
||||
const args: string[] = [
|
||||
"-p",
|
||||
options.prompt,
|
||||
"--model",
|
||||
"auto",
|
||||
"--output-format",
|
||||
"text",
|
||||
"--trust",
|
||||
"--force",
|
||||
];
|
||||
if (options.mode === "plan") {
|
||||
args.push("--mode=plan");
|
||||
} else if (options.mode === "ask") {
|
||||
args.push("--mode=ask");
|
||||
}
|
||||
|
||||
const run = await spawnSafe("cursor-agent", args, {
|
||||
cwd: options.cwd,
|
||||
env: options.env,
|
||||
timeoutMs: options.timeoutMs,
|
||||
});
|
||||
|
||||
if (!run.ok) {
|
||||
return run;
|
||||
}
|
||||
|
||||
return ok(run.value.stdout);
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
export { cursorAgent, type CursorAgentMode, type CursorAgentOptions } from "./cursor-agent.js";
|
||||
export {
|
||||
nerveAgentContext,
|
||||
readNerveYaml,
|
||||
type NerveYamlError,
|
||||
type ReadNerveYamlOptions,
|
||||
} from "./context.js";
|
||||
export {
|
||||
llmExtract,
|
||||
type LlmError,
|
||||
type LlmExtractOptions,
|
||||
type LlmProvider,
|
||||
} from "./llm-extract.js";
|
||||
export {
|
||||
nerveCommandEnv,
|
||||
spawnSafe,
|
||||
type SpawnEnv,
|
||||
type SpawnError,
|
||||
type SpawnResult,
|
||||
type SpawnSafeOptions,
|
||||
} from "./spawn-safe.js";
|
||||
@@ -1,174 +0,0 @@
|
||||
import { type Result, err, ok } from "@uncaged/nerve-core";
|
||||
import { toJSONSchema, type z } from "zod";
|
||||
|
||||
export type LlmProvider = {
|
||||
baseUrl: string;
|
||||
apiKey: string;
|
||||
model: string;
|
||||
};
|
||||
|
||||
export type LlmExtractOptions<T> = {
|
||||
text: string;
|
||||
schema: z.ZodType<T>;
|
||||
provider: LlmProvider;
|
||||
};
|
||||
|
||||
export type LlmError =
|
||||
| { kind: "http_error"; status: number; body: string }
|
||||
| { kind: "invalid_response_json"; message: string }
|
||||
| { kind: "no_tool_call"; preview: string }
|
||||
| { kind: "tool_arguments_invalid_json"; message: string }
|
||||
| { kind: "schema_validation_failed"; message: string }
|
||||
| { kind: "network_error"; message: string };
|
||||
|
||||
function chatCompletionsUrl(baseUrl: string): string {
|
||||
const trimmed = baseUrl.replace(/\/+$/, "");
|
||||
return `${trimmed}/chat/completions`;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === "object" && value !== null && !Array.isArray(value);
|
||||
}
|
||||
|
||||
function stripJsonSchemaMeta(json: Record<string, unknown>): Record<string, unknown> {
|
||||
const { $schema: _drop, ...rest } = json;
|
||||
return rest;
|
||||
}
|
||||
|
||||
function readToolName(parametersSchema: Record<string, unknown>): string {
|
||||
const title = parametersSchema.title;
|
||||
if (typeof title === "string" && title.trim().length > 0) {
|
||||
return title.trim();
|
||||
}
|
||||
return "extract";
|
||||
}
|
||||
|
||||
function readToolArgumentsJson(parsed: unknown, previewSource: string): Result<string, LlmError> {
|
||||
if (!isRecord(parsed)) {
|
||||
return err({ kind: "invalid_response_json", message: "Top-level JSON is not an object" });
|
||||
}
|
||||
|
||||
const choices = parsed.choices;
|
||||
if (!Array.isArray(choices) || choices.length === 0) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const first = choices[0];
|
||||
if (!isRecord(first)) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const messageObj = first.message;
|
||||
if (!isRecord(messageObj)) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const toolCalls = messageObj.tool_calls;
|
||||
if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const call0 = toolCalls[0];
|
||||
if (!isRecord(call0)) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const fn = call0.function;
|
||||
if (!isRecord(fn)) {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
const argsRaw = fn.arguments;
|
||||
if (typeof argsRaw !== "string") {
|
||||
return err({ kind: "no_tool_call", preview: previewSource.slice(0, 500) });
|
||||
}
|
||||
|
||||
return ok(argsRaw);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calls an OpenAI-compatible chat completions API with `tool_choice` forced to a single function
|
||||
* derived from a Zod v4 schema (`toJSONSchema`). Uses `fetch()` only (no shell).
|
||||
*/
|
||||
export async function llmExtract<T>(options: LlmExtractOptions<T>): Promise<Result<T, LlmError>> {
|
||||
const rawJsonSchema = toJSONSchema(options.schema) as Record<string, unknown>;
|
||||
const parameters = stripJsonSchemaMeta(rawJsonSchema);
|
||||
const toolName = readToolName(parameters);
|
||||
const toolDescription =
|
||||
typeof options.schema.description === "string" && options.schema.description.trim().length > 0
|
||||
? options.schema.description.trim()
|
||||
: "Extract structured data from the input text.";
|
||||
|
||||
const body = {
|
||||
model: options.provider.model,
|
||||
messages: [
|
||||
{
|
||||
role: "system" as const,
|
||||
content: "Extract the requested information from the provided text. Be precise.",
|
||||
},
|
||||
{ role: "user" as const, content: options.text },
|
||||
],
|
||||
tools: [
|
||||
{
|
||||
type: "function" as const,
|
||||
function: {
|
||||
name: toolName,
|
||||
description: toolDescription,
|
||||
parameters,
|
||||
},
|
||||
},
|
||||
],
|
||||
tool_choice: { type: "function" as const, function: { name: toolName } },
|
||||
};
|
||||
|
||||
let response: Response;
|
||||
try {
|
||||
response = await fetch(chatCompletionsUrl(options.provider.baseUrl), {
|
||||
method: "POST",
|
||||
headers: {
|
||||
Authorization: `Bearer ${options.provider.apiKey}`,
|
||||
"Content-Type": "application/json",
|
||||
},
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
} catch (cause) {
|
||||
const message = cause instanceof Error ? cause.message : String(cause);
|
||||
return err({ kind: "network_error", message });
|
||||
}
|
||||
|
||||
const responseText = await response.text();
|
||||
if (!response.ok) {
|
||||
return err({ kind: "http_error", status: response.status, body: responseText.slice(0, 4000) });
|
||||
}
|
||||
|
||||
let parsed: unknown;
|
||||
try {
|
||||
parsed = JSON.parse(responseText) as unknown;
|
||||
} catch (cause) {
|
||||
const message = cause instanceof Error ? cause.message : String(cause);
|
||||
return err({ kind: "invalid_response_json", message });
|
||||
}
|
||||
|
||||
const argsJson = readToolArgumentsJson(parsed, responseText);
|
||||
if (!argsJson.ok) {
|
||||
return argsJson;
|
||||
}
|
||||
|
||||
let argsParsed: unknown;
|
||||
try {
|
||||
argsParsed = JSON.parse(argsJson.value) as unknown;
|
||||
} catch (cause) {
|
||||
const message = cause instanceof Error ? cause.message : String(cause);
|
||||
return err({ kind: "tool_arguments_invalid_json", message });
|
||||
}
|
||||
|
||||
const validated = options.schema.safeParse(argsParsed);
|
||||
if (!validated.success) {
|
||||
return err({
|
||||
kind: "schema_validation_failed",
|
||||
message: validated.error.message,
|
||||
});
|
||||
}
|
||||
|
||||
return ok(validated.data);
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
import { spawn } from "node:child_process";
|
||||
import { homedir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { type Result, err, ok } from "@uncaged/nerve-core";
|
||||
|
||||
/** Compatible with `process.env` for `child_process.spawn`. */
|
||||
export type SpawnEnv = Record<string, string | undefined>;
|
||||
|
||||
export type SpawnResult = {
|
||||
stdout: string;
|
||||
stderr: string;
|
||||
exitCode: number;
|
||||
/** OS signal name (e.g. `"SIGTERM"`) when terminated by signal; otherwise `null`. */
|
||||
signal: string | null;
|
||||
};
|
||||
|
||||
export type SpawnError =
|
||||
| {
|
||||
kind: "non_zero_exit";
|
||||
stdout: string;
|
||||
stderr: string;
|
||||
exitCode: number;
|
||||
signal: string | null;
|
||||
}
|
||||
| { kind: "timeout"; stdout: string; stderr: string }
|
||||
| { kind: "spawn_failed"; message: string };
|
||||
|
||||
export type SpawnSafeOptions = {
|
||||
cwd: string | null;
|
||||
/** When null, merges {@link nerveCommandEnv} over `process.env`. When set, merges over that default. */
|
||||
env: SpawnEnv | null;
|
||||
timeoutMs: number | null;
|
||||
};
|
||||
|
||||
const DEFAULT_TIMEOUT_MS = 300_000;
|
||||
|
||||
/**
|
||||
* PATH and PNPM_HOME for running `pnpm` and `nerve` from workflow roles.
|
||||
* Uses the pnpm store home only (no npm user bin); binaries must resolve via PATH.
|
||||
*/
|
||||
export function nerveCommandEnv(): SpawnEnv {
|
||||
const home = homedir();
|
||||
const pnpmHome = join(home, ".local/share/pnpm");
|
||||
return {
|
||||
...process.env,
|
||||
PNPM_HOME: pnpmHome,
|
||||
PATH: `${pnpmHome}:${process.env.PATH ?? ""}`,
|
||||
};
|
||||
}
|
||||
|
||||
function mergeEnv(user: SpawnEnv | null): SpawnEnv {
|
||||
const base = nerveCommandEnv();
|
||||
if (user === null) {
|
||||
return base;
|
||||
}
|
||||
return { ...base, ...user };
|
||||
}
|
||||
|
||||
function resolveTimeout(timeoutMs: number | null): number {
|
||||
if (timeoutMs === null) {
|
||||
return DEFAULT_TIMEOUT_MS;
|
||||
}
|
||||
return timeoutMs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawn a process with `shell: false` (argv only), default {@link nerveCommandEnv}, and optional timeout.
|
||||
* Returns `ok` only when the process exits with code 0.
|
||||
*/
|
||||
export function spawnSafe(
|
||||
command: string,
|
||||
args: ReadonlyArray<string>,
|
||||
options: SpawnSafeOptions,
|
||||
): Promise<Result<SpawnResult, SpawnError>> {
|
||||
return new Promise((resolve) => {
|
||||
const cwd = options.cwd === null ? process.cwd() : options.cwd;
|
||||
const env = mergeEnv(options.env);
|
||||
const timeoutMs = resolveTimeout(options.timeoutMs);
|
||||
|
||||
const child = spawn(command, args, {
|
||||
cwd,
|
||||
env,
|
||||
shell: false,
|
||||
stdio: ["ignore", "pipe", "pipe"],
|
||||
});
|
||||
|
||||
let stdout = "";
|
||||
let stderr = "";
|
||||
let settled = false;
|
||||
|
||||
const finish = (outcome: Result<SpawnResult, SpawnError>) => {
|
||||
if (settled) {
|
||||
return;
|
||||
}
|
||||
settled = true;
|
||||
clearTimeout(timer);
|
||||
resolve(outcome);
|
||||
};
|
||||
|
||||
const timer = setTimeout(() => {
|
||||
child.kill("SIGTERM");
|
||||
finish(err({ kind: "timeout", stdout, stderr }));
|
||||
}, timeoutMs);
|
||||
|
||||
child.stdout?.on("data", (chunk: Buffer | string) => {
|
||||
stdout += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
|
||||
});
|
||||
child.stderr?.on("data", (chunk: Buffer | string) => {
|
||||
stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
|
||||
});
|
||||
|
||||
child.on("error", (cause: Error) => {
|
||||
finish(err({ kind: "spawn_failed", message: cause.message }));
|
||||
});
|
||||
|
||||
child.on("close", (code, signal) => {
|
||||
const exitCode = code ?? 1;
|
||||
const sig = signal === undefined || signal === null ? null : String(signal);
|
||||
const result: SpawnResult = {
|
||||
stdout: stdout.trimEnd(),
|
||||
stderr: stderr.trimEnd(),
|
||||
exitCode,
|
||||
signal: sig,
|
||||
};
|
||||
if (exitCode !== 0) {
|
||||
finish(
|
||||
err({
|
||||
kind: "non_zero_exit",
|
||||
stdout: result.stdout,
|
||||
stderr: result.stderr,
|
||||
exitCode,
|
||||
signal: sig,
|
||||
}),
|
||||
);
|
||||
return;
|
||||
}
|
||||
finish(ok(result));
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.json",
|
||||
"compilerOptions": {
|
||||
"outDir": "dist",
|
||||
"rootDir": "src",
|
||||
"composite": false
|
||||
},
|
||||
"include": ["src"]
|
||||
}
|
||||
Generated
+2
-27
@@ -69,7 +69,7 @@ importers:
|
||||
version: link:../store
|
||||
drizzle-orm:
|
||||
specifier: 1.0.0-beta.23-c10d10c
|
||||
version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6)
|
||||
version: 1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)
|
||||
yaml:
|
||||
specifier: ^2.8.3
|
||||
version: 2.8.3
|
||||
@@ -100,25 +100,6 @@ importers:
|
||||
specifier: ^4.1.5
|
||||
version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
|
||||
|
||||
packages/workflow-utils:
|
||||
dependencies:
|
||||
'@uncaged/nerve-core':
|
||||
specifier: workspace:*
|
||||
version: link:../core
|
||||
zod:
|
||||
specifier: ^4.3.6
|
||||
version: 4.3.6
|
||||
devDependencies:
|
||||
'@rslib/core':
|
||||
specifier: ^0.21.3
|
||||
version: 0.21.3(typescript@5.9.3)
|
||||
'@types/node':
|
||||
specifier: ^22.0.0
|
||||
version: 22.19.17
|
||||
vitest:
|
||||
specifier: ^4.1.5
|
||||
version: 4.1.5(@types/node@22.19.17)(vite@8.0.9(@types/node@22.19.17)(esbuild@0.27.7)(yaml@2.8.3))
|
||||
|
||||
packages:
|
||||
|
||||
'@ast-grep/napi-darwin-arm64@0.37.0':
|
||||
@@ -1491,9 +1472,6 @@ packages:
|
||||
engines: {node: '>= 14.6'}
|
||||
hasBin: true
|
||||
|
||||
zod@4.3.6:
|
||||
resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
|
||||
|
||||
snapshots:
|
||||
|
||||
'@ast-grep/napi-darwin-arm64@0.37.0':
|
||||
@@ -2191,14 +2169,13 @@ snapshots:
|
||||
|
||||
detect-libc@2.1.2: {}
|
||||
|
||||
drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1)(zod@4.3.6):
|
||||
drizzle-orm@1.0.0-beta.23-c10d10c(@types/better-sqlite3@7.6.13)(@types/mssql@9.1.11(@azure/core-client@1.10.1))(better-sqlite3@11.10.0)(mssql@11.0.1(@azure/core-client@1.10.1))(sql.js@1.14.1):
|
||||
optionalDependencies:
|
||||
'@types/better-sqlite3': 7.6.13
|
||||
'@types/mssql': 9.1.11(@azure/core-client@1.10.1)
|
||||
better-sqlite3: 11.10.0
|
||||
mssql: 11.0.1(@azure/core-client@1.10.1)
|
||||
sql.js: 1.14.1
|
||||
zod: 4.3.6
|
||||
|
||||
ecdsa-sig-formatter@1.0.11:
|
||||
dependencies:
|
||||
@@ -2795,5 +2772,3 @@ snapshots:
|
||||
optional: true
|
||||
|
||||
yaml@2.8.3: {}
|
||||
|
||||
zod@4.3.6: {}
|
||||
|
||||
Reference in New Issue
Block a user