@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

package/dist/src/claude/session-live-tailer.js

@@ -1,269 +0,0 @@
-import { createReadStream, existsSync, readdirSync, statSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import path from 'node:path';
-import os from 'node:os';
-/**
- * Tails Claude Code session JSONL files for live tool output.
- *
- * The SDK streams high-level events (assistant text, tool_call summaries, results)
- * but does not expose the raw tool output that Claude Code writes to the JSONL
- * transcript on disk.  This service fills that gap by polling the file for new
- * lines, parsing each one, and forwarding parsed events to a caller-supplied
- * callback.
- */
-export class SessionLiveTailer {
-    activeTails = new Map();
-    // ── Path discovery ──────────────────────────────────────────────────
-    /**
-     * Locate the JSONL file for a session.
-     *
-     * Claude Code stores transcripts at:
-     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
-     *
-     * The `<sanitized-cwd>` folder name is an internal implementation detail that
-     * can change across Claude Code versions, so we search all project directories
-     * for the session file rather than attempting to replicate the sanitisation.
-     */
-    findSessionFile(sessionId, cwd) {
-        const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-        if (!existsSync(projectsDir)) {
-            return null;
-        }
-        // If cwd is provided, try the sanitised form first (best-effort fast path).
-        if (cwd) {
-            const sanitised = cwd.replace(/\//g, '-');
-            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        // Fall back to scanning all project directories.
-        try {
-            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
-                if (!entry.isDirectory())
-                    continue;
-                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
-                if (existsSync(candidate)) {
-                    return candidate;
-                }
-            }
-        }
-        catch {
-            // Permission denied or similar — nothing we can do.
-        }
-        return null;
-    }
-    /**
-     * Check whether we can locate a JSONL file for the given session.
-     */
-    sessionFileExists(sessionId, cwd) {
-        return this.findSessionFile(sessionId, cwd) !== null;
-    }
-    // ── Live tailing ────────────────────────────────────────────────────
-    /**
-     * Poll a session's JSONL file for new lines and emit parsed events.
-     *
-     * Returns a stop function.  The caller **must** invoke it when tailing is no
-     * longer needed (e.g. when the session completes or the tool is interrupted).
-     */
-    startTailing(sessionId, cwd, onEvent, pollIntervalMs = 150) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath) {
-            onEvent({
-                type: 'error',
-                sessionId,
-                error: `Session JSONL not found for ${sessionId}`,
-            });
-            return () => { };
-        }
-        let offset = statSync(filePath).size;
-        let buffer = '';
-        let reading = false; // guard against overlapping reads
-        const interval = setInterval(() => {
-            if (reading)
-                return;
-            try {
-                const currentSize = statSync(filePath).size;
-                if (currentSize < offset) {
-                    // File was truncated (rotation / compaction) — reset.
-                    offset = 0;
-                    buffer = '';
-                }
-                if (currentSize <= offset)
-                    return;
-                reading = true;
-                const stream = createReadStream(filePath, {
-                    start: offset,
-                    end: currentSize - 1,
-                    encoding: 'utf8',
-                });
-                let chunk = '';
-                stream.on('data', (data) => {
-                    chunk += typeof data === 'string' ? data : data.toString('utf8');
-                });
-                stream.on('end', () => {
-                    reading = false;
-                    offset = currentSize;
-                    buffer += chunk;
-                    const lines = buffer.split('\n');
-                    // Keep the last (possibly incomplete) segment in the buffer.
-                    buffer = lines.pop() ?? '';
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            continue;
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: parsed,
-                                rawLine: trimmed,
-                            });
-                        }
-                        catch {
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: null,
-                                rawLine: trimmed,
-                            });
-                        }
-                    }
-                });
-                stream.on('error', (err) => {
-                    reading = false;
-                    onEvent({
-                        type: 'error',
-                        sessionId,
-                        error: err.message,
-                    });
-                });
-            }
-            catch (err) {
-                reading = false;
-                onEvent({
-                    type: 'error',
-                    sessionId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }, pollIntervalMs);
-        this.activeTails.set(sessionId, interval);
-        return () => this.stopTailing(sessionId);
-    }
-    /**
-     * Stop tailing a specific session.
-     */
-    stopTailing(sessionId) {
-        const interval = this.activeTails.get(sessionId);
-        if (interval) {
-            clearInterval(interval);
-            this.activeTails.delete(sessionId);
-        }
-    }
-    /**
-     * Stop all active tails (cleanup on shutdown).
-     */
-    stopAll() {
-        for (const [, interval] of this.activeTails) {
-            clearInterval(interval);
-        }
-        this.activeTails.clear();
-    }
-    // ── Snapshot helpers ────────────────────────────────────────────────
-    /**
-     * Read the last N lines from a session JSONL file.
-     */
-    async getLastLines(sessionId, cwd, lineCount = 20) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath)
-            return [];
-        const lines = [];
-        const rl = createInterface({
-            input: createReadStream(filePath, { encoding: 'utf8' }),
-        });
-        for await (const line of rl) {
-            lines.push(line);
-            if (lines.length > lineCount) {
-                lines.shift();
-            }
-        }
-        return lines;
-    }
-    /**
-     * Extract a preview of recent tool output from the tail of a session file.
-     */
-    async getToolOutputPreview(sessionId, cwd, maxEntries = 5) {
-        const lastLines = await this.getLastLines(sessionId, cwd, 100);
-        const previews = [];
-        for (const line of lastLines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                const preview = extractToolOutput(parsed);
-                if (preview) {
-                    previews.push(preview);
-                }
-            }
-            catch {
-                // skip unparseable lines
-            }
-        }
-        return previews.slice(-maxEntries);
-    }
-}
-// ── Internal helpers ────────────────────────────────────────────────────
-/**
- * Attempt to extract tool output information from a JSONL record.
- *
- * Claude Code JSONL records with tool results can appear as:
- *   1. A top-level `{ type: "user", message: { content: [{ type: "tool_result", ... }] } }`
- *   2. Direct `tool_result` entries (less common).
- */
-function extractToolOutput(record) {
-    // Pattern 1: user message wrapping tool_result content blocks
-    if (record.type === 'user') {
-        const message = record.message;
-        if (!message)
-            return null;
-        const content = message.content;
-        if (!Array.isArray(content))
-            return null;
-        for (const block of content) {
-            if (block &&
-                typeof block === 'object' &&
-                block.type === 'tool_result') {
-                const b = block;
-                return {
-                    toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
-                    content: stringifyContent(b.content),
-                    isError: b.is_error === true,
-                };
-            }
-        }
-    }
-    // Pattern 2: direct tool_result record (varies by Claude Code version)
-    if (record.type === 'tool_result') {
-        return {
-            toolUseId: typeof record.tool_use_id === 'string' ? record.tool_use_id : '',
-            content: stringifyContent(record.content),
-            isError: record.is_error === true,
-        };
-    }
-    return null;
-}
-function stringifyContent(value) {
-    if (typeof value === 'string')
-        return value;
-    if (value === undefined || value === null)
-        return '';
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return '[non-serializable]';
-    }
-}

package/dist/src/claude/tool-approval-manager.d.ts

@@ -1,30 +0,0 @@
-import type { ToolApprovalDecision, ToolApprovalPolicy, ToolApprovalRule } from '../types/contracts.js';
-export declare class ToolApprovalManager {
-    private policy;
-    private decisions;
-    private readonly maxDecisions;
-    private readonly persistPath;
-    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number, persistPath?: string);
-    loadPersistedPolicy(): Promise<void>;
-    private persistPolicy;
-    evaluate(toolName: string, input: Record<string, unknown>, options?: {
-        title?: string;
-        agentID?: string;
-    }): {
-        behavior: 'allow';
-    } | {
-        behavior: 'deny';
-        message: string;
-    };
-    getDecisions(limit?: number): ToolApprovalDecision[];
-    getDeniedDecisions(limit?: number): ToolApprovalDecision[];
-    clearDecisions(): void;
-    getPolicy(): ToolApprovalPolicy;
-    setPolicy(policy: ToolApprovalPolicy): Promise<void>;
-    addRule(rule: ToolApprovalRule, position?: number): Promise<void>;
-    removeRule(ruleId: string): Promise<boolean>;
-    setDefaultAction(action: 'allow' | 'deny'): Promise<void>;
-    setEnabled(enabled: boolean): Promise<void>;
-    private findMatchingRule;
-    private recordDecision;
-}

package/dist/src/claude/tool-approval-manager.js

@@ -1,279 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { isFileNotFoundError, writeJsonAtomically } from '../util/fs-helpers.js';
-const DEFAULT_MAX_DECISIONS = 500;
-const INPUT_PREVIEW_MAX = 300;
-function normalizePolicy(policy) {
-    return {
-        ...policy,
-        rules: [...policy.rules],
-        defaultAction: 'allow',
-    };
-}
-function getDefaultRules() {
-    return [
-        // Safe read-only tools
-        {
-            id: 'allow-read',
-            toolPattern: 'Read',
-            action: 'allow',
-            description: 'Allow reading files',
-        },
-        {
-            id: 'allow-grep',
-            toolPattern: 'Grep',
-            action: 'allow',
-            description: 'Allow grep searches',
-        },
-        {
-            id: 'allow-glob',
-            toolPattern: 'Glob',
-            action: 'allow',
-            description: 'Allow glob file searches',
-        },
-        {
-            id: 'allow-ls',
-            toolPattern: 'LS',
-            action: 'allow',
-            description: 'Allow directory listing',
-        },
-        {
-            id: 'allow-list',
-            toolPattern: 'ListDirectory',
-            action: 'allow',
-            description: 'Allow listing directories',
-        },
-        // Edit tools
-        {
-            id: 'allow-edit',
-            toolPattern: 'Edit',
-            action: 'allow',
-            description: 'Allow file edits',
-        },
-        {
-            id: 'allow-multiedit',
-            toolPattern: 'MultiEdit',
-            action: 'allow',
-            description: 'Allow multi-edits',
-        },
-        {
-            id: 'allow-write',
-            toolPattern: 'Write',
-            action: 'allow',
-            description: 'Allow file writes',
-        },
-        {
-            id: 'allow-notebook',
-            toolPattern: 'NotebookEdit',
-            action: 'allow',
-            description: 'Allow notebook edits',
-        },
-        // Bash - deny dangerous patterns first, then allow the rest
-        {
-            id: 'deny-bash-rm-rf-root',
-            toolPattern: 'Bash',
-            inputPattern: 'rm -rf /',
-            action: 'deny',
-            denyMessage: 'Destructive rm -rf on root path is not allowed.',
-            description: 'Block rm -rf on root',
-        },
-        {
-            id: 'deny-bash-force-push',
-            toolPattern: 'Bash',
-            inputPattern: 'git push --force',
-            action: 'deny',
-            denyMessage: 'Force push is not allowed.',
-            description: 'Block git force push',
-        },
-        {
-            id: 'deny-bash-reset-hard',
-            toolPattern: 'Bash',
-            inputPattern: 'git reset --hard',
-            action: 'deny',
-            denyMessage: 'git reset --hard is not allowed from Claude Code. Use the manager git_reset tool instead.',
-            description: 'Block git reset --hard',
-        },
-        {
-            id: 'allow-bash',
-            toolPattern: 'Bash',
-            action: 'allow',
-            description: 'Allow bash commands (after dangerous patterns filtered)',
-        },
-        // Agent / misc
-        {
-            id: 'allow-skill',
-            toolPattern: 'Skill',
-            action: 'allow',
-            description: 'Allow Agent Skills (filesystem SKILL.md)',
-        },
-        {
-            id: 'allow-agent',
-            toolPattern: 'Agent',
-            action: 'allow',
-            description: 'Allow agent delegation',
-        },
-        {
-            id: 'allow-todowrite',
-            toolPattern: 'TodoWrite',
-            action: 'allow',
-            description: 'Allow todo tracking',
-        },
-        {
-            id: 'allow-todoread',
-            toolPattern: 'TodoRead',
-            action: 'allow',
-            description: 'Allow todo reading',
-        },
-    ];
-}
-export class ToolApprovalManager {
-    policy;
-    decisions = [];
-    maxDecisions;
-    persistPath;
-    constructor(policy, maxDecisions, persistPath) {
-        this.policy = normalizePolicy({
-            rules: policy?.rules ?? getDefaultRules(),
-            defaultAction: 'allow',
-            defaultDenyMessage: policy?.defaultDenyMessage ?? 'Tool call denied by approval policy.',
-            enabled: policy?.enabled ?? true,
-        });
-        this.maxDecisions = maxDecisions ?? DEFAULT_MAX_DECISIONS;
-        this.persistPath = persistPath ?? null;
-    }
-    async loadPersistedPolicy() {
-        if (!this.persistPath) {
-            return;
-        }
-        try {
-            const content = await fs.readFile(this.persistPath, 'utf8');
-            const loaded = JSON.parse(content);
-            this.policy = normalizePolicy({
-                rules: loaded.rules ?? getDefaultRules(),
-                defaultAction: 'allow',
-                defaultDenyMessage: loaded.defaultDenyMessage ?? 'Tool call denied by approval policy.',
-                enabled: loaded.enabled ?? true,
-            });
-        }
-        catch (error) {
-            if (!isFileNotFoundError(error)) {
-                throw error;
-            }
-        }
-    }
-    async persistPolicy() {
-        if (!this.persistPath) {
-            return;
-        }
-        await fs.mkdir(path.dirname(this.persistPath), { recursive: true });
-        await writeJsonAtomically(this.persistPath, this.policy);
-    }
-    evaluate(toolName, input, options) {
-        if (!this.policy.enabled) {
-            return { behavior: 'allow' };
-        }
-        const inputJson = safeJsonStringify(input);
-        const matchedRule = this.findMatchingRule(toolName, inputJson);
-        const action = matchedRule?.action ?? 'allow';
-        const denyMessage = action === 'deny'
-            ? (matchedRule?.denyMessage ?? this.policy.defaultDenyMessage ?? 'Denied by policy.')
-            : undefined;
-        this.recordDecision({
-            timestamp: new Date().toISOString(),
-            toolName,
-            inputPreview: inputJson.slice(0, INPUT_PREVIEW_MAX),
-            title: options?.title,
-            matchedRuleId: matchedRule?.id ?? 'default',
-            action,
-            denyMessage,
-            agentId: options?.agentID,
-        });
-        if (action === 'deny') {
-            return { behavior: 'deny', message: denyMessage };
-        }
-        return { behavior: 'allow' };
-    }
-    getDecisions(limit) {
-        const all = [...this.decisions].reverse();
-        return limit ? all.slice(0, limit) : all;
-    }
-    getDeniedDecisions(limit) {
-        const denied = this.decisions.filter((d) => d.action === 'deny').reverse();
-        return limit ? denied.slice(0, limit) : denied;
-    }
-    clearDecisions() {
-        this.decisions = [];
-    }
-    getPolicy() {
-        return { ...this.policy, rules: [...this.policy.rules] };
-    }
-    async setPolicy(policy) {
-        this.policy = normalizePolicy(policy);
-        await this.persistPolicy();
-    }
-    async addRule(rule, position) {
-        if (position !== undefined && position >= 0 && position < this.policy.rules.length) {
-            this.policy.rules.splice(position, 0, rule);
-        }
-        else {
-            this.policy.rules.push(rule);
-        }
-        await this.persistPolicy();
-    }
-    async removeRule(ruleId) {
-        const index = this.policy.rules.findIndex((r) => r.id === ruleId);
-        if (index === -1) {
-            return false;
-        }
-        this.policy.rules.splice(index, 1);
-        await this.persistPolicy();
-        return true;
-    }
-    async setDefaultAction(action) {
-        if (action === 'deny') {
-            throw new Error('defaultAction cannot be deny; unmatched tools are always allowed. Add explicit deny rules instead.');
-        }
-        this.policy = normalizePolicy(this.policy);
-        await this.persistPolicy();
-    }
-    async setEnabled(enabled) {
-        this.policy.enabled = enabled;
-        await this.persistPolicy();
-    }
-    findMatchingRule(toolName, inputJson) {
-        for (const rule of this.policy.rules) {
-            if (!matchesToolPattern(rule.toolPattern, toolName)) {
-                continue;
-            }
-            if (rule.inputPattern && !inputJson.includes(rule.inputPattern)) {
-                continue;
-            }
-            return rule;
-        }
-        return null;
-    }
-    recordDecision(decision) {
-        this.decisions.push(decision);
-        if (this.decisions.length > this.maxDecisions) {
-            this.decisions = this.decisions.slice(-this.maxDecisions);
-        }
-    }
-}
-function matchesToolPattern(pattern, toolName) {
-    if (pattern === '*') {
-        return true;
-    }
-    if (!pattern.includes('*')) {
-        return pattern === toolName;
-    }
-    const regex = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
-    return regex.test(toolName);
-}
-function safeJsonStringify(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}

package/dist/src/index.d.ts

@@ -1,5 +0,0 @@
-import type { Plugin } from '@opencode-ai/plugin';
-import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, EngineerFailureKind, EngineerFailureResult, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
-export { ClaudeManagerPlugin };
-export declare const plugin: Plugin;

package/dist/src/index.js

@@ -1,3 +0,0 @@
-import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export { ClaudeManagerPlugin };
-export const plugin = ClaudeManagerPlugin;

package/dist/src/manager/context-tracker.d.ts

@@ -1,32 +0,0 @@
-import type { ContextWarningLevel, SessionContextSnapshot } from '../types/contracts.js';
-export declare class ContextTracker {
-    private totalTurns;
-    private totalCostUsd;
-    private latestInputTokens;
-    private latestOutputTokens;
-    private contextWindowSize;
-    private compactionCount;
-    private sessionId;
-    recordResult(result: {
-        sessionId?: string;
-        turns?: number;
-        totalCostUsd?: number;
-        inputTokens?: number;
-        outputTokens?: number;
-        contextWindowSize?: number;
-    }): void;
-    recordCompaction(): void;
-    snapshot(): SessionContextSnapshot;
-    warningLevel(): ContextWarningLevel;
-    estimateContextPercent(): number | null;
-    reset(): void;
-    /** Restore from persisted active session state. */
-    restore(state: {
-        sessionId: string;
-        totalTurns: number;
-        totalCostUsd: number;
-        estimatedContextPercent: number | null;
-        contextWindowSize: number | null;
-        latestInputTokens: number | null;
-    }): void;
-}