night-orch 0.3.1 → 0.3.2

package/dist/web/agent-session.d.ts

@@ -0,0 +1,88 @@
+import type { Config } from '../config/schema.js';
+export type InteractiveAgentType = 'claude' | 'codex';
+export type InteractiveAgentSessionStatus = 'idle' | 'running' | 'failed' | 'closed';
+export type InteractiveAgentSessionEventType = 'status' | 'stdout' | 'stderr' | 'text' | 'tool_call';
+export interface InteractiveAgentProfileSummary {
+    name: string;
+    type: InteractiveAgentType;
+    command: string;
+    args: string[];
+}
+export interface InteractiveAgentSessionSummary {
+    id: string;
+    agent: InteractiveAgentType;
+    profileName: string | null;
+    status: InteractiveAgentSessionStatus;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    turnCount: number;
+    lastError: string | null;
+}
+export interface InteractiveAgentSessionDetail extends InteractiveAgentSessionSummary {
+    continueSessionId: string | null;
+    runningTurnId: string | null;
+}
+export interface InteractiveAgentSessionEvent {
+    id: number;
+    sessionId: string;
+    timestamp: string;
+    type: InteractiveAgentSessionEventType;
+    data: Record<string, unknown>;
+}
+export interface InteractiveAgentSessionList {
+    generatedAt: string;
+    workspacePath: string;
+    profiles: InteractiveAgentProfileSummary[];
+    sessions: InteractiveAgentSessionSummary[];
+}
+export interface InteractiveAgentSessionEventList {
+    sessionId: string;
+    status: InteractiveAgentSessionStatus;
+    events: InteractiveAgentSessionEvent[];
+    lastEventId: number;
+}
+interface CreateSessionInput {
+    agent: InteractiveAgentType;
+    profileName?: string | null;
+    cwd?: string | null;
+}
+interface SessionEventListener {
+    (sessionId: string): void;
+}
+interface ManagerOptions {
+    workspacePath?: string;
+    maxEventsPerSession?: number;
+}
+export declare class InteractiveAgentSessionManager {
+    private readonly config;
+    private readonly sessions;
+    private readonly listeners;
+    private readonly workspacePath;
+    private readonly maxEventsPerSession;
+    private nextEventId;
+    constructor(config: Config, options?: ManagerOptions);
+    listSessions(): InteractiveAgentSessionList;
+    listProfiles(): InteractiveAgentProfileSummary[];
+    createSession(input: CreateSessionInput): InteractiveAgentSessionDetail;
+    getSession(sessionId: string): InteractiveAgentSessionDetail | null;
+    closeSession(sessionId: string): InteractiveAgentSessionDetail;
+    getEvents(sessionId: string, since?: number, limit?: number): InteractiveAgentSessionEventList;
+    sendPrompt(sessionId: string, prompt: string): {
+        accepted: true;
+        sessionId: string;
+        turnId: string;
+    };
+    onSessionEvent(listener: SessionEventListener): () => void;
+    private runTurn;
+    private handleStdoutLine;
+    private appendEvent;
+    private notify;
+    private resolveProfile;
+    private resolveSessionCwd;
+    private requireSession;
+    private toSummary;
+    private toDetail;
+}
+export {};
+//# sourceMappingURL=agent-session.d.ts.map

package/dist/web/agent-session.d.ts.map

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

package/dist/web/agent-session.js

@@ -0,0 +1,567 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { nowUtcIso } from '../utils/time.js';
+import { buildWorkerCommand } from '../workers/command.js';
+import { buildWorkerEnv } from '../workers/env.js';
+import { isRecord, summarizeValue } from '../workers/events.js';
+import { streamingExec } from '../workers/streaming-exec.js';
+const DEFAULT_MAX_EVENTS_PER_SESSION = 2_000;
+export class InteractiveAgentSessionManager {
+    config;
+    sessions = new Map();
+    listeners = new Set();
+    workspacePath;
+    maxEventsPerSession;
+    nextEventId = 1;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.workspacePath = resolve(options.workspacePath ?? process.cwd());
+        this.maxEventsPerSession = clampInt(options.maxEventsPerSession ?? DEFAULT_MAX_EVENTS_PER_SESSION, 100, 20_000);
+    }
+    listSessions() {
+        const sessions = [...this.sessions.values()]
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+            .map((session) => this.toSummary(session));
+        return {
+            generatedAt: nowUtcIso(),
+            workspacePath: this.workspacePath,
+            profiles: this.listProfiles(),
+            sessions,
+        };
+    }
+    listProfiles() {
+        const out = [];
+        for (const [name, profile] of Object.entries(this.config.workerProfiles)) {
+            if (profile.type !== 'claude' && profile.type !== 'codex')
+                continue;
+            out.push({
+                name,
+                type: profile.type,
+                command: profile.command,
+                args: [...profile.args],
+            });
+        }
+        return out.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    createSession(input) {
+        const profileSelection = this.resolveProfile(input.agent, input.profileName ?? null);
+        const cwd = this.resolveSessionCwd(input.cwd ?? null);
+        const now = nowUtcIso();
+        const id = randomUUID();
+        const session = {
+            id,
+            agent: input.agent,
+            profileName: profileSelection.profileName,
+            profile: profileSelection.profile,
+            status: 'idle',
+            cwd,
+            createdAt: now,
+            updatedAt: now,
+            turnCount: 0,
+            lastError: null,
+            continueSessionId: null,
+            runningTurnId: null,
+            events: [],
+            inFlight: null,
+        };
+        this.sessions.set(id, session);
+        this.appendEvent(session, 'status', {
+            message: `Created ${input.agent} interactive session`,
+            profile: profileSelection.profileName ?? '(fallback)',
+            cwd,
+        });
+        return this.toDetail(session);
+    }
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        return this.toDetail(session);
+    }
+    closeSession(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (session.status === 'running') {
+            throw new Error('Session is currently running and cannot be closed');
+        }
+        if (session.status === 'closed') {
+            return this.toDetail(session);
+        }
+        session.status = 'closed';
+        session.updatedAt = nowUtcIso();
+        session.runningTurnId = null;
+        this.appendEvent(session, 'status', { message: 'Session closed' });
+        return this.toDetail(session);
+    }
+    getEvents(sessionId, since = 0, limit = 200) {
+        const session = this.requireSession(sessionId);
+        const boundedSince = Math.max(0, Math.floor(since));
+        const boundedLimit = clampInt(limit, 1, 400);
+        const events = session.events
+            .filter((event) => event.id > boundedSince)
+            .slice(0, boundedLimit);
+        return {
+            sessionId,
+            status: session.status,
+            events,
+            lastEventId: events.length > 0 ? events[events.length - 1].id : boundedSince,
+        };
+    }
+    sendPrompt(sessionId, prompt) {
+        const session = this.requireSession(sessionId);
+        const cleanedPrompt = prompt.trim();
+        if (!cleanedPrompt) {
+            throw new Error('prompt is required');
+        }
+        if (session.status === 'closed') {
+            throw new Error('Session is closed');
+        }
+        if (session.inFlight) {
+            throw new Error('Session already has a running prompt');
+        }
+        const turnId = randomUUID();
+        session.status = 'running';
+        session.updatedAt = nowUtcIso();
+        session.turnCount += 1;
+        session.runningTurnId = turnId;
+        session.lastError = null;
+        this.appendEvent(session, 'status', {
+            message: 'Turn started',
+            turnId,
+            turnCount: session.turnCount,
+        });
+        const runPromise = this.runTurn(session, turnId, cleanedPrompt);
+        session.inFlight = runPromise;
+        void runPromise
+            .catch((err) => {
+            const message = summarizeValue(err.message ?? String(err), 1_000);
+            session.status = 'failed';
+            session.lastError = `Unexpected turn failure: ${message}`;
+            session.runningTurnId = null;
+            session.updatedAt = nowUtcIso();
+            this.appendEvent(session, 'status', {
+                message: session.lastError,
+                turnId,
+            });
+        })
+            .finally(() => {
+            if (session.inFlight === runPromise) {
+                session.inFlight = null;
+            }
+        });
+        return { accepted: true, sessionId, turnId };
+    }
+    onSessionEvent(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async runTurn(session, turnId, prompt) {
+        const tempOutputDir = join(tmpdir(), 'night-orch-codex-output');
+        const tempOutputFile = session.agent === 'codex'
+            ? join(tempOutputDir, `interactive-${randomUUID()}.txt`)
+            : null;
+        try {
+            if (tempOutputFile) {
+                await mkdir(tempOutputDir, { recursive: true });
+            }
+            const taskArgs = buildInteractiveTaskArgs(session.agent, session.profile, session.continueSessionId, tempOutputFile);
+            const workerCommand = buildWorkerCommand(session.profile, taskArgs);
+            const env = buildWorkerEnv(session.profile);
+            const result = await streamingExec({
+                command: workerCommand.command,
+                args: workerCommand.args,
+                cwd: session.cwd,
+                env,
+                timeoutMs: session.profile.workerTimeoutSeconds * 1000,
+                stdin: prompt,
+                onStdoutLine: (line) => {
+                    this.handleStdoutLine(session, line);
+                },
+                onStderrLine: (line) => {
+                    this.appendEvent(session, 'stderr', { text: summarizeValue(line, 1_000) });
+                },
+            });
+            if (tempOutputFile) {
+                try {
+                    const lastMessage = (await readFile(tempOutputFile, 'utf-8')).trim();
+                    if (lastMessage.length > 0) {
+                        this.appendEvent(session, 'text', {
+                            text: summarizeValue(lastMessage, 8_000),
+                            source: 'codex-output-last-message',
+                        });
+                    }
+                }
+                catch {
+                    // Best-effort only; some codex invocations may skip output file.
+                }
+                finally {
+                    void unlink(tempOutputFile).catch(() => { });
+                }
+            }
+            const sessionId = session.agent === 'codex'
+                ? extractCodexThreadId(result.stdout)
+                : extractClaudeSessionId(result.stdout);
+            if (sessionId) {
+                session.continueSessionId = sessionId;
+            }
+            if (result.outputTruncated) {
+                this.appendEvent(session, 'status', {
+                    message: 'Output was truncated to tail window',
+                    stdoutBytes: result.stdoutBytes,
+                    stderrBytes: result.stderrBytes,
+                });
+            }
+            if (result.exitCode === 0 && !result.timedOut) {
+                session.status = 'idle';
+                session.lastError = null;
+                session.runningTurnId = null;
+                session.updatedAt = nowUtcIso();
+                this.appendEvent(session, 'status', {
+                    message: 'Turn completed',
+                    turnId,
+                    exitCode: result.exitCode,
+                    durationMs: result.durationMs,
+                    sessionId: session.continueSessionId,
+                });
+                return;
+            }
+            const failureMessage = result.timedOut
+                ? `Agent timed out after ${session.profile.workerTimeoutSeconds}s`
+                : `Agent exited with code ${result.exitCode}`;
+            session.status = 'failed';
+            session.lastError = failureMessage;
+            session.runningTurnId = null;
+            session.updatedAt = nowUtcIso();
+            this.appendEvent(session, 'status', {
+                message: failureMessage,
+                turnId,
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+            });
+        }
+        catch (err) {
+            const message = summarizeValue(err.message ?? String(err), 1_000);
+            session.status = 'failed';
+            session.lastError = message;
+            session.runningTurnId = null;
+            session.updatedAt = nowUtcIso();
+            this.appendEvent(session, 'status', {
+                message: `Turn failed: ${message}`,
+                turnId,
+            });
+            logger.warn({ sessionId: session.id, err }, 'Interactive agent turn failed');
+        }
+    }
+    handleStdoutLine(session, line) {
+        const parsed = tryParseJson(line);
+        if (!parsed) {
+            this.appendEvent(session, 'stdout', { text: summarizeValue(line, 1_000) });
+            return;
+        }
+        const handled = session.agent === 'codex'
+            ? emitCodexEvent(parsed, (type, data) => this.appendEvent(session, type, data))
+            : emitClaudeEvent(parsed, (type, data) => this.appendEvent(session, type, data));
+        if (!handled) {
+            this.appendEvent(session, 'stdout', { text: summarizeValue(line, 1_000) });
+        }
+    }
+    appendEvent(session, type, data) {
+        const event = {
+            id: this.nextEventId++,
+            sessionId: session.id,
+            timestamp: nowUtcIso(),
+            type,
+            data,
+        };
+        session.events.push(event);
+        if (session.events.length > this.maxEventsPerSession) {
+            session.events.splice(0, session.events.length - this.maxEventsPerSession);
+        }
+        session.updatedAt = event.timestamp;
+        this.notify(session.id);
+    }
+    notify(sessionId) {
+        for (const listener of this.listeners) {
+            try {
+                listener(sessionId);
+            }
+            catch (err) {
+                logger.warn({ err, sessionId }, 'Agent-session listener failed');
+            }
+        }
+    }
+    resolveProfile(agent, explicitProfileName) {
+        if (explicitProfileName) {
+            const byName = this.config.workerProfiles[explicitProfileName];
+            if (!byName) {
+                throw new Error(`Unknown profile: ${explicitProfileName}`);
+            }
+            if (byName.type !== agent) {
+                throw new Error(`Profile ${explicitProfileName} has type ${byName.type}; expected ${agent}`);
+            }
+            return { profileName: explicitProfileName, profile: byName };
+        }
+        for (const [name, profile] of Object.entries(this.config.workerProfiles)) {
+            if (profile.type === agent) {
+                return { profileName: name, profile };
+            }
+        }
+        return {
+            profileName: null,
+            profile: buildFallbackProfile(agent),
+        };
+    }
+    resolveSessionCwd(rawCwd) {
+        if (!rawCwd)
+            return this.workspacePath;
+        const resolved = resolve(this.workspacePath, rawCwd);
+        if (resolved !== this.workspacePath && !resolved.startsWith(this.workspacePath + sep)) {
+            throw new Error('cwd must be inside the night-orch workspace');
+        }
+        return resolved;
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        return session;
+    }
+    toSummary(session) {
+        return {
+            id: session.id,
+            agent: session.agent,
+            profileName: session.profileName,
+            status: session.status,
+            cwd: session.cwd,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            turnCount: session.turnCount,
+            lastError: session.lastError,
+        };
+    }
+    toDetail(session) {
+        return {
+            ...this.toSummary(session),
+            continueSessionId: session.continueSessionId,
+            runningTurnId: session.runningTurnId,
+        };
+    }
+}
+function buildFallbackProfile(agent) {
+    return {
+        type: agent,
+        command: agent,
+        args: agent === 'codex' ? ['exec'] : ['-p'],
+        workerTimeoutSeconds: 1800,
+        minimalEnv: true,
+        runtimeWrapper: null,
+        env: {},
+    };
+}
+function buildInteractiveTaskArgs(agent, profile, continueSessionId, outputFile) {
+    if (agent === 'codex') {
+        const args = [...profile.args];
+        if (outputFile) {
+            args.push('--output-last-message', outputFile);
+        }
+        if (continueSessionId) {
+            const execIndex = args.indexOf('exec');
+            if (execIndex >= 0) {
+                args.splice(execIndex + 1, 0, 'resume', continueSessionId);
+            }
+        }
+        return args;
+    }
+    const args = [
+        ...profile.args,
+        '--output-format', 'json',
+        '--max-turns', '50',
+    ];
+    if (!hasExplicitPermissionMode(args)) {
+        args.push('--permission-mode', resolveDefaultPermissionMode());
+    }
+    if (continueSessionId) {
+        args.push('--continue', continueSessionId);
+    }
+    return args;
+}
+function hasExplicitPermissionMode(args) {
+    for (const arg of args) {
+        if (arg === '--permission-mode' || arg.startsWith('--permission-mode='))
+            return true;
+        if (arg === '--dangerously-skip-permissions')
+            return true;
+        if (arg === '--allow-dangerously-skip-permissions')
+            return true;
+    }
+    return false;
+}
+function resolveDefaultPermissionMode() {
+    try {
+        if (typeof process.getuid === 'function' && process.getuid() === 0) {
+            return 'acceptEdits';
+        }
+    }
+    catch {
+        // Ignore and keep non-root default.
+    }
+    return 'bypassPermissions';
+}
+function emitCodexEvent(parsed, emit) {
+    if (!isRecord(parsed))
+        return false;
+    const type = parsed['type'];
+    if (type === 'item.completed' && isRecord(parsed['item'])) {
+        const item = parsed['item'];
+        if (item['type'] === 'agent_message' && typeof item['text'] === 'string') {
+            emit('text', { text: summarizeValue(item['text'], 8_000) });
+            return true;
+        }
+        if ((item['type'] === 'function_call' || item['type'] === 'tool_call') && typeof item['name'] === 'string') {
+            emit('tool_call', {
+                toolName: item['name'],
+                toolArgs: summarizeValue(item['arguments'] ?? item['args'], 1_000),
+            });
+            return true;
+        }
+    }
+    if (type === 'function_call' && typeof parsed['name'] === 'string') {
+        emit('tool_call', {
+            toolName: parsed['name'],
+            toolArgs: summarizeValue(parsed['arguments'] ?? parsed['args'], 1_000),
+        });
+        return true;
+    }
+    if (type === 'error') {
+        emit('stderr', { text: summarizeValue(parsed['error'], 1_000) });
+        return true;
+    }
+    return false;
+}
+function emitClaudeEvent(parsed, emit) {
+    if (Array.isArray(parsed)) {
+        let handled = false;
+        for (const item of parsed) {
+            handled = emitClaudeEvent(item, emit) || handled;
+        }
+        return handled;
+    }
+    if (!isRecord(parsed))
+        return false;
+    const type = parsed['type'];
+    if (type !== 'assistant') {
+        if (type === 'error') {
+            emit('stderr', { text: summarizeValue(parsed['error'], 1_000) });
+            return true;
+        }
+        return false;
+    }
+    const message = parsed['message'];
+    if (!isRecord(message) || !Array.isArray(message['content']))
+        return false;
+    let handled = false;
+    for (const block of message['content']) {
+        if (!isRecord(block))
+            continue;
+        if (block['type'] === 'text' && typeof block['text'] === 'string') {
+            emit('text', { text: summarizeValue(block['text'], 8_000) });
+            handled = true;
+            continue;
+        }
+        if (block['type'] === 'tool_use') {
+            emit('tool_call', {
+                toolName: typeof block['name'] === 'string' ? block['name'] : 'tool',
+                toolArgs: summarizeValue(block['input'], 1_000),
+            });
+            handled = true;
+        }
+    }
+    return handled;
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function extractCodexThreadId(raw) {
+    for (const event of parseCodexEvents(raw)) {
+        if (!isRecord(event))
+            continue;
+        if (isRecord(event['session']) && typeof event['session']['thread_id'] === 'string') {
+            return event['session']['thread_id'];
+        }
+        if (typeof event['thread_id'] === 'string') {
+            return event['thread_id'];
+        }
+    }
+    return null;
+}
+function parseCodexEvents(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    const out = [];
+    for (const line of trimmed.split('\n')) {
+        const parsed = tryParseJson(line.trim());
+        if (parsed)
+            out.push(parsed);
+    }
+    return out;
+}
+function extractClaudeSessionId(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const parsed = tryParseJson(trimmed);
+    if (!parsed)
+        return null;
+    if (Array.isArray(parsed)) {
+        for (const item of parsed) {
+            if (!isRecord(item))
+                continue;
+            if (item['type'] === 'system' && isRecord(item['session']) && typeof item['session']['session_id'] === 'string') {
+                return item['session']['session_id'];
+            }
+            if (typeof item['session_id'] === 'string') {
+                return item['session_id'];
+            }
+        }
+        return null;
+    }
+    if (isRecord(parsed)) {
+        if (typeof parsed['session_id'] === 'string')
+            return parsed['session_id'];
+        if (isRecord(parsed['session']) && typeof parsed['session']['session_id'] === 'string') {
+            return parsed['session']['session_id'];
+        }
+    }
+    return null;
+}
+function clampInt(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    const floor = Math.floor(value);
+    if (floor < min)
+        return min;
+    if (floor > max)
+        return max;
+    return floor;
+}
+//# sourceMappingURL=agent-session.js.map