@agenthippo-ai/agenthippo 0.1.0

package/out/terminalLogger.js

@@ -0,0 +1,358 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalNameToSlug = terminalNameToSlug;
+exports.ensureDirectory = ensureDirectory;
+exports.appendTextFileWithRotation = appendTextFileWithRotation;
+exports.activateTerminalLogger = activateTerminalLogger;
+exports.deleteSessionLogs = deleteSessionLogs;
+exports.cleanupOldSessionLogs = cleanupOldSessionLogs;
+const vscode = __importStar(require("vscode"));
+const workspaceFolders_1 = require("./workspaceFolders");
+const branding_1 = require("./branding");
+const _textEncoder = new TextEncoder();
+function terminalNameToSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 50) || 'terminal';
+}
+async function ensureDirectory(uri) {
+    await vscode.workspace.fs.createDirectory(uri);
+}
+async function statSafe(uri) {
+    try {
+        return await vscode.workspace.fs.stat(uri);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function deleteFileSafe(uri) {
+    try {
+        await vscode.workspace.fs.delete(uri, { recursive: false, useTrash: false });
+    }
+    catch {
+        // ignore
+    }
+}
+async function rotateFileIfNeeded(uri, maxBytes, nextWriteBytes) {
+    const st = await statSafe(uri);
+    const size = st?.size ?? 0;
+    if (size + nextWriteBytes <= maxBytes) {
+        return;
+    }
+    const rotated = uri.with({ path: `${uri.path}.1` });
+    await deleteFileSafe(rotated);
+    try {
+        await vscode.workspace.fs.rename(uri, rotated, { overwrite: true });
+    }
+    catch {
+        // ignore (file may not exist)
+    }
+}
+async function appendTextFileWithRotation(uri, text, maxBytes) {
+    const bytes = _textEncoder.encode(text);
+    await rotateFileIfNeeded(uri, maxBytes, bytes.length);
+    let existing;
+    try {
+        existing = await vscode.workspace.fs.readFile(uri);
+    }
+    catch {
+        existing = undefined;
+    }
+    if (!existing || existing.length === 0) {
+        await vscode.workspace.fs.writeFile(uri, bytes);
+        return;
+    }
+    const combined = new Uint8Array(existing.length + bytes.length);
+    combined.set(existing, 0);
+    combined.set(bytes, existing.length);
+    await vscode.workspace.fs.writeFile(uri, combined);
+}
+// Directory for terminal logs, relative to workspace root
+const TERMINALS_DIR = 'terminals';
+const SESSIONS_DIR = 'sessions';
+const MAX_TERMINAL_LOG_BYTES = 2 * 1024 * 1024; // 2MB per terminal file, then rotate
+const MAX_TERMINAL_CAPTURE_BYTES = 512 * 1024; // cap per-command captured output in memory
+const DEFAULT_RETENTION_DAYS = 7; // Default retention period for session logs
+const activeCommandOutputs = new Map();
+/**
+ * Terminal Activity Logger
+ *
+ * Hooks into VS Code's shell integration to log all terminal command executions
+ * to files that agents can grep/read. This solves the problem that external agents
+ * (Codex, Claude) cannot directly access terminal content.
+ *
+ * File structure:
+ *   .agentide/terminals/<terminal-slug>.md
+ *
+ * Each file contains a chronological log of commands with their outputs:
+ *
+ * <!-- CMD:npm-run-build TIME:2026-01-01T12:00:00Z CWD:/path/to/dir -->
+ * ## npm run build
+ * <!-- EXIT:0 DURATION:5000ms -->
+ * ```text
+ * [command output here]
+ * ```
+ *
+ * Agents are instructed to grep this directory for terminal output.
+ */
+function activateTerminalLogger(context) {
+    const outputChannel = vscode.window.createOutputChannel('AgentIDE Terminal Logger');
+    // Listen for command start to begin capturing output
+    context.subscriptions.push(vscode.window.onDidStartTerminalShellExecution(async (event) => {
+        const execution = event.execution;
+        const terminal = event.terminal;
+        const commandLine = execution.commandLine.value;
+        outputChannel.appendLine(`[Terminal] Command started in "${terminal.name}": ${commandLine}`);
+        // Start collecting output (bounded)
+        const output = { chunks: [], bytes: 0, truncated: false };
+        activeCommandOutputs.set(execution, output);
+        try {
+            // Read output stream (async iterable)
+            for await (const data of execution.read()) {
+                output.chunks.push(data);
+                output.bytes += Buffer.byteLength(data, 'utf8');
+                // Keep only the tail to avoid unbounded growth for long-running commands.
+                while (output.bytes > MAX_TERMINAL_CAPTURE_BYTES && output.chunks.length > 1) {
+                    const dropped = output.chunks.shift();
+                    output.bytes -= Buffer.byteLength(dropped, 'utf8');
+                    output.truncated = true;
+                }
+            }
+        }
+        catch (error) {
+            outputChannel.appendLine(`[Terminal] Error reading output: ${error}`);
+        }
+    }));
+    // Listen for command end to write the complete log entry
+    context.subscriptions.push(vscode.window.onDidEndTerminalShellExecution(async (event) => {
+        const execution = event.execution;
+        const terminal = event.terminal;
+        const commandLine = execution.commandLine.value;
+        const exitCode = event.exitCode;
+        const cwd = execution.cwd?.fsPath ?? 'unknown';
+        outputChannel.appendLine(`[Terminal] Command ended in "${terminal.name}": ${commandLine} (exit: ${exitCode})`);
+        // Get collected output
+        const outputState = activeCommandOutputs.get(execution);
+        activeCommandOutputs.delete(execution);
+        const output = outputState?.chunks.join('') ?? '';
+        const wasTruncated = outputState?.truncated ?? false;
+        // Write to terminal log file
+        await writeTerminalLogEntry(terminal.name, commandLine, wasTruncated ? `${output}\n…(truncated)` : output, exitCode, cwd, outputChannel);
+    }));
+    outputChannel.appendLine('[Terminal] Terminal activity logger activated');
+}
+function getTerminalLogDirUri() {
+    const root = (0, workspaceFolders_1.getPrimaryWorkspaceFolderUri)();
+    return root ? vscode.Uri.joinPath(root, branding_1.AGENTIDE_DIR_NAME, TERMINALS_DIR) : undefined;
+}
+/**
+ * Write a command execution entry to the terminal log file
+ */
+async function writeTerminalLogEntry(terminalName, commandLine, output, exitCode, cwd, outputChannel) {
+    const logDir = getTerminalLogDirUri();
+    if (!logDir) {
+        return;
+    }
+    const slug = terminalNameToSlug(terminalName);
+    const logUri = vscode.Uri.joinPath(logDir, `${slug}.md`);
+    try {
+        await ensureDirectory(logDir);
+        // Format the log entry
+        const nowIso = new Date().toISOString();
+        const cmdAnchor = commandLine.slice(0, 50).replace(/[^a-zA-Z0-9]+/g, '-').toLowerCase();
+        const exitStr = exitCode !== undefined ? `EXIT:${exitCode}` : 'EXIT:unknown';
+        const cwdRelative = toWorkspaceRelativePath(cwd);
+        const entry = [
+            '',
+            `<!-- CMD:${cmdAnchor} TIME:${nowIso} CWD:${cwdRelative} -->`,
+            `## \`${escapeMarkdown(commandLine)}\``,
+            `<!-- ${exitStr} -->`,
+            '',
+            '```text',
+            stripAnsiCodes(output.trim()),
+            '```',
+            '',
+            '---',
+        ].join('\n');
+        await appendTextFileWithRotation(logUri, entry + '\n', MAX_TERMINAL_LOG_BYTES);
+        outputChannel.appendLine(`[Terminal] Logged to ${slug}.md (max ${MAX_TERMINAL_LOG_BYTES} bytes)`);
+    }
+    catch (error) {
+        outputChannel.appendLine(`[Terminal] Failed to write log: ${error}`);
+    }
+}
+/**
+ * Convert absolute path to workspace-relative path
+ */
+function toWorkspaceRelativePath(absolutePath) {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders) {
+        return absolutePath;
+    }
+    for (const folder of workspaceFolders) {
+        const folderPath = folder.uri.fsPath;
+        // Case-insensitive comparison for Windows paths
+        if (absolutePath.toLowerCase().startsWith(folderPath.toLowerCase())) {
+            let relative = absolutePath.slice(folderPath.length).replace(/\\/g, '/');
+            if (relative && !relative.startsWith('/')) {
+                relative = '/' + relative;
+            }
+            return relative ? `.${relative}` : '.';
+        }
+    }
+    return absolutePath;
+}
+/**
+ * Escape markdown special characters
+ */
+function escapeMarkdown(text) {
+    return text.replace(/([`\\])/g, '\\$1');
+}
+/**
+ * Strip ANSI escape codes from text
+ */
+function stripAnsiCodes(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+// -----------------------------------------------------------------------------
+// Session Log Cleanup
+// -----------------------------------------------------------------------------
+/**
+ * Get the configured retention period in days.
+ * Reads from `agentide.sessions.retentionDays` setting, defaults to 7 days.
+ */
+function getRetentionDays() {
+    const config = vscode.workspace.getConfiguration('agentide.sessions');
+    const value = config.get('retentionDays');
+    if (typeof value === 'number' && value > 0) {
+        return value;
+    }
+    return DEFAULT_RETENTION_DAYS;
+}
+/**
+ * Get the sessions directory URI for the current workspace
+ */
+function getSessionsDirUri() {
+    const root = (0, workspaceFolders_1.getPrimaryWorkspaceFolderUri)();
+    return root ? vscode.Uri.joinPath(root, branding_1.AGENTIDE_DIR_NAME, SESSIONS_DIR) : undefined;
+}
+/**
+ * Delete a specific session's logs
+ */
+async function deleteSessionLogs(sessionId) {
+    const sessionsDir = getSessionsDirUri();
+    if (!sessionsDir) {
+        return { deleted: false, error: 'No workspace folder open' };
+    }
+    const sessionDir = vscode.Uri.joinPath(sessionsDir, sessionId);
+    try {
+        const stat = await statSafe(sessionDir);
+        if (!stat) {
+            return { deleted: false, error: 'Session directory not found' };
+        }
+        await vscode.workspace.fs.delete(sessionDir, { recursive: true, useTrash: false });
+        return { deleted: true };
+    }
+    catch (error) {
+        return { deleted: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * Cleanup old session logs based on retention period.
+ * Deletes session directories older than the configured retention period.
+ */
+async function cleanupOldSessionLogs(outputChannel) {
+    const sessionsDir = getSessionsDirUri();
+    const result = { cleaned: 0, errors: [] };
+    if (!sessionsDir) {
+        return result;
+    }
+    const retentionDays = getRetentionDays();
+    const cutoffMs = Date.now() - (retentionDays * 24 * 60 * 60 * 1000);
+    // Avoid noisy fs logs on first run when the directory doesn't exist yet
+    const sessionsDirStat = await statSafe(sessionsDir);
+    if (!sessionsDirStat) {
+        return result;
+    }
+    let entries;
+    try {
+        entries = await vscode.workspace.fs.readDirectory(sessionsDir);
+    }
+    catch {
+        // Sessions directory doesn't exist yet - nothing to clean
+        return result;
+    }
+    for (const [name, type] of entries) {
+        if (type !== vscode.FileType.Directory) {
+            continue;
+        }
+        const sessionDir = vscode.Uri.joinPath(sessionsDir, name);
+        // Check the modification time of the session directory
+        const stat = await statSafe(sessionDir);
+        if (!stat) {
+            continue;
+        }
+        if (stat.mtime < cutoffMs) {
+            try {
+                await vscode.workspace.fs.delete(sessionDir, { recursive: true, useTrash: false });
+                result.cleaned++;
+                outputChannel?.appendLine(`[Terminal] Cleaned up old session: ${name}`);
+            }
+            catch (error) {
+                const errMsg = `Failed to delete session ${name}: ${error instanceof Error ? error.message : String(error)}`;
+                result.errors.push(errMsg);
+                outputChannel?.appendLine(`[Terminal] ${errMsg}`);
+            }
+        }
+    }
+    if (result.cleaned > 0) {
+        outputChannel?.appendLine(`[Terminal] Cleaned up ${result.cleaned} old session(s) (retention: ${retentionDays} days)`);
+    }
+    return result;
+}
+/**
+ * Run cleanup of old session logs.
+ * Called when a session is closed/deleted - cleans up other old sessions opportunistically.
+ * This avoids the need for scheduled timers while still keeping things tidy.
+ */
+// Note: We intentionally do NOT export a "cleanup on close" helper.
+// The simplest model is: cleanup on startup + manual command.

package/out/test/agentEnvFile.test.js

@@ -0,0 +1,97 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const agentEnvFile_1 = require("../utils/agentEnvFile");
+suite('agentEnvFile', () => {
+    suite('parseEnvContent', () => {
+        test('parses keys, quotes, and comments', () => {
+            const parsed = (0, agentEnvFile_1.parseEnvContent)(`
+# comment
+CURSOR_API_KEY=crsr_test
+QUOTED="hello\\nworld"
+EMPTY=
+`);
+            assert.strictEqual(parsed.CURSOR_API_KEY, 'crsr_test');
+            assert.strictEqual(parsed.QUOTED, 'hello\nworld');
+            assert.strictEqual(parsed.EMPTY, '');
+        });
+    });
+    suite('mergeEnvIntoProcessEnv', () => {
+        test('does not overwrite existing process env keys', () => {
+            const target = { EXISTING: 'from-shell' };
+            const result = (0, agentEnvFile_1.mergeEnvIntoProcessEnv)({
+                EXISTING: 'from-file',
+                NEW_KEY: 'from-file',
+                ANOTHER: 'ok',
+            }, target);
+            assert.strictEqual(target.EXISTING, 'from-shell');
+            assert.strictEqual(target.NEW_KEY, 'from-file');
+            assert.strictEqual(target.ANOTHER, 'ok');
+            assert.deepStrictEqual(result.skipped, ['EXISTING']);
+            assert.deepStrictEqual(result.applied.sort(), ['ANOTHER', 'NEW_KEY']);
+        });
+    });
+    suite('buildGatewayChildProcessEnv', () => {
+        test('file wins for managed secret keys (token rotation)', () => {
+            const base = { SLACK_APP_TOKEN: 'xapp-old', PATH: '/usr/bin' };
+            const env = (0, agentEnvFile_1.buildGatewayChildProcessEnv)(base, {
+                SLACK_APP_TOKEN: 'xapp-new',
+                SLACK_BOT_TOKEN: 'xoxb-new',
+            });
+            assert.strictEqual(env.SLACK_APP_TOKEN, 'xapp-new');
+            assert.strictEqual(env.SLACK_BOT_TOKEN, 'xoxb-new');
+            assert.strictEqual(env.PATH, '/usr/bin');
+        });
+        test('shell still wins for non-secret keys', () => {
+            const base = { CUSTOM_KEY: 'from-shell' };
+            const env = (0, agentEnvFile_1.buildGatewayChildProcessEnv)(base, {
+                CUSTOM_KEY: 'from-file',
+                NEW_KEY: 'from-file',
+            });
+            assert.strictEqual(env.CUSTOM_KEY, 'from-shell');
+            assert.strictEqual(env.NEW_KEY, 'from-file');
+        });
+        test('empty file value does not clobber an existing secret', () => {
+            const base = { SLACK_APP_TOKEN: 'xapp-old' };
+            const env = (0, agentEnvFile_1.buildGatewayChildProcessEnv)(base, { SLACK_APP_TOKEN: '   ' });
+            assert.strictEqual(env.SLACK_APP_TOKEN, 'xapp-old');
+        });
+    });
+});