profclaw 0.0.1-beta.1

package/dist/chat/execution/session-manager.js

@@ -0,0 +1,356 @@
+/**
+ * Session Manager
+ *
+ * Tracks running tool execution sessions (processes).
+ * Handles backgrounding, output collection, and cleanup.
+ */
+import { logger } from "../../utils/logger.js";
+import { hasSecrets, isSecretsDetectionEnabled, redactSecrets, } from "./secrets.js";
+import { randomUUID } from "crypto";
+// Constants
+const DEFAULT_MAX_OUTPUT_CHARS = 200_000;
+const TAIL_CHARS = 10_000; // Keep last 10k chars for display
+const SESSION_CLEANUP_INTERVAL_MS = 60_000;
+const SESSION_MAX_AGE_MS = 3600_000; // 1 hour
+const MAX_SESSIONS = 500;
+const redactSessionOutput = (text) => {
+    if (!text) {
+        return text;
+    }
+    if (!isSecretsDetectionEnabled()) {
+        return text;
+    }
+    if (!hasSecrets(text)) {
+        return text;
+    }
+    return redactSecrets(text);
+};
+// Session Manager Implementation
+export class ToolSessionManager {
+    sessions = new Map();
+    cleanupTimer = null;
+    constructor() {
+        this.cleanupTimer = setInterval(() => this.cleanup(), SESSION_CLEANUP_INTERVAL_MS);
+    }
+    /**
+     * Create a new session
+     */
+    create(data) {
+        // Enforce max sessions
+        if (this.sessions.size >= MAX_SESSIONS) {
+            this.cleanupOldestSessions(50);
+        }
+        const id = this.generateSessionId();
+        const session = {
+            id,
+            createdAt: Date.now(),
+            ...data,
+        };
+        const managed = {
+            session,
+            process: null,
+            outputBuffer: [],
+            listeners: new Set(),
+        };
+        this.sessions.set(id, managed);
+        logger.debug(`[SessionManager] Created session: ${id}`, {
+            component: "SessionManager",
+        });
+        return session;
+    }
+    /**
+     * Get a session by ID
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId)?.session;
+    }
+    /**
+     * Update a session
+     */
+    update(sessionId, update) {
+        const managed = this.sessions.get(sessionId);
+        if (managed) {
+            Object.assign(managed.session, update);
+        }
+    }
+    /**
+     * List sessions with optional filtering
+     */
+    list(filter) {
+        let sessions = Array.from(this.sessions.values()).map((m) => m.session);
+        if (filter?.conversationId) {
+            sessions = sessions.filter((s) => s.conversationId === filter.conversationId);
+        }
+        if (filter?.toolName) {
+            sessions = sessions.filter((s) => s.toolName === filter.toolName);
+        }
+        if (filter?.status?.length) {
+            sessions = sessions.filter((s) => filter.status.includes(s.status));
+        }
+        if (filter?.since) {
+            sessions = sessions.filter((s) => s.createdAt >= filter.since);
+        }
+        return sessions;
+    }
+    /**
+     * Kill a running session
+     */
+    async kill(sessionId) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed)
+            return;
+        const { session, process } = managed;
+        if (process && session.status === "running") {
+            try {
+                // Try SIGTERM first
+                process.kill("SIGTERM");
+                // Force kill after 5 seconds
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        if (!process.killed) {
+                            process.kill("SIGKILL");
+                        }
+                        resolve();
+                    }, 5000);
+                    process.once("exit", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+                session.status = "killed";
+                session.completedAt = Date.now();
+                logger.info(`[SessionManager] Killed session: ${sessionId}`, {
+                    component: "SessionManager",
+                });
+            }
+            catch (error) {
+                logger.error(`[SessionManager] Failed to kill session: ${sessionId}`, error instanceof Error ? error : undefined);
+            }
+        }
+    }
+    /**
+     * Cleanup old/completed sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        const toDelete = [];
+        for (const [id, managed] of this.sessions) {
+            const { session } = managed;
+            // Remove completed sessions older than max age
+            if (["completed", "failed", "killed", "timeout"].includes(session.status) &&
+                now - session.createdAt > SESSION_MAX_AGE_MS) {
+                toDelete.push(id);
+            }
+            // Remove very old pending sessions
+            if (session.status === "pending" &&
+                now - session.createdAt > SESSION_MAX_AGE_MS * 2) {
+                toDelete.push(id);
+            }
+        }
+        for (const id of toDelete) {
+            this.sessions.delete(id);
+        }
+        if (toDelete.length > 0) {
+            logger.debug(`[SessionManager] Cleaned up ${toDelete.length} sessions`, {
+                component: "SessionManager",
+            });
+        }
+    }
+    // Extended Methods
+    /**
+     * Attach a process to a session
+     */
+    attachProcess(sessionId, process) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed)
+            return;
+        managed.process = process;
+        managed.session.pid = process.pid;
+        managed.session.status = "running";
+        managed.session.startedAt = Date.now();
+        // Set up output collection
+        process.stdout?.on("data", (data) => {
+            this.appendOutput(sessionId, "stdout", data.toString());
+        });
+        process.stderr?.on("data", (data) => {
+            this.appendOutput(sessionId, "stderr", data.toString());
+        });
+        process.on("exit", (code, signal) => {
+            this.handleProcessExit(sessionId, code, signal);
+        });
+        process.on("error", (error) => {
+            logger.error(`[SessionManager] Process error: ${sessionId}`, error);
+            managed.session.status = "failed";
+            managed.session.stderr += `\nProcess error: ${error.message}`;
+        });
+    }
+    /**
+     * Append output to a session
+     */
+    appendOutput(sessionId, stream, data) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed)
+            return;
+        const { session, listeners } = managed;
+        const maxChars = session.maxOutputChars || DEFAULT_MAX_OUTPUT_CHARS;
+        const sanitizedData = redactSessionOutput(data);
+        // Append to appropriate stream
+        if (stream === "stdout") {
+            session.stdout += sanitizedData;
+        }
+        else {
+            session.stderr += sanitizedData;
+        }
+        // Check for truncation
+        const totalChars = session.stdout.length + session.stderr.length;
+        if (totalChars > maxChars && !session.truncated) {
+            session.truncated = true;
+            // Keep only the tail
+            if (session.stdout.length > TAIL_CHARS) {
+                session.stdout = `[...truncated...]\n${session.stdout.slice(-TAIL_CHARS)}`;
+            }
+            if (session.stderr.length > TAIL_CHARS) {
+                session.stderr = `[...truncated...]\n${session.stderr.slice(-TAIL_CHARS)}`;
+            }
+        }
+        // Notify listeners
+        for (const listener of listeners) {
+            try {
+                listener({ stream, data: sanitizedData, sessionId });
+            }
+            catch {
+                // Ignore listener errors
+            }
+        }
+    }
+    /**
+     * Subscribe to session output
+     */
+    subscribe(sessionId, listener) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed) {
+            return () => { };
+        }
+        managed.listeners.add(listener);
+        return () => managed.listeners.delete(listener);
+    }
+    /**
+     * Get session output (combined stdout + stderr)
+     */
+    getOutput(sessionId) {
+        const session = this.get(sessionId);
+        if (!session)
+            return "";
+        // Interleave stdout and stderr for display
+        let output = session.stdout;
+        if (session.stderr) {
+            output += session.stderr
+                .split("\n")
+                .map((line) => `stderr: ${line}`)
+                .join("\n");
+        }
+        return output;
+    }
+    /**
+     * Get tail of session output
+     */
+    getTail(sessionId, chars = TAIL_CHARS) {
+        const output = this.getOutput(sessionId);
+        if (output.length <= chars)
+            return output;
+        return `[...]\n${output.slice(-chars)}`;
+    }
+    /**
+     * Mark session as backgrounded
+     */
+    background(sessionId) {
+        const managed = this.sessions.get(sessionId);
+        if (managed) {
+            managed.session.backgrounded = true;
+            logger.debug(`[SessionManager] Backgrounded session: ${sessionId}`, {
+                component: "SessionManager",
+            });
+        }
+    }
+    /**
+     * Write to session stdin
+     */
+    write(sessionId, data) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed?.process?.stdin)
+            return false;
+        try {
+            managed.process.stdin.write(data);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Destroy the session manager
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        // Kill all running processes
+        for (const managed of this.sessions.values()) {
+            if (managed.process && managed.session.status === "running") {
+                try {
+                    managed.process.kill("SIGKILL");
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        this.sessions.clear();
+    }
+    // Private Methods
+    generateSessionId() {
+        // Short 8-char ID for display
+        return randomUUID().slice(0, 8);
+    }
+    handleProcessExit(sessionId, code, signal) {
+        const managed = this.sessions.get(sessionId);
+        if (!managed)
+            return;
+        const { session } = managed;
+        session.exitCode = code;
+        session.exitSignal = signal?.toString() ?? null;
+        session.completedAt = Date.now();
+        if (code === 0 && !signal) {
+            session.status = "completed";
+        }
+        else if (signal === "SIGTERM" || signal === "SIGKILL") {
+            session.status = "killed";
+        }
+        else {
+            session.status = "failed";
+        }
+        logger.debug(`[SessionManager] Session ${sessionId} exited: code=${code}, signal=${signal}`, { component: "SessionManager" });
+        // Notify if backgrounded
+        if (session.backgrounded && session.notifyOnExit) {
+            // TODO: Send notification to chat
+        }
+    }
+    cleanupOldestSessions(count) {
+        const sorted = Array.from(this.sessions.entries())
+            .filter(([_, m]) => m.session.status !== "running")
+            .sort((a, b) => a[1].session.createdAt - b[1].session.createdAt);
+        for (let i = 0; i < count && i < sorted.length; i++) {
+            this.sessions.delete(sorted[i][0]);
+        }
+    }
+}
+// Singleton
+let sessionManager = null;
+export function getSessionManager() {
+    if (!sessionManager) {
+        sessionManager = new ToolSessionManager();
+    }
+    return sessionManager;
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/chat/execution/session-spawn/config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Session Spawn Configuration
+ *
+ * Loads session spawn settings from config/settings.yml with environment variable overrides.
+ */
+export interface SessionSpawnConfig {
+    enabled: boolean;
+    maxDepth: number;
+    maxChildrenPerSession: number;
+    defaultBudget: number;
+    defaultSteps: number;
+    rootMultiplier: number;
+    defaultMessagePriority: number;
+    maxMessagePriority: number;
+    cleanup: {
+        enabled: boolean;
+        intervalMs: number;
+        maxAgeMs: number;
+    };
+}
+/**
+ * Load session spawn configuration from settings.yml with environment overrides.
+ * Results are cached for performance.
+ */
+export declare function getSessionSpawnConfig(): SessionSpawnConfig;
+/**
+ * Clear the cached configuration (useful for testing or config reload).
+ */
+export declare function clearSessionSpawnConfigCache(): void;
+/**
+ * Get computed root session limits based on config.
+ */
+export declare function getRootSessionLimits(): {
+    maxBudget: number;
+    maxSteps: number;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/chat/execution/session-spawn/config.js

@@ -0,0 +1,83 @@
+/**
+ * Session Spawn Configuration
+ *
+ * Loads session spawn settings from config/settings.yml with environment variable overrides.
+ */
+import { loadConfig } from '../../../utils/config-loader.js';
+// Defaults
+const DEFAULT_CONFIG = {
+    enabled: true,
+    maxDepth: 3,
+    maxChildrenPerSession: 5,
+    defaultBudget: 20_000,
+    defaultSteps: 20,
+    rootMultiplier: 5,
+    defaultMessagePriority: 5,
+    maxMessagePriority: 10,
+    cleanup: {
+        enabled: true,
+        intervalMs: 3_600_000, // 1 hour
+        maxAgeMs: 86_400_000, // 24 hours
+    },
+};
+// Config Loading
+let cachedConfig = null;
+/**
+ * Load session spawn configuration from settings.yml with environment overrides.
+ * Results are cached for performance.
+ */
+export function getSessionSpawnConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const settings = loadConfig('settings.yml');
+    const yamlConfig = settings.sessionSpawn || {};
+    // Merge with defaults, applying environment overrides
+    cachedConfig = {
+        enabled: parseBoolean(process.env.SESSION_SPAWN_ENABLED, yamlConfig.enabled ?? DEFAULT_CONFIG.enabled),
+        maxDepth: parseNumber(process.env.SESSION_SPAWN_MAX_DEPTH, yamlConfig.maxDepth ?? DEFAULT_CONFIG.maxDepth),
+        maxChildrenPerSession: parseNumber(process.env.SESSION_SPAWN_MAX_CHILDREN, yamlConfig.maxChildrenPerSession ?? DEFAULT_CONFIG.maxChildrenPerSession),
+        defaultBudget: parseNumber(process.env.SESSION_SPAWN_DEFAULT_BUDGET, yamlConfig.defaultBudget ?? DEFAULT_CONFIG.defaultBudget),
+        defaultSteps: parseNumber(process.env.SESSION_SPAWN_DEFAULT_STEPS, yamlConfig.defaultSteps ?? DEFAULT_CONFIG.defaultSteps),
+        rootMultiplier: parseNumber(process.env.SESSION_SPAWN_ROOT_MULTIPLIER, yamlConfig.rootMultiplier ?? DEFAULT_CONFIG.rootMultiplier),
+        defaultMessagePriority: parseNumber(process.env.SESSION_SPAWN_MESSAGE_PRIORITY, yamlConfig.defaultMessagePriority ?? DEFAULT_CONFIG.defaultMessagePriority),
+        maxMessagePriority: yamlConfig.maxMessagePriority ?? DEFAULT_CONFIG.maxMessagePriority,
+        cleanup: {
+            enabled: parseBoolean(process.env.SESSION_SPAWN_CLEANUP_ENABLED, yamlConfig.cleanup?.enabled ?? DEFAULT_CONFIG.cleanup.enabled),
+            intervalMs: parseNumber(process.env.SESSION_SPAWN_CLEANUP_INTERVAL, yamlConfig.cleanup?.intervalMs ?? DEFAULT_CONFIG.cleanup.intervalMs),
+            maxAgeMs: parseNumber(process.env.SESSION_SPAWN_MAX_AGE, yamlConfig.cleanup?.maxAgeMs ?? DEFAULT_CONFIG.cleanup.maxAgeMs),
+        },
+    };
+    return cachedConfig;
+}
+/**
+ * Clear the cached configuration (useful for testing or config reload).
+ */
+export function clearSessionSpawnConfigCache() {
+    cachedConfig = null;
+}
+/**
+ * Get computed root session limits based on config.
+ */
+export function getRootSessionLimits() {
+    const config = getSessionSpawnConfig();
+    return {
+        maxBudget: config.defaultBudget * config.rootMultiplier,
+        maxSteps: config.defaultSteps * config.rootMultiplier,
+    };
+}
+// Helpers
+function parseNumber(envValue, defaultValue) {
+    if (envValue === undefined || envValue === '') {
+        return defaultValue;
+    }
+    const parsed = parseInt(envValue, 10);
+    return isNaN(parsed) ? defaultValue : parsed;
+}
+function parseBoolean(envValue, defaultValue) {
+    if (envValue === undefined || envValue === '') {
+        return defaultValue;
+    }
+    return envValue.toLowerCase() === 'true' || envValue === '1';
+}
+//# sourceMappingURL=config.js.map

package/dist/chat/execution/session-spawn/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Session Spawn Module
+ *
+ * Exports for the agent session hierarchy and messaging system.
+ * See docs/SESSION_SPAWN.md for full documentation.
+ */
+export * from './types.js';
+export { getSessionSpawnConfig, getRootSessionLimits, clearSessionSpawnConfigCache, type SessionSpawnConfig, } from './config.js';
+export { AgentSessionManagerImpl, getAgentSessionManager } from './manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/execution/session-spawn/index.js

@@ -0,0 +1,10 @@
+/**
+ * Session Spawn Module
+ *
+ * Exports for the agent session hierarchy and messaging system.
+ * See docs/SESSION_SPAWN.md for full documentation.
+ */
+export * from './types.js';
+export { getSessionSpawnConfig, getRootSessionLimits, clearSessionSpawnConfigCache, } from './config.js';
+export { AgentSessionManagerImpl, getAgentSessionManager } from './manager.js';
+//# sourceMappingURL=index.js.map

package/dist/chat/execution/session-spawn/manager.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Agent Session Manager Implementation
+ *
+ * Database-backed manager for spawning and managing agent sessions.
+ * Supports hierarchical session trees and inter-session messaging.
+ */
+import type { AgentSession, AgentSessionManager, CleanupParams, CompleteSessionParams, ReceiveMessagesParams, SendMessageParams, SessionMessage, SpawnSessionParams, UpdateSessionParams } from './types.js';
+export declare class AgentSessionManagerImpl implements AgentSessionManager {
+    spawn(params: SpawnSessionParams): Promise<AgentSession>;
+    get(sessionId: string): Promise<AgentSession | null>;
+    update(sessionId: string, params: UpdateSessionParams): Promise<AgentSession | null>;
+    complete(sessionId: string, params: CompleteSessionParams): Promise<AgentSession | null>;
+    cancel(sessionId: string, reason?: string): Promise<AgentSession | null>;
+    getChildren(sessionId: string): Promise<AgentSession[]>;
+    getSiblings(sessionId: string): Promise<AgentSession[]>;
+    getParent(sessionId: string): Promise<AgentSession | null>;
+    getByConversation(conversationId: string): Promise<AgentSession[]>;
+    send(params: SendMessageParams): Promise<SessionMessage[]>;
+    receive(params: ReceiveMessagesParams): Promise<SessionMessage[]>;
+    getUnreadCount(sessionId: string): Promise<number>;
+    cleanup(params: CleanupParams): Promise<{
+        sessionsDeleted: number;
+        messagesDeleted: number;
+    }>;
+    /**
+     * Create a root session for a conversation.
+     * This is called when starting a new agentic conversation.
+     */
+    createRootSession(conversationId: string, name: string, goal?: string): Promise<AgentSession>;
+    private resolveTargetSessionIds;
+    private mapToAgentSession;
+    private mapToSessionMessage;
+}
+export declare function getAgentSessionManager(): AgentSessionManagerImpl;
+//# sourceMappingURL=manager.d.ts.map