@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

package/dist/src/claude/claude-agent-sdk-adapter.js

@@ -0,0 +1,517 @@
+import { getSessionMessages, listSessions, query, } from '@anthropic-ai/claude-agent-sdk';
+import { appendTranscriptEvents } from '../util/transcript-append.js';
+const defaultFacade = {
+    query,
+    listSessions,
+    getSessionMessages,
+};
+const TOOL_INPUT_PREVIEW_MAX = 2000;
+const USER_MESSAGE_MAX = 4000;
+/**
+ * Ensures the Claude Agent SDK Skill tool is pre-approved per
+ * https://docs.anthropic.com/en/docs/claude-code/sdk/skills
+ * Subagents inherit the parent session tool surface unless given a narrower `tools` list.
+ */
+function mergeSkillIntoAllowedTools(allowedTools, disallowedTools) {
+    if (disallowedTools?.includes('Skill')) {
+        return allowedTools;
+    }
+    if (allowedTools === undefined) {
+        return ['Skill'];
+    }
+    return allowedTools.includes('Skill') ? allowedTools : [...allowedTools, 'Skill'];
+}
+export class ClaudeAgentSdkAdapter {
+    sdkFacade;
+    approvalManager;
+    constructor(sdkFacade = defaultFacade, approvalManager) {
+        this.sdkFacade = sdkFacade;
+        this.approvalManager = approvalManager;
+    }
+    async runSession(input, onEvent) {
+        const options = this.buildOptions(input);
+        const includePartials = options.includePartialMessages === true;
+        const abortController = new AbortController();
+        options.abortController = abortController;
+        const externalSignal = input.abortSignal;
+        let onAbort;
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                abortController.abort();
+            }
+            else {
+                onAbort = () => abortController.abort();
+                externalSignal.addEventListener('abort', onAbort, { once: true });
+            }
+        }
+        const sessionQuery = this.sdkFacade.query({
+            prompt: input.prompt,
+            options,
+        });
+        let events = [];
+        let finalText = '';
+        let sessionId;
+        let turns;
+        let totalCostUsd;
+        let inputTokens;
+        let outputTokens;
+        let contextWindowSize;
+        try {
+            for await (const message of sessionQuery) {
+                const batch = normalizeSdkMessages(message, includePartials);
+                for (const event of batch) {
+                    sessionId ??= event.sessionId;
+                    if (event.type === 'result') {
+                        finalText = event.text;
+                        turns = event.turns;
+                        totalCostUsd = event.totalCostUsd;
+                    }
+                    events = appendTranscriptEvents(events, [event]);
+                    if (onEvent) {
+                        await onEvent(event);
+                    }
+                }
+                // Extract usage data from result messages
+                if (message.type === 'result') {
+                    const usage = extractUsageFromResult(message);
+                    if (usage.inputTokens !== undefined) {
+                        inputTokens = usage.inputTokens;
+                    }
+                    if (usage.outputTokens !== undefined) {
+                        outputTokens = usage.outputTokens;
+                    }
+                    if (usage.contextWindowSize !== undefined) {
+                        contextWindowSize = usage.contextWindowSize;
+                    }
+                }
+            }
+        }
+        finally {
+            if (onAbort && externalSignal) {
+                externalSignal.removeEventListener('abort', onAbort);
+            }
+            sessionQuery.close();
+        }
+        return {
+            sessionId,
+            events,
+            finalText,
+            turns,
+            totalCostUsd,
+            inputTokens,
+            outputTokens,
+            contextWindowSize,
+        };
+    }
+    async listSavedSessions(cwd) {
+        const sessions = await this.sdkFacade.listSessions(cwd ? { dir: cwd } : undefined);
+        return sessions.map((session) => ({
+            sessionId: session.sessionId,
+            summary: session.summary,
+            cwd: session.cwd,
+            gitBranch: session.gitBranch,
+            createdAt: session.createdAt,
+            lastModified: session.lastModified,
+        }));
+    }
+    async getTranscript(sessionId, cwd) {
+        const messages = await this.sdkFacade.getSessionMessages(sessionId, cwd ? { dir: cwd } : undefined);
+        return messages.map((message) => ({
+            role: message.type,
+            sessionId: message.session_id,
+            messageId: message.uuid,
+            text: extractText(message.message),
+        }));
+    }
+    async probeCapabilities(cwd, settingSources = ['project']) {
+        const sessionQuery = this.sdkFacade.query({
+            prompt: 'Reply with OK.',
+            options: {
+                cwd,
+                maxTurns: 1,
+                permissionMode: 'plan',
+                persistSession: false,
+                tools: [],
+                settingSources,
+            },
+        });
+        try {
+            const [commands, agents, models] = await Promise.all([
+                sessionQuery.supportedCommands(),
+                sessionQuery.supportedAgents(),
+                sessionQuery.supportedModels(),
+            ]);
+            return {
+                commands: commands.map(mapSlashCommand),
+                agents: agents.map(mapAgent),
+                models: models.map((model) => model.value),
+            };
+        }
+        finally {
+            sessionQuery.close();
+        }
+    }
+    buildOptions(input) {
+        const options = {
+            cwd: input.cwd,
+            tools: { type: 'preset', preset: 'claude_code' },
+            allowedTools: mergeSkillIntoAllowedTools(input.allowedTools, input.disallowedTools),
+            disallowedTools: input.disallowedTools,
+            continue: input.continueSession,
+            resume: input.resumeSessionId,
+            forkSession: input.forkSession,
+            persistSession: input.persistSession,
+            includePartialMessages: input.includePartialMessages,
+            settingSources: input.settingSources,
+            maxTurns: input.maxTurns,
+            model: input.model,
+            effort: input.effort,
+            permissionMode: input.permissionMode ?? 'acceptEdits',
+            systemPrompt: input.systemPrompt
+                ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
+                : { type: 'preset', preset: 'claude_code' },
+            env: {
+                ...process.env,
+                CLAUDE_AGENT_SDK_CLIENT_APP: 'opencode-claude-manager-plugin/0.1.0',
+            },
+        };
+        if (!input.resumeSessionId) {
+            delete options.resume;
+        }
+        if (this.approvalManager) {
+            const manager = this.approvalManager;
+            options.canUseTool = async (toolName, toolInput, opts) => {
+                return manager.evaluate(toolName, toolInput, {
+                    title: opts.title,
+                    agentID: opts.agentID,
+                });
+            };
+        }
+        return options;
+    }
+}
+function normalizeSdkMessages(message, includePartials) {
+    const sessionId = 'session_id' in message ? message.session_id : undefined;
+    if (message.type === 'assistant') {
+        return normalizeAssistantSdkMessage(message, sessionId);
+    }
+    if (message.type === 'stream_event') {
+        if (!includePartials) {
+            return [];
+        }
+        const partialText = extractPartialEventText(message.event);
+        if (!partialText) {
+            return [];
+        }
+        return [
+            {
+                type: 'partial',
+                sessionId,
+                text: partialText,
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'result') {
+        return [
+            {
+                type: message.is_error ? 'error' : 'result',
+                sessionId,
+                text: message.subtype === 'success'
+                    ? message.result
+                    : message.errors.join('\n') || message.subtype,
+                turns: message.num_turns,
+                totalCostUsd: message.total_cost_usd,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
+    }
+    if (message.type === 'system') {
+        return [
+            {
+                type: message.subtype === 'init' ? 'init' : 'system',
+                sessionId,
+                text: message.subtype,
+                rawType: `${message.type}:${message.subtype}`,
+            },
+        ];
+    }
+    if (message.type === 'auth_status') {
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.output.join('\n') || 'auth_status',
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'prompt_suggestion') {
+        return [
+            {
+                type: 'system',
+                sessionId,
+                text: message.suggestion,
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'user') {
+        return normalizeUserSdkMessage(message, sessionId);
+    }
+    if (message.type === 'tool_progress') {
+        const toolName = 'tool_name' in message && typeof message.tool_name === 'string' ? message.tool_name : 'tool';
+        const elapsed = 'elapsed_time_seconds' in message && typeof message.elapsed_time_seconds === 'number'
+            ? message.elapsed_time_seconds
+            : 0;
+        return [
+            {
+                type: 'tool_progress',
+                sessionId,
+                text: JSON.stringify({ name: toolName, elapsed }),
+                rawType: message.type,
+            },
+        ];
+    }
+    if (message.type === 'tool_use_summary') {
+        const summary = 'summary' in message && typeof message.summary === 'string' ? message.summary : '';
+        return [
+            {
+                type: 'tool_summary',
+                sessionId,
+                text: summary,
+                rawType: message.type,
+            },
+        ];
+    }
+    return [
+        {
+            type: 'system',
+            sessionId,
+            text: message.type,
+            rawType: message.type,
+        },
+    ];
+}
+function normalizeAssistantSdkMessage(message, sessionId) {
+    const raw = message.message;
+    if (!isRecord(raw) || !Array.isArray(raw.content)) {
+        const text = extractText(raw);
+        return text.trim()
+            ? [
+                {
+                    type: 'assistant',
+                    sessionId,
+                    text,
+                    rawType: 'assistant',
+                },
+            ]
+            : [];
+    }
+    const out = [];
+    let textBuffer = '';
+    const flushText = () => {
+        if (textBuffer.trim()) {
+            out.push({
+                type: 'assistant',
+                sessionId,
+                text: textBuffer,
+                rawType: 'assistant',
+            });
+        }
+        textBuffer = '';
+    };
+    for (const block of raw.content) {
+        if (!isRecord(block)) {
+            continue;
+        }
+        if (block.type === 'text' && typeof block.text === 'string') {
+            textBuffer += block.text;
+        }
+        else if (block.type === 'tool_use' && typeof block.name === 'string') {
+            flushText();
+            const id = typeof block.id === 'string' ? block.id : '';
+            const preview = truncateJsonish(block.input, TOOL_INPUT_PREVIEW_MAX);
+            out.push({
+                type: 'tool_call',
+                sessionId,
+                text: JSON.stringify({
+                    name: block.name,
+                    id,
+                    input: preview,
+                }),
+                rawType: 'assistant:tool_use',
+            });
+        }
+    }
+    flushText();
+    return out;
+}
+function normalizeUserSdkMessage(message, sessionId) {
+    let payload = serializeUserMessageContent(message.message);
+    if (message.tool_use_result !== undefined) {
+        const extra = truncateJsonish(message.tool_use_result, 1500);
+        if (extra) {
+            payload = payload ? `${payload}\n[tool_use_result] ${extra}` : `[tool_use_result] ${extra}`;
+        }
+    }
+    payload = truncateString(payload, USER_MESSAGE_MAX);
+    if (!payload.trim()) {
+        return [];
+    }
+    return [
+        {
+            type: 'user',
+            sessionId,
+            text: payload,
+            rawType: 'user',
+        },
+    ];
+}
+function serializeUserMessageContent(message) {
+    if (typeof message === 'string') {
+        return message;
+    }
+    if (!isRecord(message)) {
+        return '';
+    }
+    const content = message.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return truncateJsonish(message, USER_MESSAGE_MAX);
+    }
+    const lines = [];
+    for (const part of content) {
+        if (!isRecord(part)) {
+            continue;
+        }
+        if (part.type === 'text' && typeof part.text === 'string') {
+            lines.push(part.text);
+        }
+        else if (part.type === 'tool_result') {
+            const id = typeof part.tool_use_id === 'string' ? part.tool_use_id : '';
+            const body = truncateJsonish(part.content, TOOL_INPUT_PREVIEW_MAX);
+            lines.push(`[tool_result:${id}] ${body}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function truncateJsonish(value, max) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return truncateString(value, max);
+    }
+    try {
+        return truncateString(JSON.stringify(value), max);
+    }
+    catch {
+        return truncateString(String(value), max);
+    }
+}
+function truncateString(s, max) {
+    if (s.length <= max) {
+        return s;
+    }
+    return s.slice(0, max);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function extractPartialEventText(event) {
+    if (!isRecord(event)) {
+        return null;
+    }
+    const delta = event.delta;
+    if (isRecord(delta)) {
+        if (typeof delta.text === 'string' && delta.text.length > 0) {
+            return delta.text;
+        }
+        if (typeof delta.partial_json === 'string' && delta.partial_json.length > 0) {
+            return delta.partial_json;
+        }
+    }
+    return null;
+}
+function extractText(payload) {
+    if (typeof payload === 'string') {
+        return payload;
+    }
+    if (!isRecord(payload)) {
+        return '';
+    }
+    if (Array.isArray(payload.content)) {
+        const parts = payload.content
+            .map((contentPart) => {
+            if (!isRecord(contentPart)) {
+                return '';
+            }
+            if (typeof contentPart.text === 'string') {
+                return contentPart.text;
+            }
+            if (contentPart.type === 'tool_use' && typeof contentPart.name === 'string') {
+                return `[tool:${contentPart.name}]`;
+            }
+            return '';
+        })
+            .filter(Boolean);
+        if (parts.length > 0) {
+            return parts.join('\n');
+        }
+    }
+    return JSON.stringify(payload);
+}
+function mapSlashCommand(command) {
+    return {
+        name: command.name,
+        description: command.description,
+        argumentHint: command.argumentHint,
+        source: 'sdk',
+    };
+}
+function mapAgent(agent) {
+    return {
+        name: agent.name,
+        description: agent.description,
+        model: agent.model,
+        source: 'sdk',
+    };
+}
+function extractUsageFromResult(message) {
+    if (message.type !== 'result') {
+        return {};
+    }
+    const result = {};
+    // Extract from usage field
+    const usage = message.usage;
+    if (isRecord(usage)) {
+        if (typeof usage.input_tokens === 'number') {
+            result.inputTokens = usage.input_tokens;
+        }
+        if (typeof usage.output_tokens === 'number') {
+            result.outputTokens = usage.output_tokens;
+        }
+    }
+    // Extract contextWindow from modelUsage (camelCase) or model_usage (snake_case)
+    const modelUsage = message.modelUsage ??
+        message.model_usage;
+    if (isRecord(modelUsage)) {
+        for (const model of Object.values(modelUsage)) {
+            if (isRecord(model)) {
+                const cw = typeof model.contextWindow === 'number'
+                    ? model.contextWindow
+                    : typeof model.context_window === 'number'
+                        ? model.context_window
+                        : undefined;
+                if (cw !== undefined) {
+                    result.contextWindowSize = cw;
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}

package/dist/src/claude/claude-session.service.d.ts

@@ -0,0 +1,10 @@
+import type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, RunClaudeSessionInput } from '../types/contracts.js';
+import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from './claude-agent-sdk-adapter.js';
+export declare class ClaudeSessionService {
+    private readonly sdkAdapter;
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter);
+    runTask(input: RunClaudeSessionInput, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    listSessions(cwd?: string): Promise<ClaudeSessionSummary[]>;
+    getTranscript(sessionId: string, cwd?: string): Promise<ClaudeSessionTranscriptMessage[]>;
+    probeCapabilities(cwd: string): Promise<ClaudeCapabilitySnapshot>;
+}

package/dist/src/claude/claude-session.service.js

@@ -0,0 +1,18 @@
+export class ClaudeSessionService {
+    sdkAdapter;
+    constructor(sdkAdapter) {
+        this.sdkAdapter = sdkAdapter;
+    }
+    runTask(input, onEvent) {
+        return this.sdkAdapter.runSession(input, onEvent);
+    }
+    listSessions(cwd) {
+        return this.sdkAdapter.listSavedSessions(cwd);
+    }
+    getTranscript(sessionId, cwd) {
+        return this.sdkAdapter.getTranscript(sessionId, cwd);
+    }
+    probeCapabilities(cwd) {
+        return this.sdkAdapter.probeCapabilities(cwd);
+    }
+}

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

@@ -0,0 +1,51 @@
+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[]>;
+}