@zhijiewang/openharness 0.11.1 → 0.12.1

package/dist/mcp/registry.js

@@ -0,0 +1,180 @@
+/**
+ * MCP Server Registry — curated list of compatible MCP servers.
+ *
+ * Provides a browsable catalog of MCP servers that users can add
+ * to their .oh/config.yaml with a single command.
+ */
+/**
+ * Curated registry of popular MCP servers.
+ * Each entry has enough info to generate the config.yaml block.
+ */
+export const MCP_REGISTRY = [
+    // ── Filesystem ──
+    {
+        name: 'filesystem',
+        package: '@modelcontextprotocol/server-filesystem',
+        description: 'Read, write, and manage files on the local filesystem',
+        category: 'filesystem',
+        args: ['/tmp'],
+        riskLevel: 'medium',
+    },
+    // ── Git & GitHub ──
+    {
+        name: 'github',
+        package: '@modelcontextprotocol/server-github',
+        description: 'GitHub API — issues, PRs, repos, code search',
+        category: 'git',
+        envVars: ['GITHUB_PERSONAL_ACCESS_TOKEN'],
+        riskLevel: 'medium',
+    },
+    {
+        name: 'gitlab',
+        package: '@modelcontextprotocol/server-gitlab',
+        description: 'GitLab API — issues, merge requests, pipelines',
+        category: 'git',
+        envVars: ['GITLAB_PERSONAL_ACCESS_TOKEN', 'GITLAB_API_URL'],
+        riskLevel: 'medium',
+    },
+    // ── Database ──
+    {
+        name: 'sqlite',
+        package: '@modelcontextprotocol/server-sqlite',
+        description: 'Query and modify SQLite databases',
+        category: 'database',
+        args: ['./database.sqlite'],
+        riskLevel: 'medium',
+    },
+    {
+        name: 'postgres',
+        package: '@modelcontextprotocol/server-postgres',
+        description: 'Query PostgreSQL databases (read-only by default)',
+        category: 'database',
+        envVars: ['POSTGRES_CONNECTION_STRING'],
+        riskLevel: 'medium',
+    },
+    // ── Search & Web ──
+    {
+        name: 'brave-search',
+        package: '@modelcontextprotocol/server-brave-search',
+        description: 'Web search via Brave Search API',
+        category: 'search',
+        envVars: ['BRAVE_API_KEY'],
+        riskLevel: 'low',
+    },
+    {
+        name: 'fetch',
+        package: '@modelcontextprotocol/server-fetch',
+        description: 'Fetch and parse web pages, convert HTML to markdown',
+        category: 'search',
+        riskLevel: 'low',
+    },
+    // ── Productivity ──
+    {
+        name: 'slack',
+        package: '@modelcontextprotocol/server-slack',
+        description: 'Read and send Slack messages, list channels',
+        category: 'productivity',
+        envVars: ['SLACK_BOT_TOKEN'],
+        riskLevel: 'high',
+    },
+    {
+        name: 'google-drive',
+        package: '@anthropic/mcp-server-google-drive',
+        description: 'Search and read Google Drive documents',
+        category: 'productivity',
+        envVars: ['GOOGLE_DRIVE_CREDENTIALS'],
+        riskLevel: 'medium',
+    },
+    {
+        name: 'linear',
+        package: '@anthropic/mcp-server-linear',
+        description: 'Linear issue tracker — create, update, search issues',
+        category: 'productivity',
+        envVars: ['LINEAR_API_KEY'],
+        riskLevel: 'medium',
+    },
+    // ── Dev Tools ──
+    {
+        name: 'docker',
+        package: '@modelcontextprotocol/server-docker',
+        description: 'Manage Docker containers, images, and volumes',
+        category: 'dev-tools',
+        riskLevel: 'high',
+    },
+    {
+        name: 'puppeteer',
+        package: '@modelcontextprotocol/server-puppeteer',
+        description: 'Browser automation — navigate, screenshot, interact with web pages',
+        category: 'dev-tools',
+        riskLevel: 'medium',
+    },
+    {
+        name: 'memory',
+        package: '@modelcontextprotocol/server-memory',
+        description: 'Persistent knowledge graph for long-term memory',
+        category: 'ai',
+        riskLevel: 'low',
+    },
+    {
+        name: 'sequential-thinking',
+        package: '@modelcontextprotocol/server-sequential-thinking',
+        description: 'Step-by-step reasoning and chain-of-thought tools',
+        category: 'ai',
+        riskLevel: 'low',
+    },
+    {
+        name: 'context7',
+        package: '@anthropic/mcp-server-context7',
+        description: 'Fetch up-to-date library documentation for any framework',
+        category: 'dev-tools',
+        riskLevel: 'low',
+    },
+];
+/** Search the registry by name or keyword */
+export function searchRegistry(query) {
+    const q = query.toLowerCase();
+    return MCP_REGISTRY.filter(e => e.name.includes(q) ||
+        e.description.toLowerCase().includes(q) ||
+        e.category.includes(q) ||
+        e.package.toLowerCase().includes(q));
+}
+/** Get all entries in a category */
+export function getByCategory(category) {
+    return MCP_REGISTRY.filter(e => e.category === category);
+}
+/** Get all unique categories */
+export function getCategories() {
+    return [...new Set(MCP_REGISTRY.map(e => e.category))];
+}
+/** Generate the config.yaml block for a registry entry */
+export function generateConfigBlock(entry) {
+    const lines = [
+        `  - name: ${entry.name}`,
+        `    command: npx`,
+        `    args: ["-y", "${entry.package}"${entry.args ? ', ' + entry.args.map(a => `"${a}"`).join(', ') : ''}]`,
+    ];
+    if (entry.envVars && entry.envVars.length > 0) {
+        lines.push('    env:');
+        for (const v of entry.envVars) {
+            lines.push(`      ${v}: "YOUR_${v}"`);
+        }
+    }
+    if (entry.riskLevel && entry.riskLevel !== 'medium') {
+        lines.push(`    riskLevel: ${entry.riskLevel}`);
+    }
+    return lines.join('\n');
+}
+/** Format registry as a browsable list */
+export function formatRegistry(entries) {
+    const list = entries ?? MCP_REGISTRY;
+    const categories = [...new Set(list.map(e => e.category))];
+    const sections = [];
+    for (const cat of categories) {
+        const catEntries = list.filter(e => e.category === cat);
+        const header = cat.charAt(0).toUpperCase() + cat.slice(1).replace('-', ' ');
+        const rows = catEntries.map(e => `  ${e.name.padEnd(20)} ${e.description}${e.envVars ? ' [requires: ' + e.envVars.join(', ') + ']' : ''}`);
+        sections.push(`${header}:\n${rows.join('\n')}`);
+    }
+    return sections.join('\n\n');
+}
+//# sourceMappingURL=registry.js.map

package/dist/query/index.js

@@ -8,6 +8,7 @@
  * - types.ts — shared types
  */
 import { toolToAPIFormat } from "../Tool.js";
+import { DeferredTool } from "../DeferredTool.js";
 import { createAssistantMessage, createUserMessage } from "../types/message.js";
 import { StreamingToolExecutor } from "../services/StreamingToolExecutor.js";
 import { getContextWindow } from "../harness/cost.js";
@@ -34,9 +35,16 @@ export async function* query(userMessage, config, existingMessages = []) {
     const modelInfo = config.provider.getModelInfo?.(config.model ?? '');
     const toolsSupported = !modelInfo || modelInfo.supportsTools;
     const apiTools = toolsSupported ? config.tools.map(toolToAPIFormat) : undefined;
-    const toolPrompts = toolsSupported
+    let toolPrompts = toolsSupported
         ? config.tools.map((t) => t.prompt()).join("\n\n")
         : "";
+    // Hint about deferred tools available via ToolSearch
+    if (toolsSupported) {
+        const deferredCount = config.tools.filter(t => t instanceof DeferredTool && !t.activated).length;
+        if (deferredCount > 0) {
+            toolPrompts += `\n\n[${deferredCount} additional tools available — use ToolSearch to discover them]`;
+        }
+    }
     const fullSystemPrompt = toolPrompts
         ? config.systemPrompt + "\n\n# Available Tools\n\n" + toolPrompts
         : config.systemPrompt;

package/dist/query/tools.js

@@ -73,7 +73,7 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
     try {
         const toolAbort = AbortSignal.timeout(TOOL_TIMEOUT_MS);
         const contextWithTimeout = { ...context, abortSignal: context.abortSignal ?? toolAbort };
-        const result = await Promise.race([
+        let result = await Promise.race([
             tool.call(parsed.data, contextWithTimeout),
             new Promise((_, reject) => {
                 toolAbort.addEventListener("abort", () => reject(new Error(`Tool '${tool.name}' timed out after ${TOOL_TIMEOUT_MS / 1000}s`)));
@@ -85,11 +85,37 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
             toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),
             toolOutput: result.output.slice(0, 1000),
         });
-        // Strip ANSI and cap output
-        let output = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+        // Verification loop: auto-run lint/typecheck after file-modifying tools
+        let verificationSuffix = '';
+        if (!result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+            try {
+                const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import('../harness/verification.js');
+                const vConfig = getVerificationConfig();
+                if (vConfig?.enabled) {
+                    const filePaths = extractFilePaths(tool.name, parsed.data);
+                    if (filePaths.length > 0) {
+                        const vResult = await runVerificationForFiles(filePaths, vConfig);
+                        if (vResult.ran) {
+                            if (!vResult.passed) {
+                                verificationSuffix = `\n\n[Verification FAILED]\n${vResult.summary}`;
+                                if (vConfig.mode === 'block') {
+                                    result = { output: result.output, isError: true };
+                                }
+                            }
+                            else {
+                                verificationSuffix = '\n\n[Verification passed]';
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* verification should never break tool execution */ }
+        }
+        // Strip ANSI and cap output, then append verification suffix
+        let output = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "") + verificationSuffix;
         if (output.length > MAX_TOOL_RESULT_CHARS) {
             output = output.slice(0, MAX_TOOL_RESULT_CHARS)
-                + `\n\n[TRUNCATED: output was ${result.output.length.toLocaleString()} chars, showing first ${MAX_TOOL_RESULT_CHARS.toLocaleString()}]`;
+                + `\n\n[TRUNCATED: output was ${output.length.toLocaleString()} chars, showing first ${MAX_TOOL_RESULT_CHARS.toLocaleString()}]`;
         }
         return { output, isError: result.isError };
     }

package/dist/repl.js

@@ -48,9 +48,20 @@ export async function startREPL(config) {
     catch {
         session = createSession(config.provider.name, config.model ?? '', sessionExtras);
     }
+    // Wake context: inject session summary when resuming
+    if (config.resumeSessionId && session.hibernate) {
+        const { buildWakeContext } = await import('./harness/session.js');
+        const wakeMsg = buildWakeContext(session);
+        const { createInfoMessage } = await import('./types/message.js');
+        session.messages.push(createInfoMessage(wakeMsg));
+    }
     // Initialize checkpoints for file rewind
     const { initCheckpoints } = await import('./harness/checkpoints.js');
     initCheckpoints(session.id);
+    // Start background cron executor
+    const { CronExecutor } = await import('./services/CronExecutor.js');
+    const cronExecutor = new CronExecutor(config.provider, config.tools, config.systemPrompt, config.permissionMode, config.model);
+    cronExecutor.start();
     const cost = new CostTracker();
     let cachedConfig = readOhConfig();
     // Centralized state store — all REPL state lives here
@@ -598,6 +609,28 @@ export async function startREPL(config) {
         renderer.setError(null);
         // Exit
         if (input === 'exit' || input === 'quit' || input === '/exit' || input === '/quit' || input === '/q') {
+            // Hibernate: save session state for potential wake-up resume
+            try {
+                const { buildHibernateState } = await import('./harness/session.js');
+                session.hibernate = buildHibernateState(messages);
+            }
+            catch { /* ignore */ }
+            // Dream consolidation: prune stale memories before exit
+            try {
+                const { consolidateMemories } = await import('./harness/memory.js');
+                const { readOhConfig } = await import('./harness/config.js');
+                const ohCfg = readOhConfig();
+                if (ohCfg?.memory?.consolidateOnExit !== false) {
+                    consolidateMemories();
+                }
+            }
+            catch { /* ignore */ }
+            // Emit sessionEnd hook
+            try {
+                const { emitHookAsync } = await import('./harness/hooks.js');
+                await emitHookAsync('sessionEnd', {});
+            }
+            catch { /* ignore */ }
             cleanup();
             process.exit(0);
         }
@@ -890,6 +923,7 @@ export async function startREPL(config) {
         if (cleanedUp)
             return;
         cleanedUp = true;
+        cronExecutor.stop();
         renderer.stop();
         session.messages = messages;
         session.totalCost = cost.totalCost;

package/dist/services/AgentDispatcher.d.ts

@@ -13,6 +13,7 @@ export type AgentTask = {
     prompt: string;
     description?: string;
     blockedBy?: string[];
+    allowedTools?: string[];
 };
 export type AgentTaskResult = {
     id: string;

package/dist/services/AgentDispatcher.js

@@ -113,9 +113,18 @@ export class AgentDispatcher {
         }
         try {
             const { query } = await import('../query.js');
+            // Filter tools if task specifies allowed tools
+            let taskTools = this.tools;
+            if (task.allowedTools && task.allowedTools.length > 0) {
+                const allowSet = new Set(task.allowedTools.map(n => n.toLowerCase()));
+                allowSet.add('askuser');
+                const filtered = this.tools.filter(t => allowSet.has(t.name.toLowerCase()));
+                if (filtered.length > 0)
+                    taskTools = filtered;
+            }
             const config = {
                 provider: this.provider,
-                tools: this.tools,
+                tools: taskTools,
                 systemPrompt: this.systemPrompt,
                 permissionMode: this.permissionMode,
                 model: this.model,

package/dist/services/CronExecutor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CronExecutor — background scheduler that runs due cron tasks.
+ *
+ * Checks every 60 seconds for crons that are due, then executes each
+ * by running the cron's prompt through a sub-query loop. Results are
+ * persisted to ~/.oh/crons/history/ for debugging and audit.
+ *
+ * Execution is non-blocking and failure-isolated — one failing cron
+ * does not affect others or the main REPL session.
+ */
+import type { Provider } from '../providers/base.js';
+import type { Tools } from '../Tool.js';
+import type { PermissionMode } from '../types/permissions.js';
+import { type CronResult } from './cron.js';
+export declare class CronExecutor {
+    private provider;
+    private tools;
+    private systemPrompt;
+    private permissionMode;
+    private model?;
+    private intervalId;
+    private running;
+    private _stopped;
+    constructor(provider: Provider, tools: Tools, systemPrompt: string, permissionMode: PermissionMode, model?: string | undefined);
+    /** Start the background scheduler */
+    start(): void;
+    /** Stop the scheduler */
+    stop(): void;
+    /** Check for due crons and execute them */
+    tick(): Promise<CronResult[]>;
+    /** Execute a single cron task */
+    private executeCron;
+    /** Whether the executor is currently running */
+    get isRunning(): boolean;
+    /** Get IDs of currently executing crons */
+    get activeIds(): string[];
+}
+//# sourceMappingURL=CronExecutor.d.ts.map

package/dist/services/CronExecutor.js

@@ -0,0 +1,130 @@
+/**
+ * CronExecutor — background scheduler that runs due cron tasks.
+ *
+ * Checks every 60 seconds for crons that are due, then executes each
+ * by running the cron's prompt through a sub-query loop. Results are
+ * persisted to ~/.oh/crons/history/ for debugging and audit.
+ *
+ * Execution is non-blocking and failure-isolated — one failing cron
+ * does not affect others or the main REPL session.
+ */
+import { listCrons, getDueCrons, updateCron, saveCronResult, } from './cron.js';
+const CHECK_INTERVAL_MS = 60_000; // Check every 60 seconds
+const MAX_CRON_TURNS = 10; // Limit sub-query turns for cron tasks
+export class CronExecutor {
+    provider;
+    tools;
+    systemPrompt;
+    permissionMode;
+    model;
+    intervalId = null;
+    running = new Set(); // Prevent overlapping executions
+    _stopped = false;
+    constructor(provider, tools, systemPrompt, permissionMode, model) {
+        this.provider = provider;
+        this.tools = tools;
+        this.systemPrompt = systemPrompt;
+        this.permissionMode = permissionMode;
+        this.model = model;
+    }
+    /** Start the background scheduler */
+    start() {
+        if (this.intervalId)
+            return;
+        this._stopped = false;
+        // Run first tick after a short delay (don't block startup)
+        setTimeout(() => {
+            if (!this._stopped)
+                this.tick().catch(() => { });
+        }, 5_000);
+        // Then check every 60 seconds
+        this.intervalId = setInterval(() => {
+            if (!this._stopped)
+                this.tick().catch(() => { });
+        }, CHECK_INTERVAL_MS);
+    }
+    /** Stop the scheduler */
+    stop() {
+        this._stopped = true;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    /** Check for due crons and execute them */
+    async tick() {
+        const allCrons = listCrons();
+        const due = getDueCrons(allCrons);
+        const results = [];
+        for (const cron of due) {
+            // Skip if already running (prevent overlapping executions)
+            if (this.running.has(cron.id))
+                continue;
+            try {
+                const result = await this.executeCron(cron);
+                results.push(result);
+            }
+            catch (err) {
+                // Never let a single cron failure crash the scheduler
+                const result = {
+                    cronId: cron.id,
+                    timestamp: Date.now(),
+                    output: '',
+                    error: err instanceof Error ? err.message : String(err),
+                };
+                saveCronResult(result);
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    /** Execute a single cron task */
+    async executeCron(cron) {
+        this.running.add(cron.id);
+        const timestamp = Date.now();
+        try {
+            const { query } = await import('../query.js');
+            const config = {
+                provider: this.provider,
+                tools: this.tools,
+                systemPrompt: `[Cron Task: ${cron.name}]\n\n${this.systemPrompt}`,
+                permissionMode: this.permissionMode,
+                model: this.model,
+                maxTurns: MAX_CRON_TURNS,
+            };
+            let output = '';
+            for await (const event of query(cron.prompt, config)) {
+                if (event.type === 'text_delta')
+                    output += event.content;
+                if (event.type === 'error') {
+                    const result = { cronId: cron.id, timestamp, output, error: event.message };
+                    saveCronResult(result);
+                    // Still update lastRun on error to prevent rapid retry loops
+                    cron.lastRun = Date.now();
+                    cron.runCount++;
+                    updateCron(cron);
+                    return result;
+                }
+            }
+            // Success: update cron metadata and save result
+            cron.lastRun = Date.now();
+            cron.runCount++;
+            updateCron(cron);
+            const result = { cronId: cron.id, timestamp, output };
+            saveCronResult(result);
+            return result;
+        }
+        finally {
+            this.running.delete(cron.id);
+        }
+    }
+    /** Whether the executor is currently running */
+    get isRunning() {
+        return this.intervalId !== null && !this._stopped;
+    }
+    /** Get IDs of currently executing crons */
+    get activeIds() {
+        return [...this.running];
+    }
+}
+//# sourceMappingURL=CronExecutor.js.map

package/dist/services/StreamingToolExecutor.js

@@ -94,6 +94,34 @@ export class StreamingToolExecutor {
         };
         try {
             tracked.result = await tool.call(parsed.data, callContext);
+            // Verification loop: auto-run lint/typecheck after file-modifying tools
+            if (tracked.result && !tracked.result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+                try {
+                    const { runVerificationForFiles, getVerificationConfig, extractFilePaths } = await import('../harness/verification.js');
+                    const vConfig = getVerificationConfig();
+                    if (vConfig?.enabled) {
+                        const filePaths = extractFilePaths(tool.name, tracked.toolCall.arguments);
+                        if (filePaths.length > 0) {
+                            const vResult = await runVerificationForFiles(filePaths, vConfig);
+                            if (vResult.ran) {
+                                if (!vResult.passed) {
+                                    tracked.result = {
+                                        output: tracked.result.output + `\n\n[Verification FAILED]\n${vResult.summary}`,
+                                        isError: vConfig.mode === 'block',
+                                    };
+                                }
+                                else {
+                                    tracked.result = {
+                                        output: tracked.result.output + '\n\n[Verification passed]',
+                                        isError: false,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+                catch { /* verification should never break tool execution */ }
+            }
         }
         catch (err) {
             tracked.result = {

package/dist/services/cron.d.ts

@@ -33,6 +33,10 @@ export declare function deleteCron(id: string): boolean;
 export declare function updateCron(cron: CronDefinition): void;
 /** Parse a simplified schedule string into milliseconds interval */
 export declare function parseScheduleMs(schedule: string): number | null;
+/** Save a cron execution result to history */
+export declare function saveCronResult(result: CronResult): void;
+/** Get execution history for a cron (most recent first) */
+export declare function getCronHistory(cronId: string, limit?: number): CronResult[];
 /**
  * Check which crons are due to run based on their schedule and lastRun.
  */

package/dist/services/cron.js

@@ -72,6 +72,33 @@ export function parseScheduleMs(schedule) {
         return parseInt(dayMatch[1]) * 24 * 60 * 60 * 1000;
     return null;
 }
+// ── Result Persistence ──
+const HISTORY_DIR = join(CRON_DIR, 'history');
+/** Save a cron execution result to history */
+export function saveCronResult(result) {
+    mkdirSync(HISTORY_DIR, { recursive: true });
+    const filename = `${result.cronId}-${result.timestamp}.json`;
+    writeFileSync(join(HISTORY_DIR, filename), JSON.stringify(result, null, 2));
+}
+/** Get execution history for a cron (most recent first) */
+export function getCronHistory(cronId, limit = 10) {
+    if (!existsSync(HISTORY_DIR))
+        return [];
+    return readdirSync(HISTORY_DIR)
+        .filter(f => f.startsWith(`${cronId}-`) && f.endsWith('.json'))
+        .sort()
+        .reverse()
+        .slice(0, limit)
+        .map(f => {
+        try {
+            return JSON.parse(readFileSync(join(HISTORY_DIR, f), 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((r) => r !== null);
+}
 /**
  * Check which crons are due to run based on their schedule and lastRun.
  */

package/dist/tools/AgentTool/index.d.ts

@@ -7,6 +7,7 @@ declare const inputSchema: z.ZodObject<{
     run_in_background: z.ZodOptional<z.ZodBoolean>;
     model: z.ZodOptional<z.ZodString>;
     subagent_type: z.ZodOptional<z.ZodString>;
+    allowed_tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model?: string | undefined;
@@ -14,6 +15,7 @@ declare const inputSchema: z.ZodObject<{
     run_in_background?: boolean | undefined;
     isolated?: boolean | undefined;
     subagent_type?: string | undefined;
+    allowed_tools?: string[] | undefined;
 }, {
     prompt: string;
     model?: string | undefined;
@@ -21,6 +23,7 @@ declare const inputSchema: z.ZodObject<{
     run_in_background?: boolean | undefined;
     isolated?: boolean | undefined;
     subagent_type?: string | undefined;
+    allowed_tools?: string[] | undefined;
 }>;
 export declare const AgentTool: Tool<typeof inputSchema>;
 export {};