edge-ai-client-ts 1.0.0

package/dist/cli/messages.js

@@ -0,0 +1,59 @@
+/**
+ * `messages` subcommand — list recent LLM conversation messages (operator-scoped).
+ * Mirrors `edge-client/src/cli/messages.rs`.
+ */
+import { loadSettings, loadDeviceSecret } from '../config/settings.js';
+export async function listMessages(limit) {
+    if (!Number.isInteger(limit) || limit <= 0) {
+        console.error('ec-ts messages: invalid --limit');
+        return 1;
+    }
+    const settings = loadSettings();
+    if (!settings.owner_operator_id) {
+        console.error('ec-ts messages: not enrolled');
+        return 2;
+    }
+    const secret = loadDeviceSecret();
+    if (!secret) {
+        console.error('ec-ts messages: device secret missing');
+        return 3;
+    }
+    const httpUrl = settings.server.ws_url
+        .replace(/^wss:/, 'https:')
+        .replace(/^ws:/, 'http:')
+        .replace(/\/edge$/, '')
+        .replace(/\/$/, '');
+    const url = `${httpUrl}/api/messages/recent?operator_id=${encodeURIComponent(settings.owner_operator_id)}&limit=${limit}`;
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'X-Device-Secret': secret } });
+    }
+    catch (e) {
+        console.error(`ec-ts messages: network error: ${String(e)}`);
+        return 4;
+    }
+    if (!resp.ok) {
+        console.error(`ec-ts messages: HTTP ${resp.status}`);
+        return 5;
+    }
+    let body;
+    try {
+        body = (await resp.json());
+    }
+    catch {
+        console.error('ec-ts messages: non-JSON response');
+        return 6;
+    }
+    const items = body.items ?? [];
+    if (items.length === 0) {
+        console.log('(no recent messages)');
+        return 0;
+    }
+    console.log(`Recent messages (${items.length}):`);
+    for (const m of items) {
+        const ts = new Date(m.timestamp).toISOString();
+        const preview = m.content.length > 80 ? m.content.slice(0, 77) + '...' : m.content;
+        console.log(`  [${ts}] ${m.agent_id} (${m.role}): ${preview}`);
+    }
+    return 0;
+}

package/dist/cli/run.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Start the daemon and block until SIGINT/SIGTERM.
+ * Returns the process exit code.
+ */
+export declare function runDaemon(): Promise<number>;

package/dist/cli/run.js

@@ -0,0 +1,112 @@
+/**
+ * `run` subcommand — start the edge-client daemon.
+ * Mirrors `edge-client/src/cli/mod.rs::Command::Run`.
+ */
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { loadSettings, configDir, } from '../config/settings.js';
+import { EdgeWsClient } from '../network/ws-client.js';
+import { SessionManager } from '../session/manager.js';
+import { DiskBufferQueue } from '../buffer/disk-queue.js';
+import { FileLogger } from '../logging/file-logger.js';
+/**
+ * Start the daemon and block until SIGINT/SIGTERM.
+ * Returns the process exit code.
+ */
+export async function runDaemon() {
+    let settings;
+    try {
+        settings = loadSettings();
+    }
+    catch (e) {
+        console.error(`ec-ts: failed to load settings: ${String(e)}`);
+        console.error('run `ec-ts enroll --key <KEY>` once to generate the default config, then re-run.');
+        return 1;
+    }
+    const logDir = path.join(configDir(), 'logs');
+    const logger = new FileLogger(logDir);
+    await logger.info(`starting daemon (machine_id=${settings.machine_id})`);
+    // Set up disk-backed buffer queue for offline resilience.
+    const bufferKey = settings.buffer.key
+        ? Buffer.from(settings.buffer.key, 'hex')
+        : Buffer.alloc(32); // zero key if not configured (dev only)
+    const buffer = new DiskBufferQueue({
+        dir: settings.buffer.dump_dir ?? './buffer-dump',
+        key: bufferKey,
+        maxBytes: settings.buffer.max_memory_mb * 1024 * 1024,
+    });
+    // Session manager owns PTY/SFTP/pi processes.
+    const sessionManager = new SessionManager({
+        machineId: settings.machine_id,
+        shellEnabled: settings.shell.enabled,
+    });
+    // WS client to the relay. Route inbound messages to the session manager
+    // (live) or to the disk buffer (offline → drain on reconnect).
+    const ws = new EdgeWsClient({ settings });
+    ws.on('inbound', (msg) => {
+        void (async () => {
+            try {
+                if (msg && typeof msg === 'object' && 'type' in msg) {
+                    const m = msg;
+                    if (m.type === 'extension_ui_response' && typeof m.msg_id === 'string') {
+                        // Forward HITL responses to the right agent's pi session.
+                        const agentId = msg.agent_id;
+                        if (typeof agentId === 'string') {
+                            await sessionManager.forwardExtensionUIResponse(agentId, m.msg_id, msg);
+                        }
+                        return;
+                    }
+                }
+                // Persist to the offline buffer (best-effort, never blocks the WS loop).
+                const buf = Buffer.from(JSON.stringify(msg), 'utf8');
+                await buffer.append({
+                    msg_id: typeof msg.msg_id === 'string' ? msg.msg_id : crypto.randomUUID(),
+                    timestamp: Date.now(),
+                    bytes: buf,
+                });
+            }
+            catch (e) {
+                await logger.warn(`inbound handler failed: ${String(e)}`);
+            }
+        })();
+    });
+    ws.on('online', () => void logger.info('relay online'));
+    ws.on('offline', () => void logger.warn('relay offline'));
+    ws.on('error', (err) => {
+        void logger.error(`ws error: ${err?.message ?? 'null (no detail)'}`);
+    });
+    // Graceful shutdown on SIGINT/SIGTERM.
+    const shutdown = async (signal) => {
+        await logger.info(`shutdown signal received (${signal})`);
+        try {
+            ws.stop();
+            await sessionManager.closeAll();
+        }
+        catch (e) {
+            await logger.error(`shutdown error: ${String(e)}`);
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    // Fire-and-forget start — the EdgeWsClient's internal reconnect logic
+    // handles retries on failure with exponential backoff. The daemon blocks
+    // forever regardless of connect success/failure; SIGINT/SIGTERM exits cleanly.
+    //
+    // We do NOT `await ws.start()` (which throws on first connect failure)
+    // because that would kill the daemon before the reconnect timer gets a
+    // chance to fire. Instead we let start() run in the background, log the
+    // outcome, and block on the forever-promise below.
+    void ws.start()
+        .then(() => void logger.info(`daemon connected (ws=${settings.server.ws_url}, host=${os.hostname()})`))
+        .catch(async (e) => {
+        // First-attempt failure — logged but NOT fatal. The reconnect timer
+        // inside EdgeWsClient.start() will keep retrying.
+        const msg = e instanceof Error ? e.message : String(e);
+        await logger.error(`initial connection failed (will retry): ${msg}`);
+        console.error(`ec-ts: initial connection failed (will retry): ${msg}`);
+    });
+    // Block forever; SIGINT/SIGTERM handler exits cleanly.
+    await new Promise(() => { });
+    return 0;
+}

package/dist/cli/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<number>;

package/dist/cli/status.js

@@ -0,0 +1,56 @@
+/**
+ * `status` subcommand — show daemon + relay contact status.
+ * Mirrors `edge-client/src/cli/status.rs`.
+ *
+ * Reads local settings + tries a quick HTTP HEAD against the relay to verify
+ * reachability. Does NOT require the daemon to be running.
+ */
+import { loadSettings } from '../config/settings.js';
+import * as os from 'node:os';
+export async function status() {
+    let settings;
+    try {
+        settings = loadSettings();
+    }
+    catch (e) {
+        console.error(`ec-ts status: failed to load settings: ${String(e)}`);
+        return 1;
+    }
+    // Derive HTTP probe URL from ws_url.
+    const httpUrl = settings.server.ws_url
+        .replace(/^wss:/, 'https:')
+        .replace(/^ws:/, 'http:')
+        .replace(/\/edge$/, '')
+        .replace(/\/$/, '');
+    console.log('ec-ts status:');
+    console.log(`  machine_id:    ${settings.machine_id}`);
+    console.log(`  operator_id:   ${settings.owner_operator_id ?? '(not enrolled)'}`);
+    console.log(`  relay:         ${settings.server.ws_url}`);
+    // Probe relay reachability (short timeout — best effort).
+    const t0 = Date.now();
+    let reachable = false;
+    let httpStatus = -1;
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 3_000);
+        const resp = await fetch(httpUrl + '/api/health', {
+            method: 'GET',
+            signal: ctl.signal,
+        });
+        clearTimeout(timer);
+        httpStatus = resp.status;
+        reachable = resp.ok;
+    }
+    catch {
+        reachable = false;
+    }
+    const rttMs = Date.now() - t0;
+    console.log(`  relay reach:   ${reachable ? 'OK' : 'unreachable'} (HTTP ${httpStatus}, ${rttMs} ms)`);
+    // System info (matches Rust StatusArgs output).
+    console.log(`  platform:      ${process.platform}`);
+    console.log(`  arch:          ${process.arch}`);
+    console.log(`  hostname:      ${os.hostname()}`);
+    console.log(`  node:          ${process.version}`);
+    console.log(`  pid:           ${process.pid}`);
+    return reachable ? 0 : 2;
+}

package/dist/cli/whoami.d.ts

@@ -0,0 +1,2 @@
+/** Print the local identity. */
+export declare function whoami(): Promise<number>;

package/dist/cli/whoami.js

@@ -0,0 +1,41 @@
+/**
+ * `whoami` subcommand — show this edge node's local identity.
+ * Mirrors `edge-client/src/cli/whoami.rs`.
+ *
+ * Local-only — does NOT call the relay. Shows operator_id, machine_id,
+ * ws_url, configured key hint + id.
+ */
+import { loadSettings, loadDeviceSecret } from '../config/settings.js';
+/** Print the local identity. */
+export async function whoami() {
+    let settings;
+    try {
+        settings = loadSettings();
+    }
+    catch (e) {
+        console.error(`ec-ts whoami: failed to load settings: ${String(e)}`);
+        return 1;
+    }
+    // Key hint = first 4 + last 4 chars of device_secret (if present), so the user
+    // can distinguish multiple enrollments without leaking the full secret.
+    const secret = loadDeviceSecret();
+    let keyHint = '(not set)';
+    if (secret && secret.length >= 8) {
+        keyHint = `${secret.slice(0, 4)}...${secret.slice(-4)}`;
+    }
+    else if (secret) {
+        keyHint = `${secret.length} chars`;
+    }
+    console.log('ec-ts local identity:');
+    console.log(`  operator_id:   ${settings.owner_operator_id ?? '(not enrolled)'}`);
+    console.log(`  machine_id:    ${settings.machine_id}`);
+    console.log(`  agent_id:      ${settings.agent.default_agent_id}`);
+    console.log(`  relay (ws):    ${settings.server.ws_url}`);
+    if (settings.server.ws_url_lan)
+        console.log(`  relay (lan):   ${settings.server.ws_url_lan}`);
+    if (settings.server.ws_url_wan)
+        console.log(`  relay (wan):   ${settings.server.ws_url_wan}`);
+    console.log(`  api key hint:  ${keyHint}`);
+    console.log(`  shell enabled: ${settings.shell.enabled}`);
+    return 0;
+}

package/dist/config/cmd-gate.d.ts

@@ -0,0 +1,65 @@
+/**
+ * AGT-03 pre-execution command gate — **config schema** portion.
+ *
+ * Mirrors the `CmdGateConfig` struct + defaults + env-resolve logic from
+ * `edge-client/src/session/cmd_gate.rs`. The runtime **decision** logic
+ * (`GateDecision`, `evaluate`) lives in `src/session/cmd-gate.ts` (Phase 2)
+ * and imports the types defined here.
+ *
+ * This split mirrors the Rust layout where `config/settings.rs` references
+ * `session::cmd_gate::CmdGateConfig` for the schema, while the `evaluate`
+ * decision function lives in the same Rust file but is purely session-side.
+ * In TS we separate config (here) from session logic to keep the dependency
+ * graph clean: `config/` must not import from `session/`.
+ */
+/**
+ * Gate enforcement mode. Serialized as lowercase in TOML (mirrors Rust's
+ * `#[serde(rename_all = "lowercase")]`).
+ *
+ * - `off`   — Legacy: never gate, never inspect.
+ * - `warn`  — Gate: every decision is Allow or RequireApproval; denylist hits
+ *             are surfaced for approval but never auto-denied.
+ * - `block` — Strict (default): denylist hits → Deny; always_approve hits →
+ *             RequireApproval; everything else → Allow.
+ */
+export type CmdGateMode = 'off' | 'warn' | 'block';
+/**
+ * Configurable gate policy. Field names EXACTLY match the Rust struct.
+ */
+export interface CmdGateConfig {
+    readonly mode: CmdGateMode;
+    /** Tools that are always safe (read-only introspection). */
+    readonly allowlist: readonly string[];
+    /** Tool names that require operator approval (mutating/exec-class). */
+    readonly always_approve: readonly string[];
+    /** Substring patterns that force Deny (block) or RequireApproval (warn). */
+    readonly denylist: readonly string[];
+    /** Seconds to wait for operator approval before aborting pi. */
+    readonly timeout_s: number;
+}
+/** Default allowlist — read-only introspection tools. */
+export declare function defaultAllowlist(): string[];
+/** Default always-approve list — mutating/exec-class tools. */
+export declare function defaultAlwaysApprove(): string[];
+/** Default denylist — destructive substring patterns. */
+export declare function defaultDenylist(): string[];
+/** Default timeout for operator approval (seconds). */
+export declare const DEFAULT_CMD_GATE_TIMEOUT_S = 60;
+/** Construct the default CmdGateConfig (safe defaults: block mode). */
+export declare function defaultCmdGateConfig(): CmdGateConfig;
+/**
+ * Parse a comma-separated string into a trimmed, non-empty string list.
+ * Mirrors Rust's `parse_csv`.
+ */
+export declare function parseCsv(raw: string): string[];
+/**
+ * Resolve the gate config from env overrides. Env wins over the config value.
+ *
+ * Env names (mirrors Rust exactly):
+ *   - `EDGE_CMD_GATE_MODE`      = `off` | `warn` | `block`
+ *   - `EDGE_CMD_GATE_TIMEOUT_S` = seconds
+ *   - `EDGE_CMD_GATE_ALLOWLIST` = comma-separated tool names (replaces)
+ *   - `EDGE_CMD_GATE_APPROVE`   = comma-separated tool names (replaces)
+ *   - `EDGE_CMD_GATE_DENYLIST`  = comma-separated patterns (replaces)
+ */
+export declare function resolveCmdGateConfig(env: Record<string, string | undefined>, config: CmdGateConfig): CmdGateConfig;

package/dist/config/cmd-gate.js

@@ -0,0 +1,128 @@
+/**
+ * AGT-03 pre-execution command gate — **config schema** portion.
+ *
+ * Mirrors the `CmdGateConfig` struct + defaults + env-resolve logic from
+ * `edge-client/src/session/cmd_gate.rs`. The runtime **decision** logic
+ * (`GateDecision`, `evaluate`) lives in `src/session/cmd-gate.ts` (Phase 2)
+ * and imports the types defined here.
+ *
+ * This split mirrors the Rust layout where `config/settings.rs` references
+ * `session::cmd_gate::CmdGateConfig` for the schema, while the `evaluate`
+ * decision function lives in the same Rust file but is purely session-side.
+ * In TS we separate config (here) from session logic to keep the dependency
+ * graph clean: `config/` must not import from `session/`.
+ */
+/** Default allowlist — read-only introspection tools. */
+export function defaultAllowlist() {
+    return [
+        'read',
+        'read_file',
+        'cat',
+        'ls',
+        'list_directory',
+        'find',
+        'grep',
+        'search',
+        'git_log',
+        'git_diff',
+    ];
+}
+/** Default always-approve list — mutating/exec-class tools. */
+export function defaultAlwaysApprove() {
+    return [
+        'bash',
+        'exec',
+        'run_command',
+        'shell_exec',
+        'process',
+        'write',
+        'edit',
+        'delete',
+        'move',
+        'rename',
+    ];
+}
+/** Default denylist — destructive substring patterns. */
+export function defaultDenylist() {
+    return [
+        // Unix destructive
+        'rm -rf',
+        'rm -fr',
+        'rm -f /',
+        ':(){ :|:& };:', // fork bomb
+        'dd if=/dev/zero',
+        'dd if=/dev/urandom',
+        'mkfs.',
+        'mkfs ',
+        'shutdown',
+        'reboot',
+        'halt',
+        'poweroff',
+        // Windows destructive
+        'format c:',
+        'format d:',
+        'reg delete',
+        'bcdedit',
+        'rd /s /q',
+        'del /f /s /q',
+        // Privilege escalation
+        'sudo su',
+        'sudo -i',
+    ];
+}
+/** Default timeout for operator approval (seconds). */
+export const DEFAULT_CMD_GATE_TIMEOUT_S = 60;
+/** Construct the default CmdGateConfig (safe defaults: block mode). */
+export function defaultCmdGateConfig() {
+    return {
+        mode: 'block',
+        allowlist: defaultAllowlist(),
+        always_approve: defaultAlwaysApprove(),
+        denylist: defaultDenylist(),
+        timeout_s: DEFAULT_CMD_GATE_TIMEOUT_S,
+    };
+}
+/**
+ * Parse a comma-separated string into a trimmed, non-empty string list.
+ * Mirrors Rust's `parse_csv`.
+ */
+export function parseCsv(raw) {
+    return raw
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+}
+/**
+ * Resolve the gate config from env overrides. Env wins over the config value.
+ *
+ * Env names (mirrors Rust exactly):
+ *   - `EDGE_CMD_GATE_MODE`      = `off` | `warn` | `block`
+ *   - `EDGE_CMD_GATE_TIMEOUT_S` = seconds
+ *   - `EDGE_CMD_GATE_ALLOWLIST` = comma-separated tool names (replaces)
+ *   - `EDGE_CMD_GATE_APPROVE`   = comma-separated tool names (replaces)
+ *   - `EDGE_CMD_GATE_DENYLIST`  = comma-separated patterns (replaces)
+ */
+export function resolveCmdGateConfig(env, config) {
+    const modeEnv = env['EDGE_CMD_GATE_MODE'];
+    let mode = config.mode;
+    if (modeEnv === 'off' || modeEnv === 'warn' || modeEnv === 'block') {
+        mode = modeEnv;
+    }
+    const timeoutEnv = env['EDGE_CMD_GATE_TIMEOUT_S'];
+    let timeout_s = config.timeout_s;
+    if (timeoutEnv !== undefined) {
+        const parsed = Number.parseInt(timeoutEnv.trim(), 10);
+        if (Number.isFinite(parsed)) {
+            timeout_s = parsed;
+        }
+    }
+    const allowlistEnv = env['EDGE_CMD_GATE_ALLOWLIST'];
+    const allowlist = allowlistEnv !== undefined ? parseCsv(allowlistEnv) : [...config.allowlist];
+    const alwaysApproveEnv = env['EDGE_CMD_GATE_APPROVE'];
+    const always_approve = alwaysApproveEnv !== undefined
+        ? parseCsv(alwaysApproveEnv)
+        : [...config.always_approve];
+    const denylistEnv = env['EDGE_CMD_GATE_DENYLIST'];
+    const denylist = denylistEnv !== undefined ? parseCsv(denylistEnv) : [...config.denylist];
+    return { mode, allowlist, always_approve, denylist, timeout_s };
+}