@ai-devkit/agent-manager 0.28.1 → 0.30.0

package/src/durable/ClaudePrintAgentService.ts

@@ -1,94 +0,0 @@
-import type { DurableAgent, ProcessIdentity } from './DurableAgent.js';
-import { ClaudePrintError, DurableAgentNotFoundError } from './DurableAgent.js';
-import { ClaudeCliProbe } from './ClaudeCliProbe.js';
-import { ClaudePrintRunner, type ClaudePrintRunResult } from './ClaudePrintRunner.js';
-import { DurableAgentRepository, type CreateDurableAgentInput, type DurableRunCompletion } from './DurableAgentRepository.js';
-
-interface RepositoryLike {
-    create(input: CreateDurableAgentInput): Promise<DurableAgent>;
-    list(): Promise<DurableAgent[]>;
-    resolve(reference: string): Promise<DurableAgent | DurableAgent[] | null>;
-    acquireRun(id: string): Promise<{ agent: DurableAgent; token: string }>;
-    recordProviderProcess(id: string, token: string, identity: ProcessIdentity): Promise<void>;
-    completeRun(id: string, token: string, result: DurableRunCompletion): Promise<DurableAgent>;
-}
-
-interface ProbeLike { validate(): Promise<{ executable: string; version: string }> }
-interface RunnerLike { run(request: Parameters<ClaudePrintRunner['run']>[0]): Promise<ClaudePrintRunResult> }
-
-export interface ClaudePrintAgentServiceOptions {
-    repository?: RepositoryLike;
-    probe?: ProbeLike;
-    runner?: RunnerLike;
-    executable?: string;
-}
-
-export interface ClaudePrintSendResult extends ClaudePrintRunResult {
-    agentId: string;
-    agentName: string;
-}
-
-export class ClaudePrintAgentService {
-    readonly repository: RepositoryLike;
-    private readonly probe: ProbeLike;
-    private readonly runner: RunnerLike;
-    private readonly executable?: string;
-
-    constructor(options: ClaudePrintAgentServiceOptions = {}) {
-        this.repository = options.repository ?? new DurableAgentRepository();
-        this.probe = options.probe ?? new ClaudeCliProbe();
-        this.runner = options.runner ?? new ClaudePrintRunner();
-        this.executable = options.executable;
-    }
-
-    async create(input: CreateDurableAgentInput): Promise<DurableAgent> {
-        await this.probe.validate();
-        return this.repository.create(input);
-    }
-
-    async send(reference: string, prompt: string): Promise<ClaudePrintSendResult> {
-        const resolved = await this.repository.resolve(reference);
-        if (!resolved) throw new DurableAgentNotFoundError(reference);
-        if (Array.isArray(resolved)) {
-            throw new ClaudePrintError(`Multiple durable agents match "${reference}".`, 'DURABLE_AGENT_AMBIGUOUS');
-        }
-        const acquired = await this.repository.acquireRun(resolved.id);
-        try {
-            const result = await this.runner.run({
-                agent: acquired.agent,
-                prompt,
-                executable: this.executable,
-                firstRun: acquired.agent.sessionHealth === 'uninitialized',
-                onSpawn: (identity) => this.repository.recordProviderProcess(resolved.id, acquired.token, identity),
-            });
-            await this.repository.completeRun(resolved.id, acquired.token, {
-                status: 'succeeded',
-                exitCode: result.exitCode,
-                summary: sanitize(result.result, 4096),
-                sessionHealth: 'healthy',
-            });
-            return { ...result, agentId: resolved.id, agentName: resolved.name };
-        } catch (error) {
-            const failure = error instanceof Error ? error : new Error(String(error));
-            const sessionHealth = error instanceof ClaudePrintError && error.code === 'CLAUDE_SESSION_MISMATCH'
-                ? 'mismatch' as const
-                : 'unknown' as const;
-            await this.repository.completeRun(resolved.id, acquired.token, {
-                status: 'failed',
-                exitCode: null,
-                summary: sanitize(failure.message, 4096),
-                sessionHealth,
-            });
-            throw error;
-        }
-    }
-}
-
-function sanitize(value: string, max: number): string {
-    return Array.from(value, (character) => {
-        const code = character.charCodeAt(0);
-        return (code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31) || code === 127)
-            ? ' '
-            : character;
-    }).join('').trim().slice(0, max);
-}

package/src/durable/ClaudePrintRunner.ts

@@ -1,139 +0,0 @@
-import { spawn as nodeSpawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'child_process';
-import type { DurableAgent, ProcessIdentity } from './DurableAgent.js';
-import { ClaudePrintError } from './DurableAgent.js';
-import { LocalProcessInspector, type ProcessInspector } from './DurableAgentRepository.js';
-
-type Spawn = (
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithoutStdio & { stdio: ['pipe', 'pipe', 'pipe'] },
-) => ChildProcessWithoutNullStreams;
-
-export interface ClaudePrintRunRequest {
-    agent: DurableAgent;
-    prompt: string;
-    executable?: string;
-    firstRun: boolean;
-    onSpawn(identity: ProcessIdentity): Promise<void>;
-}
-
-export interface ClaudePrintRunResult {
-    sessionId: string;
-    result: string;
-    exitCode: number;
-}
-
-export interface ClaudePrintRunnerOptions {
-    spawn?: Spawn;
-    processInspector?: ProcessInspector;
-    maxLineBytes?: number;
-}
-
-export class ClaudePrintRunner {
-    private readonly spawn: Spawn;
-    private readonly processInspector: ProcessInspector;
-    private readonly maxLineBytes: number;
-
-    constructor(options: ClaudePrintRunnerOptions = {}) {
-        this.spawn = options.spawn ?? (nodeSpawn as Spawn);
-        this.processInspector = options.processInspector ?? new LocalProcessInspector();
-        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
-    }
-
-    async run(request: ClaudePrintRunRequest): Promise<ClaudePrintRunResult> {
-        const sessionArgs = request.firstRun
-            ? ['--session-id', request.agent.providerSessionId]
-            : ['--resume', request.agent.providerSessionId];
-        const args = ['-p', ...sessionArgs, '--output-format', 'stream-json', '--verbose'];
-        const child = this.spawn(request.executable ?? 'claude', args, {
-            cwd: request.agent.cwd,
-            shell: false,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        if (!child.pid) {
-            child.kill();
-            throw new ClaudePrintError('Claude process did not provide a PID.', 'CLAUDE_PROCESS_IDENTITY');
-        }
-        const identity = this.processInspector.getIdentity(child.pid);
-        if (!identity) {
-            child.kill();
-            throw new ClaudePrintError('Cannot verify Claude process identity.', 'CLAUDE_PROCESS_IDENTITY');
-        }
-
-        let buffer = Buffer.alloc(0);
-        let terminal: ClaudePrintRunResult | null = null;
-        let protocolError: ClaudePrintError | null = null;
-
-        child.stdout.on('data', (chunk: Buffer | string) => {
-            if (protocolError) return;
-            buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
-            if (buffer.length > this.maxLineBytes && buffer.indexOf(0x0a) < 0) {
-                protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');
-                return;
-            }
-            let newline: number;
-            while ((newline = buffer.indexOf(0x0a)) >= 0) {
-                const line = buffer.subarray(0, newline);
-                buffer = buffer.subarray(newline + 1);
-                if (line.length === 0) continue;
-                if (line.length > this.maxLineBytes) {
-                    protocolError = new ClaudePrintError('Claude stream line exceeded the safety limit.', 'CLAUDE_STREAM_OVERSIZED');
-                    return;
-                }
-                try {
-                    const value = JSON.parse(line.toString('utf8')) as unknown;
-                    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-                        throw new ClaudePrintError('Claude emitted a non-object stream message.', 'CLAUDE_STREAM_INVALID');
-                    }
-                    const event = value as Record<string, unknown>;
-                    if (typeof event.session_id === 'string' && event.session_id !== request.agent.providerSessionId) {
-                        throw new ClaudePrintError('Claude returned a different session identity.', 'CLAUDE_SESSION_MISMATCH');
-                    }
-                    if (event.type === 'result') {
-                        if (terminal) throw new ClaudePrintError('Claude emitted more than one terminal result.', 'CLAUDE_STREAM_INVALID');
-                        if (typeof event.session_id !== 'string' || typeof event.result !== 'string') {
-                            throw new ClaudePrintError('Claude emitted an invalid terminal result.', 'CLAUDE_STREAM_INVALID');
-                        }
-                        terminal = { sessionId: event.session_id, result: event.result, exitCode: 0 };
-                    }
-                } catch (error) {
-                    protocolError = error instanceof ClaudePrintError
-                        ? error
-                        : new ClaudePrintError('Claude emitted malformed stream JSON.', 'CLAUDE_STREAM_INVALID');
-                    return;
-                }
-            }
-        });
-        // Drain provider diagnostics without reflecting potentially sensitive prompt/tool data.
-        child.stderr.resume();
-
-        const closed = new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
-            child.once('error', reject);
-            child.once('close', (code, signal) => resolve({ code, signal }));
-        });
-
-        try {
-            await request.onSpawn(identity);
-        } catch (error) {
-            child.kill();
-            throw error;
-        }
-
-        child.stdin.end(request.prompt);
-        const { code, signal } = await closed;
-
-        if (protocolError) throw protocolError;
-        if (buffer.length > 0) {
-            throw new ClaudePrintError('Claude stream ended with incomplete JSON.', 'CLAUDE_STREAM_INVALID');
-        }
-        if (code !== 0) {
-            throw new ClaudePrintError(
-                `Claude print run failed${signal ? ` (${signal})` : '.'}`,
-                'CLAUDE_PROCESS_FAILED',
-            );
-        }
-        if (!terminal) throw new ClaudePrintError('Claude stream ended without a terminal result.', 'CLAUDE_RESULT_MISSING');
-        const finalResult = terminal as ClaudePrintRunResult;
-        return { sessionId: finalResult.sessionId, result: finalResult.result, exitCode: code };
-    }
-}