@agent-relay/factory 0.0.0 → 0.1.1

package/dist/fleet/internal-fleet-client.d.ts

@@ -0,0 +1,85 @@
+import type { BrokerEvent, ListAgent, SendMessageInput, SpawnPtyInput } from '@agent-relay/harness-driver';
+import type { AgentMessage, AgentPidResolution, Capability, FleetClient, RosterEntry, SendInput, SpawnInput, SpawnResult } from '../ports/fleet';
+import type { Logger } from '../ports/system';
+type SpawnedHandleLike = {
+    name: string;
+    sessionId?: string;
+    session_ref?: string;
+    sessionRef?: string;
+    pid?: number;
+};
+type HarnessEventListener = (event: BrokerEvent) => void;
+type DriverAgentLike = {
+    name: string;
+    sessionId?: string;
+    pid?: number;
+};
+type DriverDeliveryEventLike = BrokerEvent;
+type AgentRelayMcpCommand = {
+    command: string;
+    args: string[];
+};
+export interface HarnessDriverClientLike {
+    readonly brokerPid?: number;
+    spawnPty(input: SpawnPtyInput): Promise<SpawnedHandleLike>;
+    release(name: string, reason?: string): Promise<{
+        name: string;
+    }>;
+    listAgents(): Promise<Array<Pick<ListAgent, 'name'> & {
+        pid?: number;
+    }>>;
+    sendMessage(input: SendMessageInput): Promise<{
+        event_id: string;
+        targets?: string[];
+    }>;
+    sendInput(name: string, data: string): Promise<unknown>;
+    connectEvents?(sinceSeq?: number): void;
+    disconnect?(): void;
+    onEvent?(listener: HarnessEventListener): () => void;
+    addListener?(event: 'agentExited', listener: (agent: DriverAgentLike) => void): () => void;
+    addListener?(event: 'deliveryUpdate', listener: (event: DriverDeliveryEventLike) => void): () => void;
+}
+export interface InternalFleetClientOptions {
+    client?: HarnessDriverClientLike;
+    cwd?: string;
+    connectionPath?: string;
+    resumeCapability?: Capability;
+    logger?: Logger;
+    resolveAgentRelayMcpCommand?: () => AgentRelayMcpCommand | undefined;
+}
+type AgentExitListener = (name: string, reason?: string) => void;
+type DeliveryFailedListener = (info: {
+    to: string;
+    msgId?: string;
+    reason?: string;
+}) => void;
+type AgentMessageListener = (message: AgentMessage) => void;
+export declare class InternalFleetClient implements FleetClient {
+    #private;
+    constructor(options?: InternalFleetClientOptions);
+    spawn(input: SpawnInput): Promise<SpawnResult>;
+    resume(input: {
+        name?: string;
+        sessionRef: string;
+        node?: 'self' | string;
+        capability?: Capability;
+    }): Promise<SpawnResult>;
+    release(name: string, reason?: string): Promise<void>;
+    roster(): Promise<RosterEntry>;
+    protectedPids(): Promise<number[]>;
+    resolveAgentPid(name: string): Promise<AgentPidResolution>;
+    sendMessage(input: SendInput): Promise<void>;
+    waitForInjected(input: SendInput, opts?: {
+        timeoutMs?: number;
+    }): Promise<{
+        eventId: string;
+        targets: string[];
+    }>;
+    sendInput(name: string, data: string): Promise<void>;
+    onDeliveryFailed(listener: DeliveryFailedListener): () => void;
+    onAgentMessage(listener: AgentMessageListener): () => void;
+    onAgentExit(listener: AgentExitListener): () => void;
+    dispose(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=internal-fleet-client.d.ts.map

package/dist/fleet/internal-fleet-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-fleet-client.d.ts","sourceRoot":"","sources":["../../src/fleet/internal-fleet-client.ts"],"names":[],"mappings":"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"}

package/dist/fleet/internal-fleet-client.js

@@ -0,0 +1,575 @@
+import { HarnessDriverClient } from '@agent-relay/harness-driver';
+import { accessSync, constants } from 'node:fs';
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const requireForResolve = createRequire(import.meta.url);
+const capabilityCli = {
+    'spawn:claude': 'claude',
+    'spawn:codex': 'codex',
+};
+const selfNode = {
+    name: 'self',
+    capabilities: ['spawn:claude', 'spawn:codex'],
+    live: true,
+};
+const PID_RESOLVE_ATTEMPTS = 3;
+const PID_RESOLVE_BACKOFF_MS = 75;
+export class InternalFleetClient {
+    #client;
+    #cwd;
+    #connectionPath;
+    #resumeCapability;
+    #logger;
+    #resolveAgentRelayMcpCommand;
+    #agentExitListeners = new Set();
+    #deliveryFailedListeners = new Set();
+    #agentMessageListeners = new Set();
+    #eventUnsubscribers = [];
+    #seenEvents = [];
+    #seenEventKeys = new Set();
+    #pendingInjected = new Map();
+    #injectedEventIds = [];
+    #injectedEventIdSet = new Set();
+    #failedDeliveries = new Map();
+    #failedDeliveryIds = [];
+    #exitedAgentNames = new Set();
+    #suppressedDuplicateEvents = 0;
+    #suppressedDuplicateAgentExits = 0;
+    #missingIdentityEvents = 0;
+    #subscribed = false;
+    #disposed = false;
+    constructor(options = {}) {
+        this.#cwd = options.cwd;
+        this.#connectionPath = options.connectionPath;
+        this.#resumeCapability = options.resumeCapability ?? 'spawn:codex';
+        this.#logger = options.logger;
+        this.#resolveAgentRelayMcpCommand = options.resolveAgentRelayMcpCommand ?? resolveAgentRelayMcpCommand;
+        this.#client = options.client ?? HarnessDriverClient.connect({ cwd: options.cwd, connectionPath: options.connectionPath });
+    }
+    async spawn(input) {
+        assertSelfNode(input.node);
+        const spawnInput = this.#withAgentRelayMcpHarness({
+            name: input.name,
+            cli: capabilityCli[input.capability],
+            channels: input.channel ? [input.channel] : undefined,
+            task: input.task,
+            model: input.model,
+            cwd: input.cwd ?? this.#cwd,
+            restartPolicy: input.restartPolicy,
+            continueFrom: input.sessionRef,
+        });
+        const handle = await this.#client.spawnPty(spawnInput);
+        this.#clearAgentExitLatch(handle.name);
+        return spawnResultFrom(handle);
+    }
+    async resume(input) {
+        assertSelfNode(input.node);
+        const spawnInput = this.#withAgentRelayMcpHarness({
+            name: input.name ?? input.sessionRef,
+            // followups [fleet→W6]: W6 owns resume-vs-respawn and passes the per-agent capability.
+            cli: capabilityCli[input.capability ?? this.#resumeCapability],
+            cwd: this.#cwd,
+            continueFrom: input.sessionRef,
+        });
+        const handle = await this.#client.spawnPty(spawnInput);
+        this.#clearAgentExitLatch(handle.name);
+        return { ...spawnResultFrom(handle), sessionRef: sessionRefFrom(handle) ?? input.sessionRef };
+    }
+    #withAgentRelayMcpHarness(input) {
+        if (input.harnessConfig || (input.cli !== 'codex' && input.cli !== 'claude')) {
+            return input;
+        }
+        const command = this.#resolveAgentRelayMcpCommand();
+        if (!command) {
+            this.#logger?.warn?.('[factory-sdk] agent-relay MCP command not found; spawning without MCP injection', {
+                agent: input.name,
+                cli: input.cli,
+            });
+            return input;
+        }
+        return {
+            ...input,
+            harnessConfig: buildRelayMcpHarnessConfig(input, command),
+        };
+    }
+    async release(name, reason) {
+        await this.#client.release(name, reason);
+    }
+    async roster() {
+        const agents = await this.#client.listAgents();
+        return {
+            agents: agents.map((agent) => ({ name: agent.name })),
+            nodes: [selfNode],
+        };
+    }
+    async protectedPids() {
+        const pids = new Set();
+        if (Number.isInteger(this.#client.brokerPid) && this.#client.brokerPid > 0) {
+            pids.add(this.#client.brokerPid);
+        }
+        const connectionPid = await this.#connectionFilePid();
+        if (connectionPid) {
+            pids.add(connectionPid);
+        }
+        return [...pids].sort((a, b) => a - b);
+    }
+    async resolveAgentPid(name) {
+        try {
+            let sawAgent = false;
+            for (let attempt = 1; attempt <= PID_RESOLVE_ATTEMPTS; attempt += 1) {
+                const agent = (await this.#client.listAgents()).find((candidate) => candidate.name === name);
+                if (agent) {
+                    sawAgent = true;
+                }
+                if (typeof agent?.pid === 'number') {
+                    return { status: 'found', pid: agent.pid };
+                }
+                if (attempt < PID_RESOLVE_ATTEMPTS) {
+                    await sleep(PID_RESOLVE_BACKOFF_MS);
+                }
+            }
+            return sawAgent ? { status: 'unresolved' } : { status: 'missing' };
+        }
+        catch (error) {
+            this.#logger?.warn?.('[factory-sdk] unable to resolve spawned agent pid from roster', error);
+            return { status: 'unresolved' };
+        }
+    }
+    async #connectionFilePid() {
+        const path = this.#connectionPath ?? connectionPathForCwd(this.#cwd);
+        if (!path)
+            return undefined;
+        try {
+            const parsed = JSON.parse(await readFile(path, 'utf8'));
+            const pid = parsed.pid;
+            return typeof pid === 'number' && Number.isInteger(pid) && pid > 0 ? pid : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async sendMessage(input) {
+        await this.#client.sendMessage(messageInputFrom(input));
+    }
+    async waitForInjected(input, opts) {
+        this.#ensureEventSubscription();
+        const result = await this.#client.sendMessage(messageInputFrom(input));
+        const eventId = result.event_id;
+        const targets = result.targets ?? [];
+        if (this.#injectedEventIdSet.has(eventId)) {
+            return { eventId, targets };
+        }
+        const priorFailure = this.#failedDeliveries.get(eventId);
+        if (priorFailure) {
+            throw priorFailure;
+        }
+        return await new Promise((resolve, reject) => {
+            const timeoutMs = opts?.timeoutMs ?? 30_000;
+            const timeout = setTimeout(() => {
+                this.#pendingInjected.delete(eventId);
+                reject(new Error(`Timed out waiting for delivery_injected for ${eventId}`));
+            }, timeoutMs);
+            this.#pendingInjected.set(eventId, {
+                targets,
+                timeout,
+                resolve,
+                reject,
+            });
+        });
+    }
+    async sendInput(name, data) {
+        await this.#client.sendInput(name, data);
+    }
+    onDeliveryFailed(listener) {
+        this.#ensureEventSubscription();
+        this.#deliveryFailedListeners.add(listener);
+        return () => {
+            this.#deliveryFailedListeners.delete(listener);
+        };
+    }
+    onAgentMessage(listener) {
+        this.#ensureEventSubscription();
+        this.#agentMessageListeners.add(listener);
+        return () => {
+            this.#agentMessageListeners.delete(listener);
+        };
+    }
+    onAgentExit(listener) {
+        this.#ensureEventSubscription();
+        this.#agentExitListeners.add(listener);
+        return () => {
+            this.#agentExitListeners.delete(listener);
+        };
+    }
+    async dispose() {
+        if (this.#disposed) {
+            return;
+        }
+        this.#disposed = true;
+        const pending = [...this.#pendingInjected.values()];
+        this.#pendingInjected.clear();
+        for (const entry of pending) {
+            clearTimeout(entry.timeout);
+            entry.reject(new Error('InternalFleetClient disposed before delivery was confirmed'));
+        }
+        for (const unsubscribe of this.#eventUnsubscribers.splice(0)) {
+            unsubscribe();
+        }
+        this.#agentExitListeners.clear();
+        this.#deliveryFailedListeners.clear();
+        this.#agentMessageListeners.clear();
+        this.#failedDeliveries.clear();
+        this.#failedDeliveryIds.length = 0;
+        this.#client.disconnect?.();
+        this.#subscribed = false;
+    }
+    #ensureEventSubscription() {
+        if (this.#subscribed) {
+            return;
+        }
+        this.#subscribed = true;
+        const offEvent = this.#client.onEvent?.((event) => this.#handleBrokerEvent(event));
+        if (offEvent)
+            this.#eventUnsubscribers.push(offEvent);
+        const offDeliveryUpdate = this.#client.addListener?.('deliveryUpdate', (event) => this.#handleBrokerEvent(event));
+        if (offDeliveryUpdate)
+            this.#eventUnsubscribers.push(offDeliveryUpdate);
+        const offAgentExited = this.#client.addListener?.('agentExited', (agent) => this.#emitAgentExit(agent.name, 'exited', {
+            key: `agentExited:${JSON.stringify(agent)}`,
+            hasStableId: false,
+        }));
+        if (offAgentExited)
+            this.#eventUnsubscribers.push(offAgentExited);
+        this.#client.connectEvents?.();
+    }
+    #handleBrokerEvent(event) {
+        if (event.kind === 'delivery_injected') {
+            this.#resolveInjected(event.event_id);
+            return;
+        }
+        if (event.kind === 'delivery_failed') {
+            this.#rejectInjected(event.event_id, event.reason);
+            this.#emitDeliveryFailed({
+                to: event.name,
+                msgId: event.event_id,
+                reason: event.reason,
+            }, eventIdentity(event));
+            return;
+        }
+        if (event.kind === 'message_delivery_failed') {
+            if (event.event_id) {
+                this.#rejectInjected(event.event_id, event.lastError);
+            }
+            this.#emitDeliveryFailed({
+                to: event.to,
+                msgId: event.event_id,
+                reason: event.lastError,
+            }, eventIdentity(event));
+            return;
+        }
+        if (event.kind === 'relay_inbound') {
+            this.#emitAgentMessage({
+                from: event.from,
+                target: event.target,
+                body: event.body,
+                threadId: event.thread_id,
+                eventId: event.event_id,
+            }, eventIdentity(event));
+            return;
+        }
+        if (event.kind === 'agent_exit') {
+            this.#emitAgentExit(event.name, event.reason, eventIdentity(event));
+            return;
+        }
+        if (event.kind === 'agent_exited') {
+            this.#emitAgentExit(event.name, event.reason ?? exitReason(event), eventIdentity(event));
+        }
+    }
+    #resolveInjected(eventId) {
+        rememberRecent(eventId, this.#injectedEventIds, this.#injectedEventIdSet);
+        const pending = this.#pendingInjected.get(eventId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.#pendingInjected.delete(eventId);
+        pending.resolve({ eventId, targets: pending.targets });
+    }
+    #rejectInjected(eventId, reason) {
+        const error = new Error(reason ? `Delivery failed for ${eventId}: ${reason}` : `Delivery failed for ${eventId}`);
+        this.#failedDeliveries.set(eventId, error);
+        this.#failedDeliveryIds.push(eventId);
+        if (this.#failedDeliveryIds.length > 500) {
+            const oldest = this.#failedDeliveryIds.shift();
+            if (oldest) {
+                this.#failedDeliveries.delete(oldest);
+            }
+        }
+        const pending = this.#pendingInjected.get(eventId);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timeout);
+        this.#pendingInjected.delete(eventId);
+        pending.reject(error);
+    }
+    #emitDeliveryFailed(info, identity) {
+        if (this.#rememberEvent(identity)) {
+            return;
+        }
+        for (const listener of this.#deliveryFailedListeners) {
+            listener(info);
+        }
+    }
+    #emitAgentMessage(message, identity) {
+        if (this.#rememberEvent(identity)) {
+            return;
+        }
+        for (const listener of this.#agentMessageListeners) {
+            listener(message);
+        }
+    }
+    #emitAgentExit(name, reason, identity) {
+        if (this.#rememberEvent(identity)) {
+            return;
+        }
+        if (this.#rememberAgentExit(name)) {
+            return;
+        }
+        for (const listener of this.#agentExitListeners) {
+            listener(name, reason);
+        }
+    }
+    #rememberAgentExit(name) {
+        if (this.#exitedAgentNames.has(name)) {
+            this.#suppressedDuplicateAgentExits += 1;
+            if (this.#suppressedDuplicateAgentExits <= 3 || this.#suppressedDuplicateAgentExits % 100 === 0) {
+                this.#logger?.debug?.('[factory-sdk] suppressed duplicate agent exit', {
+                    count: this.#suppressedDuplicateAgentExits,
+                    name,
+                });
+            }
+            return true;
+        }
+        this.#exitedAgentNames.add(name);
+        return false;
+    }
+    #clearAgentExitLatch(name) {
+        this.#exitedAgentNames.delete(name);
+    }
+    #rememberEvent(identity) {
+        const { key } = identity;
+        if (!identity.hasStableId) {
+            this.#missingIdentityEvents += 1;
+            if (this.#missingIdentityEvents === 1) {
+                this.#logger?.warn?.('[factory-sdk] broker event missing stable identity; deduping by full event content');
+            }
+        }
+        if (this.#seenEventKeys.has(key)) {
+            this.#suppressedDuplicateEvents += 1;
+            if (this.#suppressedDuplicateEvents <= 3 || this.#suppressedDuplicateEvents % 100 === 0) {
+                this.#logger?.debug?.('[factory-sdk] suppressed duplicate broker event', {
+                    count: this.#suppressedDuplicateEvents,
+                    key,
+                });
+            }
+            return true;
+        }
+        this.#seenEventKeys.add(key);
+        this.#seenEvents.push(key);
+        if (this.#seenEvents.length > 500) {
+            const oldest = this.#seenEvents.shift();
+            if (oldest) {
+                this.#seenEventKeys.delete(oldest);
+            }
+        }
+        return false;
+    }
+}
+function connectionPathForCwd(cwd) {
+    const stateDir = process.env.AGENT_RELAY_STATE_DIR;
+    if (stateDir)
+        return join(stateDir, 'connection.json');
+    return cwd ? join(cwd, '.agentworkforce', 'relay', 'connection.json') : undefined;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function assertSelfNode(node) {
+    if (node && node !== 'self') {
+        throw new Error(`InternalFleetClient only supports node 'self' tonight; received ${node}`);
+    }
+}
+function sessionRefFrom(handle) {
+    return handle.session_ref ?? handle.sessionRef ?? handle.sessionId;
+}
+function spawnResultFrom(handle, resolvedPid = handle.pid) {
+    const result = { name: handle.name };
+    const sessionRef = sessionRefFrom(handle);
+    if (sessionRef)
+        result.sessionRef = sessionRef;
+    if (typeof resolvedPid === 'number')
+        result.pid = resolvedPid;
+    return result;
+}
+function resolveAgentRelayMcpCommand() {
+    try {
+        const packageJsonPath = requireForResolve.resolve('agent-relay/package.json');
+        const cliPath = join(dirname(packageJsonPath), 'dist', 'cli', 'index.js');
+        accessSync(cliPath, constants.R_OK);
+        return { command: process.execPath, args: [cliPath, 'mcp'] };
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildRelayMcpHarnessConfig(input, command) {
+    const relayEnv = relayMcpEnv(input.name, input.agentToken);
+    return {
+        runtime: 'pty',
+        command: input.cli,
+        args: input.cli === 'claude'
+            ? claudeHarnessArgs(input, command, relayEnv)
+            : codexHarnessArgs(input, command, relayEnv),
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+        env: relayEnv,
+        metadata: {
+            factoryRelayMcp: true,
+            relayMcpCommand: command.command,
+            relayMcpArgs: command.args,
+        },
+    };
+}
+function claudeHarnessArgs(input, command, relayEnv) {
+    return [
+        ...modelArgs(input.model),
+        '--mcp-config',
+        JSON.stringify({
+            mcpServers: {
+                'agent-relay': stdioMcpServer(command, relayEnv),
+            },
+        }),
+        '--strict-mcp-config',
+        ...(input.args ?? []),
+        ...taskArgs(input.task),
+    ];
+}
+function codexHarnessArgs(input, command, relayEnv) {
+    const prefix = 'mcp_servers.agent-relay';
+    return [
+        ...modelArgs(stripProviderPrefix(input.model)),
+        '--config',
+        `${prefix}.command=${tomlString(command.command)}`,
+        '--config',
+        `${prefix}.args=${tomlArray(command.args)}`,
+        '--config',
+        `${prefix}.env=${tomlInlineTable(relayEnv)}`,
+        ...(input.args ?? []),
+        ...taskArgs(input.task),
+    ];
+}
+function stdioMcpServer(command, relayEnv) {
+    return {
+        type: 'stdio',
+        command: command.command,
+        args: command.args,
+        env: relayEnv,
+    };
+}
+function relayMcpEnv(agentName, agentToken) {
+    const env = {
+        RELAY_AGENT_NAME: agentName,
+        RELAY_AGENT_TYPE: 'agent',
+        RELAY_STRICT_AGENT_NAME: '1',
+    };
+    const workspaceKey = nonEmpty(process.env.RELAY_WORKSPACE_KEY) ??
+        nonEmpty(process.env.AGENT_RELAY_WORKSPACE_KEY) ??
+        relayWorkspaceKeyFromApiKey(process.env.RELAY_API_KEY);
+    if (workspaceKey) {
+        env.RELAY_WORKSPACE_KEY = workspaceKey;
+        env.RELAY_API_KEY = workspaceKey;
+    }
+    const baseUrl = nonEmpty(process.env.RELAY_BASE_URL);
+    if (baseUrl)
+        env.RELAY_BASE_URL = baseUrl;
+    const defaultWorkspace = nonEmpty(process.env.RELAY_DEFAULT_WORKSPACE);
+    if (defaultWorkspace)
+        env.RELAY_DEFAULT_WORKSPACE = defaultWorkspace;
+    const workspacesJson = nonEmpty(process.env.RELAY_WORKSPACES_JSON);
+    if (workspacesJson)
+        env.RELAY_WORKSPACES_JSON = workspacesJson;
+    const relayAgentToken = nonEmpty(agentToken);
+    if (relayAgentToken)
+        env.RELAY_AGENT_TOKEN = relayAgentToken;
+    return env;
+}
+function modelArgs(model) {
+    return model ? ['--model', model] : [];
+}
+function taskArgs(task) {
+    return task ? [task] : [];
+}
+function stripProviderPrefix(model) {
+    if (!model)
+        return undefined;
+    const idx = model.indexOf('/');
+    return idx >= 0 ? model.slice(idx + 1) : model;
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(', ')}]`;
+}
+function tomlInlineTable(values) {
+    return `{ ${Object.entries(values)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, value]) => `${tomlString(key)} = ${tomlString(value)}`)
+        .join(', ')} }`;
+}
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed || undefined;
+}
+function relayWorkspaceKeyFromApiKey(value) {
+    const trimmed = nonEmpty(value);
+    return trimmed?.startsWith('rk_live_') ? trimmed : undefined;
+}
+function messageInputFrom(input) {
+    return {
+        to: input.to,
+        text: input.text,
+        from: input.from,
+        data: input.data,
+    };
+}
+function eventIdentity(event) {
+    const record = event;
+    const stable = record.event_id ?? record.delivery_id;
+    return {
+        key: `${event.kind}:${stable ?? ''}:${JSON.stringify(event)}`,
+        hasStableId: Boolean(stable),
+    };
+}
+function rememberRecent(value, values, set) {
+    if (set.has(value)) {
+        return;
+    }
+    set.add(value);
+    values.push(value);
+    if (values.length > 500) {
+        const oldest = values.shift();
+        if (oldest) {
+            set.delete(oldest);
+        }
+    }
+}
+function exitReason(event) {
+    if (event.signal) {
+        return `signal:${event.signal}`;
+    }
+    if (typeof event.code === 'number') {
+        return `code:${event.code}`;
+    }
+    return 'exited';
+}
+//# sourceMappingURL=internal-fleet-client.js.map