camo-cli 2.0.1

package/dist/utils/MessageHistory.js

@@ -0,0 +1,55 @@
+/**
+ * Message History - Persistent conversation state for n0 loop
+ */
+class MessageHistoryManager {
+    constructor() {
+        this.messages = [];
+    }
+    static getInstance() {
+        if (!MessageHistoryManager.instance) {
+            MessageHistoryManager.instance = new MessageHistoryManager();
+        }
+        return MessageHistoryManager.instance;
+    }
+    addUser(content) {
+        this.messages.push({
+            role: 'user',
+            content,
+            timestamp: Date.now()
+        });
+    }
+    addAssistant(content) {
+        this.messages.push({
+            role: 'assistant',
+            content,
+            timestamp: Date.now()
+        });
+    }
+    addToolResult(toolName, toolCallId, result) {
+        this.messages.push({
+            role: 'tool',
+            content: result,
+            toolName,
+            toolCallId,
+            timestamp: Date.now()
+        });
+    }
+    getAll() {
+        return [...this.messages];
+    }
+    getForLLM() {
+        return this.messages.map(m => ({
+            role: m.role === 'tool' ? 'user' : m.role,
+            content: m.role === 'tool'
+                ? `[TOOL_RESULT:${m.toolName}] ${m.content}`
+                : m.content
+        }));
+    }
+    clear() {
+        this.messages = [];
+    }
+    get length() {
+        return this.messages.length;
+    }
+}
+export const MessageHistory = MessageHistoryManager.getInstance();

package/dist/utils/PermissionManager.js

@@ -0,0 +1,253 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class PermissionManager {
+    constructor() {
+        this.sessionAllowedResources = new Set();
+        this.sessionAllowedPaths = new Set();
+        // Safe-List: Tools that auto-execute without HITL
+        this.SAFE_TOOLS = new Set([
+            'readFile',
+            'listFiles',
+            'listSymbols',
+            'grep',
+            'internal_thought',
+            'ToDoWrite'
+        ]);
+        // Safe shell command patterns
+        this.SAFE_SHELL_PATTERNS = [
+            // Git read operations
+            /^git\s+(status|log|diff|show|branch|remote|config\s+--get)/,
+            // File listing
+            /^(ls|dir|find|tree|pwd|whoami)\s/,
+            /^(ls|dir|pwd|whoami)$/,
+            // File reading
+            /^(cat|head|tail|less|more|grep|rg|ag)\s/,
+            // Package managers (read-only)
+            /^(npm|yarn|pnpm)\s+(list|ls|view|info|outdated|audit)\s/,
+            /^(npm|yarn|pnpm)\s+-v$/,
+            /^node\s+-v$/,
+            // Testing (read-only execution, no modifications)
+            /^(npm|yarn|pnpm)\s+(test|t)\s/,
+            /^(jest|vitest|mocha|ava)\s/,
+            // Build tools (read-only check)
+            /^(tsc|eslint|prettier)\s+--noEmit/,
+            // Other safe commands
+            /^(date|echo|printf|which|type|command\s+-v)/
+        ];
+        // Critical shell command patterns (require HITL)
+        this.CRITICAL_SHELL_PATTERNS = [
+            /^(rm|mv|cp)\s/,
+            /^git\s+(push|commit|add|reset|rebase|merge|cherry-pick|pull)/,
+            /^(npm|yarn|pnpm)\s+(install|i|add|remove|uninstall|publish|run\s+(?!test))/,
+            /^(curl|wget|fetch)\s/,
+            /^chmod\s/,
+            /^sudo\s/,
+            />/, // Output redirection
+            />>/ // Append redirection
+        ];
+        // BLOCKED commands - never allowed, even with HITL
+        this.BLOCKED_COMMANDS = [
+            /^sudo\s+rm\s+-rf\s+\/$/,
+            /^rm\s+-rf\s+\/$/,
+            /^rm\s+-rf\s+~$/,
+            /^chmod\s+777\s+\/$/,
+            /^:(){ :\|:& };:/, // Fork bomb
+            /^dd\s+if=.*of=\/dev\//,
+            /^mkfs\./,
+            /^format\s/
+        ];
+        this.mode = 'manual';
+        this.logPath = path.join(process.cwd(), '.camo', 'permissions.log');
+        this.ensureLogDir();
+    }
+    static getInstance() {
+        if (!PermissionManager.instance) {
+            PermissionManager.instance = new PermissionManager();
+        }
+        return PermissionManager.instance;
+    }
+    async ensureLogDir() {
+        try {
+            await fs.mkdir(path.dirname(this.logPath), { recursive: true });
+        }
+        catch (e) { /* ignore */ }
+    }
+    async logDecision(type, resource, decision, reason, scope) {
+        // Redact secrets from log
+        const sanitizedResource = this.redactSecrets(resource);
+        const entry = `[${new Date().toISOString()}] [${type}] [${decision}] [${scope}] Resource: "${sanitizedResource}" | Reason: ${reason}\n`;
+        try {
+            await fs.appendFile(this.logPath, entry, 'utf-8');
+        }
+        catch (e) { /* ignore logging errors */ }
+    }
+    redactSecrets(text) {
+        // Redact common secret patterns
+        return text
+            .replace(/AIza[A-Za-z0-9_-]{35}/g, '[REDACTED_API_KEY]')
+            .replace(/sk-[A-Za-z0-9]{48}/g, '[REDACTED_API_KEY]')
+            .replace(/ghp_[A-Za-z0-9]{36}/g, '[REDACTED_TOKEN]')
+            .replace(/password[=:]\S+/gi, 'password=[REDACTED]')
+            .replace(/token[=:]\S+/gi, 'token=[REDACTED]');
+    }
+    isPathSafe(targetPath) {
+        const resolved = path.resolve(process.cwd(), targetPath);
+        const projectRoot = process.cwd();
+        return resolved.startsWith(projectRoot);
+    }
+    isCommandBlocked(command) {
+        return this.BLOCKED_COMMANDS.some(pattern => pattern.test(command.trim()));
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    getMode() {
+        return this.mode;
+    }
+    async validate(type, context, callbacks) {
+        const resource = this.getResourceId(type, context);
+        // 0. BLOCKED commands - never allowed
+        if (type === 'SHELL' && context.command && this.isCommandBlocked(context.command)) {
+            await this.logDecision(type, resource, 'DENIED', 'Blocked dangerous command', 'AUTO');
+            callbacks.onChunk('\n[SECURITY] Command blocked: dangerous operation not allowed.\n');
+            return false;
+        }
+        // 0b. Path sandboxing - reject writes outside project
+        if (type === 'FILE_WRITE' && context.path && !this.isPathSafe(context.path)) {
+            await this.logDecision(type, resource, 'DENIED', 'Path outside project root', 'AUTO');
+            callbacks.onChunk('\n[SECURITY] Write blocked: path outside project root.\n');
+            return false;
+        }
+        // 1. Safe-List Check for Tools (Auto-Execute)
+        if (context.toolName && this.SAFE_TOOLS.has(context.toolName)) {
+            await this.logDecision(type, resource, 'APPROVED', 'Safe-List Tool', 'AUTO');
+            return true;
+        }
+        // 2. Session Allow-List Check
+        if (this.sessionAllowedResources.has(resource)) {
+            await this.logDecision(type, resource, 'APPROVED', 'Session Allowed', 'SESSION');
+            return true;
+        }
+        // 3. Session Path Trust Check (for FILE_WRITE)
+        if (type === 'FILE_WRITE' && context.path) {
+            const normalizedPath = path.resolve(process.cwd(), context.path);
+            if (this.sessionAllowedPaths.has(normalizedPath)) {
+                await this.logDecision(type, resource, 'APPROVED', 'Session Trusted Path', 'SESSION');
+                return true;
+            }
+        }
+        // 4. Auto-Allow Safety Checks (Only in AUTO mode or for explicitly safe types)
+        const { isSafe, reason } = this.checkSafety(type, context);
+        if (isSafe) {
+            await this.logDecision(type, resource, 'APPROVED', reason, 'AUTO');
+            return true;
+        }
+        // 5. HITL Trigger for Critical Operations
+        const hitlResult = await callbacks.onHITL({
+            id: Date.now().toString(),
+            type: type,
+            command: context.command,
+            path: context.path,
+            diff: context.diff,
+            reason: reason,
+            mode: this.mode
+        });
+        if (hitlResult.approved) {
+            if (hitlResult.scope === 'session') {
+                this.sessionAllowedResources.add(resource);
+                // For FILE_WRITE, also trust the path
+                if (type === 'FILE_WRITE' && context.path) {
+                    const normalizedPath = path.resolve(process.cwd(), context.path);
+                    this.sessionAllowedPaths.add(normalizedPath);
+                }
+                await this.logDecision(type, resource, 'APPROVED', 'User Approved (Session)', 'SESSION');
+            }
+            else {
+                await this.logDecision(type, resource, 'APPROVED', 'User Approved (Once)', 'ONCE');
+            }
+            return true;
+        }
+        else {
+            await this.logDecision(type, resource, 'DENIED', 'User Denied', 'ONCE');
+            return false;
+        }
+    }
+    getResourceId(type, context) {
+        if (type === 'SHELL')
+            return `SHELL:${context.command}`;
+        if (type === 'FILE_WRITE')
+            return `WRITE:${context.path}`;
+        if (type === 'FILE_READ')
+            return `READ:${context.path}`;
+        if (type === 'WEB_ACCESS')
+            return `WEB:${context.url}`;
+        return 'UNKNOWN';
+    }
+    checkSafety(type, context) {
+        // FILE_READ is always safe (auto-execute)
+        if (type === 'FILE_READ') {
+            return { isSafe: true, reason: 'Safe read operation' };
+        }
+        // SHELL command analysis
+        if (type === 'SHELL' && context.command) {
+            // MANUAL MODE: Require approval for ALL shell commands
+            if (this.mode === 'manual') {
+                return { isSafe: false, reason: 'Manual Mode: Shell commands require approval' };
+            }
+            const cmd = context.command.trim();
+            // Check if command matches safe patterns
+            const isSafeCommand = this.SAFE_SHELL_PATTERNS.some(pattern => pattern.test(cmd));
+            if (isSafeCommand) {
+                return { isSafe: true, reason: 'Safe read-only command' };
+            }
+            // Check if command matches critical patterns
+            const isCritical = this.CRITICAL_SHELL_PATTERNS.some(pattern => pattern.test(cmd));
+            if (isCritical) {
+                return { isSafe: false, reason: 'Critical operation requires approval' };
+            }
+            // Additional path check for unlisted commands
+            const paths = this.extractPaths(cmd);
+            const isInternal = paths.length === 0 || paths.every(p => p.startsWith(process.cwd()));
+            if (!isInternal) {
+                return { isSafe: false, reason: 'Accessing files outside project' };
+            }
+            // Default to requiring approval for unknown commands
+            return { isSafe: false, reason: 'Unknown command, requires approval' };
+        }
+        // WEB_ACCESS whitelist check
+        if (type === 'WEB_ACCESS' && context.url) {
+            const url = context.url;
+            const inUserMsg = context.userMessage?.includes(url);
+            const inProject = context.projectContext?.includes(url);
+            if (inUserMsg || inProject) {
+                return { isSafe: true, reason: 'URL mentioned in user request' };
+            }
+            return { isSafe: false, reason: 'External URL not explicitly requested' };
+        }
+        // FILE_WRITE always requires approval (unless session trusted)
+        if (type === 'FILE_WRITE') {
+            return { isSafe: false, reason: 'File modification requires approval' };
+        }
+        return { isSafe: false, reason: 'Unknown operation' };
+    }
+    extractPaths(cmd) {
+        const parts = cmd.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+        const commandWords = ['ls', 'cat', 'grep', 'find', 'git', 'npm', 'yarn', 'pnpm', 'node', 'echo', 'pwd', 'jest', 'vitest', 'mocha', 'tsc', 'eslint'];
+        const potentialPaths = parts.filter(p => !p.startsWith('-') &&
+            !commandWords.includes(p.replace(/['"]/g, '')));
+        return potentialPaths.map(p => {
+            const clean = p.replace(/['"]/g, '');
+            try {
+                return path.resolve(process.cwd(), clean);
+            }
+            catch {
+                return clean;
+            }
+        });
+    }
+    // Clear session trust (for testing or explicit reset)
+    clearSessionTrust() {
+        this.sessionAllowedResources.clear();
+        this.sessionAllowedPaths.clear();
+    }
+}

package/dist/utils/SessionManager.js

@@ -0,0 +1,180 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class SessionManager {
+    constructor() {
+        this.currentSession = null;
+        this.autoSaveInterval = null;
+        this.sessionDir = path.join(process.cwd(), '.camo', 'sessions');
+        this.ensureSessionDir();
+    }
+    static getInstance() {
+        if (!SessionManager.instance) {
+            SessionManager.instance = new SessionManager();
+        }
+        return SessionManager.instance;
+    }
+    async ensureSessionDir() {
+        try {
+            await fs.mkdir(this.sessionDir, { recursive: true });
+        }
+        catch (e) { /* ignore */ }
+    }
+    /**
+     * Create a new session
+     */
+    async createSession() {
+        const sessionId = `session-${Date.now()}`;
+        this.currentSession = {
+            sessionId,
+            createdAt: Date.now(),
+            lastUpdatedAt: Date.now(),
+            messages: [],
+            metadata: {
+                totalTokens: 0,
+                totalCost: 0,
+                toolsUsed: []
+            }
+        };
+        await this.saveSession();
+        this.startAutoSave();
+        return sessionId;
+    }
+    /**
+     * Resume an existing session
+     */
+    async resumeSession(sessionId) {
+        try {
+            const sessionPath = path.join(this.sessionDir, `${sessionId}.json`);
+            const data = await fs.readFile(sessionPath, 'utf-8');
+            this.currentSession = JSON.parse(data);
+            this.startAutoSave();
+            return this.currentSession;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Get the latest session (for auto-resume)
+     */
+    async getLatestSession() {
+        try {
+            const files = await fs.readdir(this.sessionDir);
+            const sessionFiles = files.filter(f => f.startsWith('session-') && f.endsWith('.json'));
+            if (sessionFiles.length === 0)
+                return null;
+            // Sort by timestamp (newest first)
+            sessionFiles.sort().reverse();
+            const latestFile = sessionFiles[0];
+            const sessionPath = path.join(this.sessionDir, latestFile);
+            const data = await fs.readFile(sessionPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Add a message to the current session
+     */
+    addMessage(message) {
+        if (!this.currentSession)
+            return;
+        this.currentSession.messages.push(message);
+        this.currentSession.lastUpdatedAt = Date.now();
+    }
+    /**
+     * Update session metadata
+     */
+    updateMetadata(updates) {
+        if (!this.currentSession)
+            return;
+        this.currentSession.metadata = {
+            ...this.currentSession.metadata,
+            ...updates
+        };
+        this.currentSession.lastUpdatedAt = Date.now();
+    }
+    /**
+     * Save current session to disk
+     */
+    async saveSession() {
+        if (!this.currentSession)
+            return;
+        try {
+            const sessionPath = path.join(this.sessionDir, `${this.currentSession.sessionId}.json`);
+            await fs.writeFile(sessionPath, JSON.stringify(this.currentSession, null, 2), 'utf-8');
+        }
+        catch (e) {
+            console.error('Failed to save session:', e);
+        }
+    }
+    /**
+     * Auto-save every 30 seconds
+     */
+    startAutoSave() {
+        if (this.autoSaveInterval) {
+            clearInterval(this.autoSaveInterval);
+        }
+        this.autoSaveInterval = setInterval(() => {
+            this.saveSession();
+        }, 30000); // 30 seconds
+    }
+    /**
+     * Stop auto-save
+     */
+    stopAutoSave() {
+        if (this.autoSaveInterval) {
+            clearInterval(this.autoSaveInterval);
+            this.autoSaveInterval = null;
+        }
+    }
+    /**
+     * Get current session
+     */
+    getCurrentSession() {
+        return this.currentSession;
+    }
+    /**
+     * List all sessions
+     */
+    async listSessions() {
+        try {
+            const files = await fs.readdir(this.sessionDir);
+            const sessionFiles = files.filter(f => f.startsWith('session-') && f.endsWith('.json'));
+            const sessions = await Promise.all(sessionFiles.map(async (file) => {
+                const sessionPath = path.join(this.sessionDir, file);
+                const data = await fs.readFile(sessionPath, 'utf-8');
+                const session = JSON.parse(data);
+                return {
+                    id: session.sessionId,
+                    createdAt: session.createdAt,
+                    messageCount: session.messages.length
+                };
+            }));
+            return sessions.sort((a, b) => b.createdAt - a.createdAt);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Delete a session
+     */
+    async deleteSession(sessionId) {
+        try {
+            const sessionPath = path.join(this.sessionDir, `${sessionId}.json`);
+            await fs.unlink(sessionPath);
+        }
+        catch (e) {
+            console.error('Failed to delete session:', e);
+        }
+    }
+    /**
+     * Cleanup: Save and stop auto-save
+     */
+    async cleanup() {
+        await this.saveSession();
+        this.stopAutoSave();
+    }
+}

package/dist/utils/TaskState.js

@@ -0,0 +1,108 @@
+/**
+ * TaskState - Persistent state for two-phase agent execution
+ */
+class TaskStateManager {
+    constructor() {
+        this.state = {
+            phase: 'idle',
+            originalTask: '',
+            plan: [],
+            currentTaskIndex: 0,
+            errorCount: 0,
+            lastError: null
+        };
+    }
+    static getInstance() {
+        if (!TaskStateManager.instance) {
+            TaskStateManager.instance = new TaskStateManager();
+        }
+        return TaskStateManager.instance;
+    }
+    // Start new task - enters planning phase
+    startTask(userInput) {
+        this.state = {
+            phase: 'planning',
+            originalTask: userInput,
+            plan: [],
+            currentTaskIndex: 0,
+            errorCount: 0,
+            lastError: null
+        };
+    }
+    // Set plan from manageTasks
+    setPlan(tasks) {
+        this.state.plan = tasks;
+        this.state.phase = 'awaiting_approval';
+    }
+    // User approved - start execution
+    approve() {
+        this.state.phase = 'executing';
+        this.state.currentTaskIndex = 0;
+    }
+    // Mark current task in progress
+    startCurrentTask() {
+        if (this.state.plan[this.state.currentTaskIndex]) {
+            this.state.plan[this.state.currentTaskIndex].status = 'in_progress';
+        }
+    }
+    // Complete current task and advance
+    completeCurrentTask() {
+        if (this.state.plan[this.state.currentTaskIndex]) {
+            this.state.plan[this.state.currentTaskIndex].status = 'completed';
+            this.state.currentTaskIndex++;
+        }
+        // Check if all done
+        if (this.state.currentTaskIndex >= this.state.plan.length) {
+            this.state.phase = 'complete';
+        }
+    }
+    // Record error for self-correction
+    recordError(error) {
+        this.state.errorCount++;
+        this.state.lastError = error;
+    }
+    // Reset state
+    reset() {
+        this.state = {
+            phase: 'idle',
+            originalTask: '',
+            plan: [],
+            currentTaskIndex: 0,
+            errorCount: 0,
+            lastError: null
+        };
+    }
+    // Getters
+    get phase() { return this.state.phase; }
+    get originalTask() { return this.state.originalTask; }
+    get plan() { return this.state.plan; }
+    get currentTaskIndex() { return this.state.currentTaskIndex; }
+    get totalTasks() { return this.state.plan.length; }
+    get progress() {
+        return `${this.state.currentTaskIndex + 1}/${this.state.plan.length}`;
+    }
+    get isComplete() { return this.state.phase === 'complete'; }
+    get hasError() { return this.state.lastError !== null; }
+    get lastError() { return this.state.lastError; }
+    // Get state for context injection
+    getContextString() {
+        if (this.state.phase === 'idle')
+            return '';
+        let ctx = `\n**TASK STATE**\n`;
+        ctx += `Original: ${this.state.originalTask}\n`;
+        ctx += `Phase: ${this.state.phase}\n`;
+        if (this.state.plan.length > 0) {
+            ctx += `Plan:\n`;
+            this.state.plan.forEach((t, i) => {
+                const marker = t.status === 'completed' ? '✓' : t.status === 'in_progress' ? '→' : ' ';
+                ctx += `  [${marker}] ${i + 1}. ${t.title}\n`;
+            });
+            ctx += `Progress: ${this.progress}\n`;
+        }
+        if (this.state.lastError) {
+            ctx += `Last Error: ${this.state.lastError}\n`;
+        }
+        return ctx;
+    }
+}
+export const TaskState = TaskStateManager.getInstance();

package/dist/utils/debug.js

@@ -0,0 +1,35 @@
+/**
+ * Debug utilities
+ */
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+const DEBUG_LOG_FILE = path.join(homedir(), '.camo-debug.log');
+export async function debugLog(message, data) {
+    try {
+        const timestamp = new Date().toISOString();
+        let logLine = `[${timestamp}] ${message}`;
+        if (data) {
+            // Hide sensitive data
+            const sanitized = JSON.stringify(data)
+                .replace(/"apiKey":"[^"]*"/g, '"apiKey":"***"')
+                .replace(/"api_key":"[^"]*"/g, '"api_key":"***"');
+            logLine += ` ${sanitized}`;
+        }
+        await fs.appendFile(DEBUG_LOG_FILE, logLine + '\n', 'utf-8');
+    }
+    catch (e) {
+        // Silent fail
+    }
+}
+export function isDebugEnabled() {
+    return process.env.CAMO_DEBUG === '1' || process.env.CAMO_DEBUG === 'true';
+}
+export async function getDebugLog() {
+    try {
+        return await fs.readFile(DEBUG_LOG_FILE, 'utf-8');
+    }
+    catch {
+        return 'No debug log found';
+    }
+}

package/dist/utils/execAsync.js

@@ -0,0 +1,3 @@
+import { promisify } from 'util';
+import { exec } from 'child_process';
+export const execAsync = promisify(exec);

package/dist/utils/retry.js

@@ -0,0 +1,50 @@
+/**
+ * Retry utility with exponential backoff
+ */
+const defaultOptions = {
+    maxAttempts: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 10000,
+};
+export async function withRetry(fn, options = {}) {
+    const opts = { ...defaultOptions, ...options };
+    let lastError = null;
+    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === opts.maxAttempts) {
+                break;
+            }
+            // Exponential backoff: 1s, 2s, 4s...
+            const delay = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
+            opts.onRetry?.(attempt, error);
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Execute with timeout
+ */
+export function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(errorMessage));
+        }, timeoutMs);
+        promise
+            .then(result => {
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch(error => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}