owflow 0.5.0 → 0.7.0

package/dist/hooks/runtime/process-executor.js

@@ -0,0 +1,147 @@
+export const DEFAULT_HOOK_TIMEOUT_MS = 120_000;
+export const HOOK_TIMEOUT_ENV = 'OWFLOW_HOOK_TIMEOUT_MS';
+export const MAX_STREAM_BUFFER_BYTES = 4 * 1024 * 1024;
+export class HookSpawnError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(originalError instanceof Error ? originalError.message : String(originalError));
+        this.originalError = originalError;
+        this.name = 'HookSpawnError';
+    }
+}
+export const buildExecutionArgs = (entry) => {
+    const resolvedLower = (entry.interpreter.resolved ?? '').toLowerCase();
+    const isPowerShell = entry.path.endsWith('.ps1') || entry.interpreter.expected === 'pwsh' || resolvedLower.includes('powershell') || resolvedLower.includes('pwsh');
+    if (isPowerShell) {
+        return [entry.interpreter.resolved, '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', entry.path];
+    }
+    return [entry.interpreter.resolved, entry.path];
+};
+export const readStream = async (stream, onChunk, maxBytes = MAX_STREAM_BUFFER_BYTES) => {
+    if (!stream)
+        return '';
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let result = '';
+    let totalBytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            totalBytes += value.byteLength;
+            const chunk = decoder.decode(value, { stream: true });
+            if (chunk) {
+                if (result.length < maxBytes) {
+                    result += chunk.slice(0, maxBytes - result.length);
+                }
+                onChunk?.(chunk);
+            }
+            if (totalBytes >= maxBytes) {
+                try {
+                    await reader.cancel('Stream limit exceeded');
+                }
+                catch { }
+                break;
+            }
+        }
+        const tail = decoder.decode();
+        if (tail) {
+            if (result.length < maxBytes) {
+                result += tail.slice(0, maxBytes - result.length);
+            }
+            onChunk?.(tail);
+        }
+    }
+    catch { }
+    return result;
+};
+export const resolveHookTimeoutMs = () => {
+    const rawTimeout = process.env[HOOK_TIMEOUT_ENV];
+    if (rawTimeout === undefined)
+        return DEFAULT_HOOK_TIMEOUT_MS;
+    const parsed = Number(rawTimeout);
+    if (Number.isFinite(parsed) && parsed <= 0)
+        return 0;
+    if (Number.isFinite(parsed))
+        return parsed;
+    return DEFAULT_HOOK_TIMEOUT_MS;
+};
+export const executeHookProcess = async (options) => {
+    const { entry, directory, stdinText, event, startedAt = Date.now(), timeoutMs = resolveHookTimeoutMs(), activeProcs } = options;
+    if (process.env.OWFLOW_DEBUG === '1') {
+        console.error(`[owflow:debug] [${event}] Spawning ${entry.path} (stdin: ${stdinText.length} bytes)`);
+    }
+    let proc;
+    try {
+        proc = Bun.spawn(buildExecutionArgs(entry), {
+            cwd: directory,
+            stdin: Buffer.from(stdinText),
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        activeProcs?.add(proc);
+    }
+    catch (spawnError) {
+        throw new HookSpawnError(spawnError);
+    }
+    let timedOut = false;
+    let timer;
+    let rawStdout = '';
+    let rawStderr = '';
+    const ioPromise = Promise.all([
+        readStream(proc.stdout),
+        readStream(proc.stderr),
+        proc.exited,
+    ]);
+    let exitCode = null;
+    try {
+        const res = timeoutMs > 0
+            ? await Promise.race([
+                ioPromise,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => {
+                        timedOut = true;
+                        try {
+                            proc.kill();
+                        }
+                        catch { }
+                        resolve('timeout');
+                    }, Math.floor(timeoutMs));
+                    timer.unref?.();
+                }),
+            ])
+            : await ioPromise;
+        if (res !== 'timeout')
+            [rawStdout, rawStderr, exitCode] = res;
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        activeProcs?.delete(proc);
+    }
+    const finishedAt = Date.now();
+    const durationMs = Math.max(0, finishedAt - startedAt);
+    const signal = proc.signalCode ?? null;
+    const ok = !timedOut && exitCode === 0 && signal === null;
+    if (process.env.OWFLOW_DEBUG === '1') {
+        console.error(`[owflow:debug] [${event}] Finished ${entry.path} in ${durationMs}ms (exitCode: ${exitCode}, ok: ${ok})`);
+    }
+    const reason = ok
+        ? undefined
+        : timedOut
+            ? `process timed out after ${Math.floor(timeoutMs)}ms`
+            : rawStderr.trim() || rawStdout.trim() || (signal ? `process terminated by signal ${signal}` : `process exited with code ${exitCode}`);
+    return {
+        startedAt,
+        finishedAt,
+        durationMs,
+        ok,
+        timedOut,
+        exitCode,
+        signal,
+        rawStdout,
+        rawStderr,
+        reason,
+    };
+};

package/dist/hooks/runtime/status-recorder.d.ts

@@ -0,0 +1,27 @@
+import type { HookRunLogRecord, HookRuntimeEntry } from '../../types/hook-types.js';
+export declare const STATUS_DEBOUNCE_MS = 50;
+export declare const MAX_LOG_FILE_BYTES: number;
+export declare const NON_SESSION_STREAM_CAP_BYTES: number;
+export interface StatusRecorderOptions {
+    directory: string;
+    statusFile?: string;
+    logFile?: string;
+}
+export declare class StatusRecorder {
+    readonly statusFile: string;
+    readonly logFile?: string;
+    readonly directory: string;
+    private readonly statuses;
+    private readonly writtenRunRecords;
+    private statusTimer;
+    constructor(options: StatusRecorderOptions);
+    getStatus(event: string): HookRuntimeEntry | undefined;
+    setStatus(event: string, entry: HookRuntimeEntry): void;
+    deleteStatus(event: string): void;
+    getAllStatuses(): ReadonlyMap<string, HookRuntimeEntry>;
+    flushStatusFileAtomic: (file: string, workspace: string, hooks: ReadonlyMap<string, HookRuntimeEntry>) => void;
+    flushStatus(): void;
+    schedulePendingStatus(): void;
+    appendLog(record: HookRunLogRecord): void;
+    dispose(): void;
+}

package/dist/hooks/runtime/status-recorder.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendWithRotation, resolveHooksLatestSymlink, resolveHooksLogFile, resolveHooksStatusFile } from '../hooks-persistence.js';
+export const STATUS_DEBOUNCE_MS = 50;
+export const MAX_LOG_FILE_BYTES = 4 * 1024 * 1024;
+export const NON_SESSION_STREAM_CAP_BYTES = 16 * 1024;
+export class StatusRecorder {
+    statusFile;
+    logFile;
+    directory;
+    statuses = new Map();
+    writtenRunRecords = new Set();
+    statusTimer;
+    constructor(options) {
+        this.directory = options.directory;
+        this.statusFile = options.statusFile ?? resolveHooksStatusFile(options.directory);
+        this.logFile = options.logFile;
+        resolveHooksLatestSymlink(this.directory);
+        this.flushStatus();
+    }
+    getStatus(event) {
+        return this.statuses.get(event);
+    }
+    setStatus(event, entry) {
+        this.statuses.set(event, entry);
+    }
+    deleteStatus(event) {
+        this.statuses.delete(event);
+    }
+    getAllStatuses() {
+        return this.statuses;
+    }
+    flushStatusFileAtomic = (file, workspace, hooks) => {
+        const nonce = crypto.randomUUID();
+        const tmpFile = `${file}.${process.pid}.${nonce}.tmp`;
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+            try {
+                if (fs.lstatSync(file).isSymbolicLink())
+                    return;
+            }
+            catch (err) {
+                if (err?.code !== 'ENOENT')
+                    return;
+            }
+            const snapshot = {
+                version: 1,
+                pid: process.pid,
+                workspace,
+                updatedAt: Date.now(),
+                hooks: Object.fromEntries(hooks),
+            };
+            const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_TRUNC | (fs.constants.O_NOFOLLOW ?? 0);
+            const fd = fs.openSync(tmpFile, flags, 0o600);
+            try {
+                fs.writeFileSync(fd, JSON.stringify(snapshot), { encoding: 'utf8' });
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            fs.renameSync(tmpFile, file);
+        }
+        catch {
+            fs.unlinkSync(tmpFile);
+            // Best-effort status persistence never affects hook execution.
+        }
+    };
+    flushStatus() {
+        if (this.statusTimer !== undefined) {
+            clearTimeout(this.statusTimer);
+            this.statusTimer = undefined;
+        }
+        this.flushStatusFileAtomic(this.statusFile, this.directory, this.statuses);
+    }
+    schedulePendingStatus() {
+        if (this.statusTimer !== undefined) {
+            clearTimeout(this.statusTimer);
+        }
+        this.statusTimer = setTimeout(() => {
+            this.statusTimer = undefined;
+            this.flushStatusFileAtomic(this.statusFile, this.directory, this.statuses);
+        }, STATUS_DEBOUNCE_MS);
+        this.statusTimer.unref?.();
+    }
+    appendLog(record) {
+        try {
+            // Distinguish distinct runs by runId and terminal status
+            const recordKey = `${record.runId}:${record.status}`;
+            if (this.writtenRunRecords.has(recordKey))
+                return;
+            const targetLogFile = this.logFile ?? resolveHooksLogFile(this.directory, record.name);
+            appendWithRotation(targetLogFile, JSON.stringify(record));
+            if (!this.logFile) {
+                resolveHooksLatestSymlink(this.directory, targetLogFile);
+            }
+            this.writtenRunRecords.add(recordKey);
+            // Bounded set eviction to prevent memory growth across thousands of runs
+            if (this.writtenRunRecords.size > 1000) {
+                const oldest = this.writtenRunRecords.values().next().value;
+                if (oldest)
+                    this.writtenRunRecords.delete(oldest);
+            }
+        }
+        catch {
+            // Best-effort log persistence never affects hook execution.
+        }
+    }
+    dispose() {
+        this.flushStatus();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Owflow OpenCode Plugin
+ * Registers skills/agents/commands via OpenCode's JS event system.
+ */
+import type { Plugin } from '@opencode-ai/plugin';
+declare const OwflowPlugin: Plugin;
+export default OwflowPlugin;

package/dist/index.js

@@ -2,20 +2,54 @@
  * Owflow OpenCode Plugin
  * Registers skills/agents/commands via OpenCode's JS event system.
  */
-import path from "node:path";
-import fs from "node:fs";
-import { PLUGIN_VERSION } from "./utils/plugin-info.js";
-import { verify_template } from "./tools/verify_template.js";
-import { fork_task } from "./tools/fork_task.js";
-import { rereadOrchestratorState } from "./hooks/session-compaction.js";
-import { guardAgainstDestructiveActions } from "./hooks/before-tool.js";
-import { configureSkills } from "./configuration/skills-config.js";
-import { configureCommands } from "./configuration/commands-config.js";
-import { configureAgents } from "./configuration/agents-config.js";
+import { PLUGIN_VERSION } from './utils/plugin-info.js';
+import { verify_template } from './tools/verify_template.js';
+import { fork_task } from './tools/fork_task.js';
+import { rereadOrchestratorState } from './hooks/internal/session-compaction.js';
+import { guardAgainstDestructiveActions } from './hooks/internal/before-tool.js';
+import { configureSkills } from './configuration/skills-config.js';
+import { configureCommands } from './configuration/commands-config.js';
+import { configureAgents } from './configuration/agents-config.js';
+import { HookEvent } from './types/hook-types.js';
+import { renderSnapshot } from './hooks/hooks-diagnostics.js';
+import { writeHookCrashLog } from './hooks/hooks-persistence.js';
+import HooksWrapper from './hooks/hooks-wrapper.js';
 // Only the plugin factory method should be exported from this file due to OpenCode plugin handling
-const OwflowPlugin = async ({ $, directory }) => {
+const MAX_TRACKED_SESSIONS = 256;
+const OwflowPlugin = async ({ $, client, directory }) => {
     const agentBySession = new Map();
-    return {
+    const hooksDisabled = process.env.OWFLOW_HOOKS_DISABLED === '1';
+    let configLoaded = false;
+    if (hooksDisabled) {
+        console.log('[owflow] User hooks disabled (OWFLOW_HOOKS_DISABLED=1); built-in hooks remain active.');
+    }
+    const endSession = async (sessionID) => {
+        if (typeof client?.session?.abort !== 'function')
+            return;
+        try {
+            await client.session.abort({ path: { id: sessionID } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[owflow] failed to end session ${sessionID} after a gate hook failed: ${message}`);
+        }
+    };
+    let wrapper;
+    let snapshot = { entries: [], bypassed: true };
+    if (!hooksDisabled) {
+        try {
+            wrapper = new HooksWrapper(directory, endSession);
+            snapshot = wrapper.snapshot;
+        }
+        catch (error) {
+            writeHookCrashLog(directory, 'startup_digest_failed', error);
+            console.error(`[owflow] ERROR: user hooks failed to load (${error.message}).`);
+            console.error(`[owflow] Built-in destructive command guard remains ACTIVE.`);
+            console.error(`[owflow] User hooks bypassed until fixed. See crash log.`);
+            wrapper = undefined;
+        }
+    }
+    const hooks = {
         tool: {
             verify_template,
             fork_task,
@@ -24,51 +58,88 @@ const OwflowPlugin = async ({ $, directory }) => {
          * Register owflow's skills, commands, and agents so OpenCode discovers
          * them without requiring manual config file edits.
          */
-        config: async (config) => {
-            console.log(`[owflow] Starting plugin installation (v${PLUGIN_VERSION})...`);
-            let typedConfig = config;
-            // Get small_model config for alias resolution
-            // Try from config parameter first, fallback to reading opencode.json
-            let smallModel = typedConfig.small_model ?? "";
-            if (!smallModel) {
-                try {
-                    // Check project-level opencode.json
-                    const projectConfigPath = path.join(directory, "opencode.json");
-                    if (fs.existsSync(projectConfigPath)) {
-                        const rawConfig = fs.readFileSync(projectConfigPath, "utf8");
-                        const opencodeConfig = JSON.parse(rawConfig);
-                        smallModel = opencodeConfig.small_model;
-                    }
-                }
-                catch (error) {
-                    console.warn(`Couldn't read or parse opencode.json config - small_model remains undefined`);
-                }
+        [HookEvent.Config]: async (config) => {
+            if (!configLoaded) {
+                console.log(`[owflow] Starting plugin installation (v${PLUGIN_VERSION})...`);
+                for (const line of renderSnapshot(snapshot))
+                    console.log(line);
             }
+            let typedConfig = config;
             configureSkills(typedConfig);
             configureCommands(typedConfig);
-            configureAgents(typedConfig, smallModel);
-            config = typedConfig;
-            console.log(`[owflow] Plugin installation completed successfully (v${PLUGIN_VERSION}).`);
+            configureAgents(typedConfig);
+            // User scripts run after built-in config mutations; failing closed on rejection.
+            if (wrapper !== undefined) {
+                await wrapper.dispatch(HookEvent.Config, typedConfig);
+            }
+            if (!configLoaded) {
+                console.log(`[owflow] Plugin installation completed successfully (v${PLUGIN_VERSION}).`);
+                configLoaded = true;
+            }
         },
-        "experimental.session.compacting": async (input, output) => {
+        [HookEvent.ExperimentalSessionCompacting]: async (input, output) => {
             await rereadOrchestratorState(directory, output);
+            if (wrapper !== undefined) {
+                await wrapper.dispatch(HookEvent.ExperimentalSessionCompacting, input, output);
+            }
         },
-        "chat.message": async (input, _output) => {
+        [HookEvent.ChatMessage]: async (input, output) => {
             try {
-                agentBySession.set(input.sessionID, input.agent ?? "main");
+                if (agentBySession.has(input.sessionID)) {
+                    agentBySession.delete(input.sessionID);
+                }
+                agentBySession.set(input.sessionID, input.agent ?? 'main');
+                while (agentBySession.size > MAX_TRACKED_SESSIONS) {
+                    const oldest = agentBySession.keys().next().value;
+                    if (oldest !== undefined)
+                        agentBySession.delete(oldest);
+                }
             }
             catch {
                 // ignore
             }
+            // Dispatch deliberately outside the swallowing catch so gate throws
+            // propagate even when the platform's input object misbehaves.
+            if (wrapper !== undefined) {
+                await wrapper.dispatch(HookEvent.ChatMessage, input, output);
+            }
         },
-        "tool.execute.before": async (input, output) => {
+        [HookEvent.ToolExecuteBefore]: async (input, output) => {
             try {
                 await guardAgainstDestructiveActions(input, output, agentBySession);
+                if (wrapper !== undefined) {
+                    await wrapper.dispatch(HookEvent.ToolExecuteBefore, input, output);
+                }
             }
             catch (e) {
-                // Re-throw only intentional blocks; swallow unexpected errors
-                if (e.message?.startsWith("Blocked:"))
+                // Re-throw only intentional blocks; log and swallow unexpected errors
+                if (e.message?.startsWith('Blocked:'))
                     throw e;
+                const message = e instanceof Error ? e.message : String(e);
+                console.warn(`[owflow] hooks: unexpected error in tool.execute.before (failing open): ${message}`);
+            }
+        },
+    };
+    // No wrapper - no support for user defined hooks, return owflow hook configs
+    if (wrapper === undefined)
+        return hooks;
+    // Return full plugin configuration with user hooks support
+    const dispatchHandlers = wrapper.createDispatchHandlers();
+    const userDispose = dispatchHandlers.dispose;
+    return {
+        ...hooks,
+        ...dispatchHandlers,
+        dispose: async () => {
+            try {
+                await userDispose?.();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.warn(`[owflow] error during user dispose hook: ${msg}`);
+            }
+            finally {
+                wrapper.dispose();
+                agentBySession.clear();
             }
         },
     };