nexus-agentd 0.1.0

package/dist/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { startAgentd } from './index.js';
+const configPath = resolveConfigPath(process.argv.slice(2));
+const runtime = await startAgentd(configPath);
+const address = runtime.server.address();
+const label = typeof address === 'object' && address
+    ? `${address.address}:${address.port}`
+    : String(address);
+console.log(`nexus-agentd listening on ${label}`);
+let closing = false;
+const close = async () => {
+    if (closing)
+        return;
+    closing = true;
+    await runtime.close();
+};
+process.once('SIGINT', () => void close().finally(() => process.exit(0)));
+process.once('SIGTERM', () => void close().finally(() => process.exit(0)));
+function resolveConfigPath(args) {
+    const index = args.indexOf('--config');
+    const value = index >= 0 ? args[index + 1] : process.env.NEXUS_AGENTD_CONFIG;
+    return path.resolve(value || 'nexus-agentd.json');
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import { type AgentdConfig } from './types.js';
+export declare function loadAgentdConfig(filePath: string): Promise<AgentdConfig>;
+export declare function resolveSecret(value: string): string;

package/dist/config.js

@@ -0,0 +1,115 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { agentdDriverKinds } from './types.js';
+export async function loadAgentdConfig(filePath) {
+    const absolute = path.resolve(filePath);
+    const raw = await readFile(absolute, 'utf8');
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid nexus-agentd config JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(value))
+        throw new Error('nexus-agentd config root must be an object');
+    const listen = isRecord(value.listen) ? value.listen : {};
+    const host = stringValue(listen.host) || '127.0.0.1';
+    const port = numberValue(listen.port, 8787, 1, 65535);
+    const authToken = resolveSecret(stringValue(value.authToken));
+    if (!authToken)
+        throw new Error('nexus-agentd authToken is required');
+    const workspaceRoots = arrayOfStrings(value.workspaceRoots);
+    if (!workspaceRoots.length) {
+        throw new Error('nexus-agentd workspaceRoots must contain at least one path');
+    }
+    if (!isRecord(value.agents)) {
+        throw new Error('nexus-agentd agents must be an object');
+    }
+    const agents = {};
+    for (const [id, input] of Object.entries(value.agents)) {
+        if (!isRecord(input))
+            throw new Error(`Agent config must be an object: ${id}`);
+        const driver = stringValue(input.driver) || inferDriver(id);
+        if (!isAgentdDriverKind(driver)) {
+            throw new Error(`Unsupported nexus-agentd driver: ${driver || id}`);
+        }
+        const permissionPolicy = stringValue(input.permissionPolicy) || 'ask';
+        if (permissionPolicy !== 'ask' && permissionPolicy !== 'deny') {
+            throw new Error(`Invalid permissionPolicy for ${id}`);
+        }
+        agents[id] = {
+            driver,
+            name: optionalString(input.name),
+            description: optionalString(input.description),
+            enabled: input.enabled !== false,
+            command: optionalString(input.command),
+            args: input.args === undefined ? undefined : arrayOfStrings(input.args),
+            inheritEnv: input.inheritEnv === undefined
+                ? undefined
+                : arrayOfStrings(input.inheritEnv),
+            env: recordOfStrings(input.env),
+            permissionPolicy,
+            permissionTimeoutMs: numberValue(input.permissionTimeoutMs, 15 * 60 * 1000, 1000, 24 * 60 * 60 * 1000)
+        };
+    }
+    return {
+        listen: { host, port },
+        authToken,
+        workspaceRoots,
+        maxRequestBytes: numberValue(value.maxRequestBytes, 1024 * 1024, 1024, 16 * 1024 * 1024),
+        maxEventsPerSession: numberValue(value.maxEventsPerSession, 2048, 64, 100_000),
+        maxOutputChars: numberValue(value.maxOutputChars, 512 * 1024, 16 * 1024, 16 * 1024 * 1024),
+        sessionTtlMs: numberValue(value.sessionTtlMs, 24 * 60 * 60 * 1000, 60_000, 30 * 24 * 60 * 60 * 1000),
+        agents
+    };
+}
+export function resolveSecret(value) {
+    if (!value.startsWith('env:'))
+        return value;
+    const name = value.slice(4).trim();
+    if (!name)
+        throw new Error('Secret environment variable name is empty');
+    const secret = process.env[name];
+    if (!secret)
+        throw new Error(`Secret environment variable is missing: ${name}`);
+    return secret;
+}
+function inferDriver(id) {
+    const value = id.trim().toLowerCase();
+    return isAgentdDriverKind(value) ? value : '';
+}
+function isAgentdDriverKind(value) {
+    return agentdDriverKinds.includes(value);
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function optionalString(value) {
+    return stringValue(value) || undefined;
+}
+function arrayOfStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map(stringValue).filter(Boolean);
+}
+function recordOfStrings(value) {
+    if (!isRecord(value))
+        return undefined;
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== 'string')
+            continue;
+        result[key] = item;
+    }
+    return result;
+}
+function numberValue(value, fallback, min, max) {
+    const number = Number(value);
+    if (!Number.isFinite(number))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.trunc(number)));
+}

package/dist/drivers/claude.d.ts

@@ -0,0 +1,2 @@
+import type { AgentdDriverConfig } from '../types.js';
+export declare function createClaudeDriver(id: string, config: AgentdDriverConfig): import("./types.js").AgentDriver;

package/dist/drivers/claude.js

@@ -0,0 +1,9 @@
+import { createStdioAcpDriver } from './stdio.js';
+export function createClaudeDriver(id, config) {
+    return createStdioAcpDriver(id, config, {
+        name: 'Claude Code',
+        description: 'Claude Code through the official Claude Agent ACP adapter',
+        command: 'claude-agent-acp',
+        args: []
+    });
+}

package/dist/drivers/codex.d.ts

@@ -0,0 +1,2 @@
+import type { AgentdDriverConfig } from '../types.js';
+export declare function createCodexDriver(id: string, config: AgentdDriverConfig): import("./types.js").AgentDriver;

package/dist/drivers/codex.js

@@ -0,0 +1,9 @@
+import { createStdioAcpDriver } from './stdio.js';
+export function createCodexDriver(id, config) {
+    return createStdioAcpDriver(id, config, {
+        name: 'Codex',
+        description: 'Codex CLI through the official Codex ACP adapter',
+        command: 'codex-acp',
+        args: []
+    });
+}

package/dist/drivers/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentdConfig } from '../types.js';
+import type { AgentDriver } from './types.js';
+export declare function createDriverRegistry(config: AgentdConfig): Map<string, AgentDriver>;
+export type { AgentDriver } from './types.js';

package/dist/drivers/index.js

@@ -0,0 +1,30 @@
+import { createClaudeDriver } from './claude.js';
+import { createCodexDriver } from './codex.js';
+import { createOpenCodeDriver } from './opencode.js';
+import { createOpenClawDriver } from './openclaw.js';
+import { createPiDriver } from './pi.js';
+export function createDriverRegistry(config) {
+    const drivers = new Map();
+    for (const [id, driver] of Object.entries(config.agents)) {
+        if (driver.enabled === false)
+            continue;
+        switch (driver.driver) {
+            case 'opencode':
+                drivers.set(id, createOpenCodeDriver(id, driver));
+                break;
+            case 'claude':
+                drivers.set(id, createClaudeDriver(id, driver));
+                break;
+            case 'codex':
+                drivers.set(id, createCodexDriver(id, driver));
+                break;
+            case 'pi':
+                drivers.set(id, createPiDriver(id, driver));
+                break;
+            case 'openclaw':
+                drivers.set(id, createOpenClawDriver(id, driver));
+                break;
+        }
+    }
+    return drivers;
+}

package/dist/drivers/openclaw.d.ts

@@ -0,0 +1,2 @@
+import type { AgentdDriverConfig } from '../types.js';
+export declare function createOpenClawDriver(id: string, config: AgentdDriverConfig): import("./types.js").AgentDriver;

package/dist/drivers/openclaw.js

@@ -0,0 +1,13 @@
+import { createStdioAcpDriver } from './stdio.js';
+export function createOpenClawDriver(id, config) {
+    return createStdioAcpDriver(id, config, {
+        name: 'OpenClaw',
+        description: 'OpenClaw Gateway through its native ACP stdio bridge',
+        command: 'openclaw',
+        args: ['acp'],
+        env: {
+            OPENCLAW_HIDE_BANNER: '1',
+            OPENCLAW_SUPPRESS_NOTES: '1'
+        }
+    });
+}

package/dist/drivers/opencode.d.ts

@@ -0,0 +1,2 @@
+import type { AgentdDriverConfig } from '../types.js';
+export declare function createOpenCodeDriver(id: string, config: AgentdDriverConfig): import("./types.js").AgentDriver;

package/dist/drivers/opencode.js

@@ -0,0 +1,9 @@
+import { createStdioAcpDriver } from './stdio.js';
+export function createOpenCodeDriver(id, config) {
+    return createStdioAcpDriver(id, config, {
+        name: 'OpenCode',
+        description: 'OpenCode Coding Agent through its native ACP stdio server',
+        command: 'opencode',
+        args: ['acp']
+    });
+}

package/dist/drivers/pi.d.ts

@@ -0,0 +1,13 @@
+import type { AgentdDriverConfig } from '../types.js';
+export declare function createPiDriver(id: string, config: AgentdDriverConfig): {
+    probe(): Promise<import("../types.js").AgentdAgentView>;
+    id: string;
+    name: string;
+    description?: string;
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    permissionPolicy: import("../types.js").PermissionPolicy;
+    permissionTimeoutMs: number;
+    spawn(workspace: string): import("child_process").ChildProcessWithoutNullStreams;
+};

package/dist/drivers/pi.js

@@ -0,0 +1,31 @@
+import { createStdioAcpDriver, probeCommand } from './stdio.js';
+export function createPiDriver(id, config) {
+    const driver = createStdioAcpDriver(id, config, {
+        name: 'Pi',
+        description: 'Pi coding agent through the pi-acp adapter',
+        command: 'pi-acp',
+        args: []
+    });
+    const probeAdapter = driver.probe.bind(driver);
+    return {
+        ...driver,
+        async probe() {
+            const adapter = await probeAdapter();
+            if (!adapter.ready)
+                return adapter;
+            const command = driver.env.PI_ACP_PI_COMMAND || 'pi';
+            try {
+                const version = await probeCommand(command, ['--version'], driver.env, 'Pi runtime');
+                return { ...adapter, version };
+            }
+            catch (error) {
+                return {
+                    ...adapter,
+                    ready: false,
+                    version: undefined,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        }
+    };
+}

package/dist/drivers/stdio.d.ts

@@ -0,0 +1,13 @@
+import type { AgentdDriverConfig } from '../types.js';
+import type { AgentDriver } from './types.js';
+export interface StdioAcpDriverDefaults {
+    name: string;
+    description: string;
+    command: string;
+    args: string[];
+    probeArgs?: string[];
+    env?: Record<string, string>;
+}
+export declare function createStdioAcpDriver(id: string, config: AgentdDriverConfig, defaults: StdioAcpDriverDefaults): AgentDriver;
+export declare function buildEnvironment(config: AgentdDriverConfig, defaults?: Record<string, string>): NodeJS.ProcessEnv;
+export declare function probeCommand(command: string, args: string[], env: NodeJS.ProcessEnv, label: string): Promise<string>;

package/dist/drivers/stdio.js

@@ -0,0 +1,114 @@
+import { spawn } from 'node:child_process';
+import { resolveSecret } from '../config.js';
+const BASE_ENV_KEYS = [
+    'PATH',
+    'HOME',
+    'USER',
+    'XDG_CONFIG_HOME',
+    'XDG_DATA_HOME',
+    'SHELL',
+    'TMP',
+    'TMPDIR',
+    'TEMP',
+    'LANG',
+    'LC_ALL'
+];
+export function createStdioAcpDriver(id, config, defaults) {
+    const command = config.command || defaults.command;
+    const args = config.args === undefined ? [...defaults.args] : [...config.args];
+    const env = buildEnvironment(config, defaults.env);
+    const name = config.name || defaults.name;
+    const description = config.description || defaults.description;
+    return {
+        id,
+        name,
+        description,
+        command,
+        args,
+        env,
+        permissionPolicy: config.permissionPolicy || 'ask',
+        permissionTimeoutMs: config.permissionTimeoutMs || 15 * 60 * 1000,
+        async probe() {
+            try {
+                const version = await probeCommand(command, defaults.probeArgs || ['--version'], env, name);
+                return {
+                    id,
+                    name,
+                    description,
+                    protocol: 'acp',
+                    ready: true,
+                    version
+                };
+            }
+            catch (error) {
+                return {
+                    id,
+                    name,
+                    description,
+                    protocol: 'acp',
+                    ready: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+        },
+        spawn(workspace) {
+            return spawn(command, args, {
+                cwd: workspace,
+                env,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+    };
+}
+export function buildEnvironment(config, defaults = {}) {
+    const result = {};
+    for (const key of new Set([...BASE_ENV_KEYS, ...(config.inheritEnv || [])])) {
+        const value = process.env[key];
+        if (value !== undefined)
+            result[key] = value;
+    }
+    Object.assign(result, defaults);
+    for (const [key, value] of Object.entries(config.env || {})) {
+        result[key] = resolveSecret(value);
+    }
+    return result;
+}
+export function probeCommand(command, args, env, label) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let output = '';
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(output.trim().split(/\r?\n/)[0] || 'unknown');
+        };
+        const timer = setTimeout(() => {
+            child.kill();
+            finish(new Error(`${label} probe timed out`));
+        }, 5000);
+        child.stdout.on('data', (chunk) => {
+            output = `${output}${String(chunk)}`.slice(-8192);
+        });
+        child.stderr.on('data', (chunk) => {
+            output = `${output}${String(chunk)}`.slice(-8192);
+        });
+        child.once('error', (error) => finish(error));
+        child.once('exit', (code, signal) => {
+            if (code === 0)
+                finish();
+            else {
+                finish(new Error(output.trim() ||
+                    `${label} probe exited with ${signal || code || 'unknown'}`));
+            }
+        });
+    });
+}

package/dist/drivers/types.d.ts

@@ -0,0 +1,14 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+import type { AgentdAgentView, PermissionPolicy } from '../types.js';
+export interface AgentDriver {
+    id: string;
+    name: string;
+    description?: string;
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    permissionPolicy: PermissionPolicy;
+    permissionTimeoutMs: number;
+    probe(): Promise<AgentdAgentView>;
+    spawn(workspace: string): ChildProcessWithoutNullStreams;
+}

package/dist/drivers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/events.d.ts

@@ -0,0 +1,13 @@
+import type { AgentdEvent, AgentdEventType } from './types.js';
+export declare class SessionEventLog {
+    private readonly sessionId;
+    private readonly maxEvents;
+    private sequence;
+    private events;
+    private listeners;
+    constructor(sessionId: string, maxEvents: number);
+    append(type: AgentdEventType, data?: unknown): AgentdEvent;
+    after(id?: string): AgentdEvent[];
+    subscribe(listener: (event: AgentdEvent) => void): () => boolean;
+    get lastId(): string | undefined;
+}

package/dist/events.js

@@ -0,0 +1,40 @@
+export class SessionEventLog {
+    sessionId;
+    maxEvents;
+    sequence = 0;
+    events = [];
+    listeners = new Set();
+    constructor(sessionId, maxEvents) {
+        this.sessionId = sessionId;
+        this.maxEvents = maxEvents;
+    }
+    append(type, data) {
+        const event = {
+            id: String(++this.sequence),
+            sessionId: this.sessionId,
+            type,
+            timestamp: Date.now(),
+            data
+        };
+        this.events.push(event);
+        if (this.events.length > this.maxEvents) {
+            this.events.splice(0, this.events.length - this.maxEvents);
+        }
+        for (const listener of this.listeners)
+            listener(structuredClone(event));
+        return event;
+    }
+    after(id) {
+        const sequence = Number(id || 0);
+        return this.events
+            .filter((event) => Number(event.id) > sequence)
+            .map((event) => structuredClone(event));
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    get lastId() {
+        return this.events.at(-1)?.id;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Server } from 'node:http';
+import { SessionManager } from './session.js';
+export declare function startAgentd(configPath: string): Promise<{
+    config: import("./types.js").AgentdConfig;
+    server: Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    sessions: SessionManager;
+    close(): Promise<void>;
+}>;
+export * from './config.js';
+export * from './server.js';
+export * from './session.js';
+export * from './types.js';
+export * from './workspace.js';

package/dist/index.js

@@ -0,0 +1,48 @@
+import { loadAgentdConfig } from './config.js';
+import { createDriverRegistry } from './drivers/index.js';
+import { createAgentdServer } from './server.js';
+import { SessionManager } from './session.js';
+import { WorkspacePolicy } from './workspace.js';
+export async function startAgentd(configPath) {
+    const config = await loadAgentdConfig(configPath);
+    const workspacePolicy = await WorkspacePolicy.create(config.workspaceRoots);
+    const sessions = new SessionManager(config, workspacePolicy, createDriverRegistry(config));
+    sessions.startCleanup();
+    const server = createAgentdServer(config, sessions);
+    await listen(server, config.listen.port, config.listen.host);
+    return {
+        config,
+        server,
+        sessions,
+        async close() {
+            await closeServer(server);
+            await sessions.shutdown();
+        }
+    };
+}
+function listen(server, port, host) {
+    return new Promise((resolve, reject) => {
+        const error = (value) => {
+            server.off('listening', listening);
+            reject(value);
+        };
+        const listening = () => {
+            server.off('error', error);
+            resolve();
+        };
+        server.once('error', error);
+        server.once('listening', listening);
+        server.listen(port, host);
+    });
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+        server.closeIdleConnections?.();
+    });
+}
+export * from './config.js';
+export * from './server.js';
+export * from './session.js';
+export * from './types.js';
+export * from './workspace.js';

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import http from 'node:http';
+import type { AgentdConfig } from './types.js';
+import { SessionManager } from './session.js';
+export declare function createAgentdServer(config: AgentdConfig, sessions: SessionManager): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;