@doingdev/opencode-claude-manager-plugin 0.1.20 → 0.1.22

package/dist/claude/delegated-can-use-tool.js

@@ -1,178 +0,0 @@
-import { createInterface } from 'node:readline/promises';
-function defaultIsInteractiveTerminal() {
-    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function formatToolRequest(toolName, input, meta) {
-    const headline = meta.title?.trim() ||
-        [meta.displayName, toolName].filter(Boolean).join(': ') ||
-        toolName;
-    const lines = [headline];
-    if (meta.description?.trim()) {
-        lines.push(meta.description.trim());
-    }
-    if (meta.decisionReason?.trim()) {
-        lines.push(`Reason: ${meta.decisionReason.trim()}`);
-    }
-    if (toolName === 'Bash' && typeof input.command === 'string') {
-        lines.push(`Command: ${input.command}`);
-        if (typeof input.description === 'string' && input.description) {
-            lines.push(`Intent: ${input.description}`);
-        }
-    }
-    else if (toolName !== 'AskUserQuestion') {
-        lines.push(`Input: ${JSON.stringify(input, null, 2)}`);
-    }
-    return lines.join('\n');
-}
-function applyDefaultAskUserAnswers(input) {
-    const rawQuestions = input.questions;
-    if (!Array.isArray(rawQuestions)) {
-        return input;
-    }
-    const answers = {};
-    for (const entry of rawQuestions) {
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const questionText = entry.question;
-        if (typeof questionText !== 'string') {
-            continue;
-        }
-        const options = entry.options;
-        if (!Array.isArray(options) || options.length === 0) {
-            continue;
-        }
-        const first = options[0];
-        if (isRecord(first) && typeof first.label === 'string') {
-            answers[questionText] = first.label;
-        }
-    }
-    return {
-        ...input,
-        questions: rawQuestions,
-        answers,
-    };
-}
-async function promptLine(question) {
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        return (await rl.question(question)).trim();
-    }
-    finally {
-        rl.close();
-    }
-}
-async function handleAskUserQuestionInteractive(input, toolUseID) {
-    const rawQuestions = input.questions;
-    if (!Array.isArray(rawQuestions)) {
-        return {
-            behavior: 'deny',
-            message: 'AskUserQuestion invoked without a questions array; cannot collect answers interactively.',
-            toolUseID,
-        };
-    }
-    const answers = {};
-    for (const entry of rawQuestions) {
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const questionText = entry.question;
-        const header = entry.header;
-        if (typeof questionText !== 'string') {
-            continue;
-        }
-        const label = typeof header === 'string' && header.trim()
-            ? `${header.trim()}: ${questionText}`
-            : questionText;
-        const options = entry.options;
-        if (!Array.isArray(options) || options.length === 0) {
-            return {
-                behavior: 'deny',
-                message: `Question "${questionText}" has no options to choose from.`,
-                toolUseID,
-            };
-        }
-        process.stdout.write(`\n${label}\n`);
-        for (const [index, opt] of options.entries()) {
-            if (isRecord(opt) && typeof opt.label === 'string') {
-                const desc = typeof opt.description === 'string' ? ` — ${opt.description}` : '';
-                process.stdout.write(`  ${index + 1}. ${opt.label}${desc}\n`);
-            }
-        }
-        const multi = entry.multiSelect === true
-            ? ' (numbers separated by commas, or type your own answer)'
-            : ' (number, or type your own answer)';
-        const response = await promptLine(`Your choice${multi}: `);
-        const parsed = parseChoiceResponse(response, options);
-        answers[questionText] = parsed;
-    }
-    return {
-        behavior: 'allow',
-        updatedInput: {
-            ...input,
-            questions: rawQuestions,
-            answers,
-        },
-        toolUseID,
-    };
-}
-function parseChoiceResponse(response, options) {
-    const indices = response
-        .split(',')
-        .map((part) => Number.parseInt(part.trim(), 10) - 1)
-        .filter((index) => Number.isFinite(index));
-    const labels = indices
-        .filter((index) => index >= 0 && index < options.length)
-        .map((index) => {
-        const opt = options[index];
-        if (isRecord(opt) && typeof opt.label === 'string') {
-            return opt.label;
-        }
-        return '';
-    })
-        .filter(Boolean);
-    return labels.length > 0 ? labels.join(', ') : response;
-}
-export function createDelegatedCanUseTool(policy, factoryOptions) {
-    const isInteractiveTerminal = factoryOptions?.isInteractiveTerminal ?? defaultIsInteractiveTerminal;
-    return async (toolName, input, options) => {
-        const usePrompt = policy === 'prompt_if_tty' && isInteractiveTerminal();
-        if (toolName === 'AskUserQuestion') {
-            if (usePrompt) {
-                return handleAskUserQuestionInteractive(input, options.toolUseID);
-            }
-            return {
-                behavior: 'allow',
-                updatedInput: applyDefaultAskUserAnswers(input),
-                toolUseID: options.toolUseID,
-            };
-        }
-        if (policy === 'allow_all' || !usePrompt) {
-            return {
-                behavior: 'allow',
-                updatedInput: input,
-                toolUseID: options.toolUseID,
-            };
-        }
-        const summary = formatToolRequest(toolName, input, options);
-        const answer = await promptLine(`${summary}\nAllow this action? [y/N] `);
-        if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-            return {
-                behavior: 'allow',
-                updatedInput: input,
-                toolUseID: options.toolUseID,
-            };
-        }
-        return {
-            behavior: 'deny',
-            message: 'User denied this tool action in the delegated Claude Code session (TTY prompt).',
-            toolUseID: options.toolUseID,
-        };
-    };
-}

package/dist/claude/session-live-tailer.d.ts

@@ -1,51 +0,0 @@
-import type { LiveTailEvent, ToolOutputPreview } from '../types/contracts.js';
-/**
- * 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 declare class SessionLiveTailer {
-    private activeTails;
-    /**
-     * 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: string, cwd?: string): string | null;
-    /**
-     * Check whether we can locate a JSONL file for the given session.
-     */
-    sessionFileExists(sessionId: string, cwd?: string): boolean;
-    /**
-     * 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: string, cwd: string | undefined, onEvent: (event: LiveTailEvent) => void, pollIntervalMs?: number): () => void;
-    /**
-     * Stop tailing a specific session.
-     */
-    stopTailing(sessionId: string): void;
-    /**
-     * Stop all active tails (cleanup on shutdown).
-     */
-    stopAll(): void;
-    /**
-     * Read the last N lines from a session JSONL file.
-     */
-    getLastLines(sessionId: string, cwd: string | undefined, lineCount?: number): Promise<string[]>;
-    /**
-     * Extract a preview of recent tool output from the tail of a session file.
-     */
-    getToolOutputPreview(sessionId: string, cwd: string | undefined, maxEntries?: number): Promise<ToolOutputPreview[]>;
-}

package/dist/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 += data;
-                });
-                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 String(value);
-    }
-}

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

@@ -1,27 +0,0 @@
-import type { ToolApprovalDecision, ToolApprovalPolicy, ToolApprovalRule } from '../types/contracts.js';
-export declare class ToolApprovalManager {
-    private policy;
-    private decisions;
-    private readonly maxDecisions;
-    constructor(policy?: Partial<ToolApprovalPolicy>, maxDecisions?: number);
-    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): void;
-    addRule(rule: ToolApprovalRule, position?: number): void;
-    removeRule(ruleId: string): boolean;
-    setDefaultAction(action: 'allow' | 'deny'): void;
-    setEnabled(enabled: boolean): void;
-    private findMatchingRule;
-    private recordDecision;
-}