@doingdev/opencode-claude-manager-plugin 0.1.9 → 0.1.10

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

@@ -110,7 +110,7 @@ export class ClaudeAgentSdkAdapter {
             settingSources: input.settingSources,
             maxTurns: input.maxTurns,
             model: input.model,
-            permissionMode: input.permissionMode,
+            permissionMode: input.permissionMode ?? 'acceptEdits',
             systemPrompt: input.systemPrompt
                 ? { type: 'preset', preset: 'claude_code', append: input.systemPrompt }
                 : { type: 'preset', preset: 'claude_code' },

package/dist/claude/delegated-can-use-tool.d.ts

@@ -0,0 +1,7 @@
+import type { CanUseTool } from '@anthropic-ai/claude-agent-sdk';
+import type { DelegatedToolPermissionPolicy } from '../types/contracts.js';
+export type DelegatedCanUseToolOptions = {
+    /** Override TTY detection (for tests or custom hosts). */
+    isInteractiveTerminal?: () => boolean;
+};
+export declare function createDelegatedCanUseTool(policy: DelegatedToolPermissionPolicy, factoryOptions?: DelegatedCanUseToolOptions): CanUseTool;

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

@@ -0,0 +1,178 @@
+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/plugin/claude-code-permission-bridge.d.ts

@@ -0,0 +1,15 @@
+import type { ToolContext } from '@opencode-ai/plugin';
+import type { ManagerSessionCanUseToolFactory } from '../types/contracts.js';
+export interface ClaudeCodePermissionBridge {
+    createCanUseTool: ManagerSessionCanUseToolFactory;
+}
+/**
+ * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
+ * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
+ *
+ * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
+ * allow with answers set to each question's first option label so the session can proceed;
+ * the UI should still show full choices — users needing a different option should answer via
+ * the primary agent and re-run.
+ */
+export declare function createClaudeCodePermissionBridge(context: ToolContext): ClaudeCodePermissionBridge;

package/dist/plugin/claude-code-permission-bridge.js

@@ -0,0 +1,184 @@
+/**
+ * Bridges Claude Agent SDK tool permission prompts to OpenCode `ToolContext.ask`.
+ * Serializes concurrent asks: parallel manager sub-sessions share one OpenCode tool context.
+ *
+ * AskUserQuestion: OpenCode `ask` does not return selected labels. After approval we return
+ * allow with answers set to each question's first option label so the session can proceed;
+ * the UI should still show full choices — users needing a different option should answer via
+ * the primary agent and re-run.
+ */
+export function createClaudeCodePermissionBridge(context) {
+    const queue = createPermissionAskQueue();
+    return {
+        createCanUseTool(scope) {
+            return (toolName, input, options) => queue.enqueue(() => bridgeCanUseTool(context, scope, toolName, input, options));
+        },
+    };
+}
+function createPermissionAskQueue() {
+    let chain = Promise.resolve();
+    return {
+        enqueue(operation) {
+            const resultPromise = chain
+                .catch(() => undefined)
+                .then(operation);
+            chain = resultPromise.then(() => undefined, () => undefined);
+            return resultPromise;
+        },
+    };
+}
+async function bridgeCanUseTool(context, scope, toolName, input, options) {
+    if (options.signal.aborted) {
+        return {
+            behavior: 'deny',
+            message: 'Permission request aborted.',
+            toolUseID: options.toolUseID,
+        };
+    }
+    if (toolName === 'AskUserQuestion') {
+        return handleAskUserQuestion(context, scope, input, options);
+    }
+    const permission = mapClaudeToolToOpenCodePermission(toolName);
+    const patterns = derivePatterns(toolName, input);
+    const metadata = buildMetadata(scope, toolName, input, options);
+    try {
+        await context.ask({
+            permission,
+            patterns,
+            always: [],
+            metadata,
+        });
+        return {
+            behavior: 'allow',
+            updatedInput: input,
+            toolUseID: options.toolUseID,
+        };
+    }
+    catch (error) {
+        return {
+            behavior: 'deny',
+            message: error instanceof Error
+                ? error.message
+                : 'OpenCode permission request was rejected or failed.',
+            toolUseID: options.toolUseID,
+        };
+    }
+}
+async function handleAskUserQuestion(context, scope, input, options) {
+    const questions = input.questions;
+    if (!Array.isArray(questions) || questions.length === 0) {
+        return {
+            behavior: 'deny',
+            message: 'AskUserQuestion invoked without a valid questions array.',
+            toolUseID: options.toolUseID,
+        };
+    }
+    const metadata = {
+        ...buildMetadata(scope, 'AskUserQuestion', input, options),
+        questions,
+        note: 'Claude Code AskUserQuestion: approving proceeds with the first listed option per question unless the host supplies structured replies.',
+    };
+    try {
+        await context.ask({
+            permission: 'question',
+            patterns: [],
+            always: [],
+            metadata,
+        });
+        const answers = buildDefaultAskUserQuestionAnswers(questions);
+        return {
+            behavior: 'allow',
+            updatedInput: {
+                ...input,
+                questions,
+                answers,
+            },
+            toolUseID: options.toolUseID,
+        };
+    }
+    catch (error) {
+        return {
+            behavior: 'deny',
+            message: error instanceof Error
+                ? error.message
+                : 'OpenCode declined or failed the clarifying-question prompt.',
+            toolUseID: options.toolUseID,
+        };
+    }
+}
+function buildDefaultAskUserQuestionAnswers(questions) {
+    const answers = {};
+    for (const raw of questions) {
+        if (!raw || typeof raw !== 'object') {
+            continue;
+        }
+        const entry = raw;
+        const questionText = typeof entry.question === 'string' ? entry.question : '';
+        if (!questionText) {
+            continue;
+        }
+        const options = Array.isArray(entry.options) ? entry.options : [];
+        const first = options[0];
+        const label = first &&
+            typeof first === 'object' &&
+            first !== null &&
+            typeof first.label === 'string'
+            ? first.label
+            : 'Default';
+        answers[questionText] = label;
+    }
+    return answers;
+}
+function mapClaudeToolToOpenCodePermission(toolName) {
+    switch (toolName) {
+        case 'Read':
+            return 'read';
+        case 'Write':
+        case 'Edit':
+        case 'NotebookEdit':
+            return 'edit';
+        case 'Bash':
+            return 'bash';
+        case 'Glob':
+            return 'glob';
+        case 'Grep':
+            return 'grep';
+        case 'Task':
+        case 'Agent':
+            return 'task';
+        case 'WebFetch':
+            return 'webfetch';
+        case 'WebSearch':
+            return 'websearch';
+        default:
+            return 'bash';
+    }
+}
+function derivePatterns(toolName, input) {
+    const filePath = input.file_path ?? input.path;
+    if (typeof filePath === 'string' && filePath.length > 0) {
+        return [filePath];
+    }
+    if (toolName === 'Bash' && typeof input.command === 'string') {
+        return [input.command];
+    }
+    return [];
+}
+function buildMetadata(scope, toolName, input, options) {
+    return {
+        source: 'claude_code',
+        managerRunId: scope.runId,
+        managerPlanId: scope.planId,
+        managerPlanTitle: scope.planTitle,
+        claudeTool: toolName,
+        toolInput: input,
+        toolUseID: options.toolUseID,
+        agentID: options.agentID,
+        title: options.title,
+        displayName: options.displayName,
+        description: options.description,
+        blockedPath: options.blockedPath,
+        decisionReason: options.decisionReason,
+        sdkSuggestions: options.suggestions,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",