@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/commands/handlers/betas.ts

@@ -0,0 +1,100 @@
+// ---------------------------------------------------------------------------
+// Betas slash-command handler (/anthropic betas)
+// ---------------------------------------------------------------------------
+
+import { resolveBetaShortcut } from "../../betas.js";
+import type { AnthropicAuthConfig } from "../../config.js";
+import { loadConfigFresh, saveConfig } from "../../config.js";
+import { isTruthyEnv } from "../../env.js";
+
+export interface BetasHandlerDeps {
+    sendCommandMessage: (sessionID: string, message: string) => Promise<void>;
+    config: AnthropicAuthConfig;
+    initialAccountPinned: boolean;
+}
+
+/**
+ * Handle /anthropic betas [list|add|remove <beta>].
+ */
+export async function handleBetasCommand(sessionID: string, args: string[], deps: BetasHandlerDeps): Promise<void> {
+    const { sendCommandMessage, config, initialAccountPinned } = deps;
+    const action = (args[1] || "").toLowerCase();
+
+    if (!action || action === "list") {
+        const fresh = loadConfigFresh();
+        const strategy = fresh.account_selection_strategy || config.account_selection_strategy;
+        const lines = [
+            "▣ Anthropic Betas",
+            "",
+            "Preset betas (auto-computed per model/provider):",
+            "  oauth-2025-04-20, claude-code-20250219,",
+            "  advanced-tool-use-2025-11-20, fast-mode-2026-02-01,",
+            "  interleaved-thinking-2025-05-14 (non-Opus 4.6) OR effort-2025-11-24 (Opus 4.6),",
+            "  files-api-2025-04-14 (only /v1/files and requests with file_id),",
+            "  token-counting-2024-11-01 (only /v1/messages/count_tokens),",
+            `  prompt-caching-scope-2026-01-05 (non-interactive${strategy === "round-robin" ? ", skipped in round-robin" : ""})`,
+            "",
+            `Experimental betas: ${isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS) ? "disabled (CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1)" : "enabled"}`,
+            `Strategy: ${strategy}${initialAccountPinned ? " (pinned via OPENCODE_ANTHROPIC_INITIAL_ACCOUNT)" : ""}`,
+            `Custom betas: ${fresh.custom_betas.length ? fresh.custom_betas.join(", ") : "(none)"}`,
+            "",
+            "Toggleable presets:",
+            "  /anthropic betas add structured-outputs-2025-12-15",
+            "  /anthropic betas add context-management-2025-06-27",
+            "  /anthropic betas add task-budgets-2026-03-13",
+            "  /anthropic betas add web-search-2025-03-05",
+            "  /anthropic betas add compact-2026-01-12",
+            "  /anthropic betas add mcp-servers-2025-12-04",
+            "  /anthropic betas add redact-thinking-2026-02-12",
+            "  /anthropic betas add 1m   (shortcut for context-1m-2025-08-07)",
+            "",
+            "Remove: /anthropic betas remove <beta>",
+        ];
+        await sendCommandMessage(sessionID, lines.join("\n"));
+        return;
+    }
+
+    if (action === "add") {
+        const betaInput = args[2]?.trim();
+        if (!betaInput) {
+            await sendCommandMessage(sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas add <beta-name>");
+            return;
+        }
+        const beta = resolveBetaShortcut(betaInput);
+        const fresh = loadConfigFresh();
+        const current = fresh.custom_betas || [];
+        if (current.includes(beta)) {
+            await sendCommandMessage(sessionID, `▣ Anthropic Betas\n\n"${beta}" already added.`);
+            return;
+        }
+        saveConfig({ custom_betas: [...current, beta] });
+        Object.assign(config, loadConfigFresh());
+        const fromShortcut = beta !== betaInput;
+        await sendCommandMessage(
+            sessionID,
+            `▣ Anthropic Betas\n\nAdded: ${beta}${fromShortcut ? ` (from shortcut: ${betaInput})` : ""}`,
+        );
+        return;
+    }
+
+    if (action === "remove" || action === "rm") {
+        const betaInput = args[2]?.trim();
+        if (!betaInput) {
+            await sendCommandMessage(sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas remove <beta-name>");
+            return;
+        }
+        const beta = resolveBetaShortcut(betaInput);
+        const fresh = loadConfigFresh();
+        const current = fresh.custom_betas || [];
+        if (!current.includes(beta)) {
+            await sendCommandMessage(sessionID, `▣ Anthropic Betas\n\n"${beta}" not in custom betas.`);
+            return;
+        }
+        saveConfig({ custom_betas: current.filter((b) => b !== beta) });
+        Object.assign(config, loadConfigFresh());
+        await sendCommandMessage(sessionID, `▣ Anthropic Betas\n\nRemoved: ${beta}`);
+        return;
+    }
+
+    await sendCommandMessage(sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas [add|remove <beta>]");
+}

package/src/commands/handlers/config.ts

@@ -0,0 +1,99 @@
+// ---------------------------------------------------------------------------
+// Config slash-command handlers (/anthropic config, /anthropic set)
+// ---------------------------------------------------------------------------
+
+import type { AnthropicAuthConfig } from "../../config.js";
+import { loadConfigFresh, saveConfig } from "../../config.js";
+
+export interface ConfigHandlerDeps {
+    sendCommandMessage: (sessionID: string, message: string) => Promise<void>;
+    config: AnthropicAuthConfig;
+}
+
+/**
+ * Handle /anthropic config — display current configuration.
+ */
+export async function handleConfigCommand(sessionID: string, deps: ConfigHandlerDeps): Promise<void> {
+    const { sendCommandMessage } = deps;
+    const fresh = loadConfigFresh();
+    const lines = [
+        "▣ Anthropic Config",
+        "",
+        `strategy: ${fresh.account_selection_strategy}`,
+        `emulation: ${fresh.signature_emulation.enabled ? "on" : "off"}`,
+        `compaction: ${fresh.signature_emulation.prompt_compaction}`,
+        `1m-context: ${fresh.override_model_limits.enabled ? "on" : "off"}`,
+        `idle-refresh: ${fresh.idle_refresh.enabled ? "on" : "off"}`,
+        `debug: ${fresh.debug ? "on" : "off"}`,
+        `quiet: ${fresh.toasts.quiet ? "on" : "off"}`,
+        `custom_betas: ${fresh.custom_betas.length ? fresh.custom_betas.join(", ") : "(none)"}`,
+    ];
+    await sendCommandMessage(sessionID, lines.join("\n"));
+}
+
+/**
+ * Handle /anthropic set <key> <value> — update a config setting.
+ */
+export async function handleSetCommand(sessionID: string, args: string[], deps: ConfigHandlerDeps): Promise<void> {
+    const { sendCommandMessage, config } = deps;
+    const key = (args[1] || "").toLowerCase();
+    const value = (args[2] || "").toLowerCase();
+    const setters: Record<string, () => void> = {
+        emulation: () =>
+            saveConfig({
+                signature_emulation: {
+                    enabled: value === "on" || value === "1" || value === "true",
+                },
+            }),
+        compaction: () =>
+            saveConfig({
+                signature_emulation: {
+                    prompt_compaction: value === "off" ? "off" : "minimal",
+                },
+            }),
+        "1m-context": () =>
+            saveConfig({
+                override_model_limits: {
+                    enabled: value === "on" || value === "1" || value === "true",
+                },
+            }),
+        "idle-refresh": () =>
+            saveConfig({
+                idle_refresh: {
+                    enabled: value === "on" || value === "1" || value === "true",
+                },
+            }),
+        debug: () =>
+            saveConfig({
+                debug: value === "on" || value === "1" || value === "true",
+            }),
+        quiet: () =>
+            saveConfig({
+                toasts: {
+                    quiet: value === "on" || value === "1" || value === "true",
+                },
+            }),
+        strategy: () => {
+            const valid = ["sticky", "round-robin", "hybrid"];
+            if (valid.includes(value))
+                saveConfig({ account_selection_strategy: value as "sticky" | "round-robin" | "hybrid" });
+            else throw new Error(`Invalid strategy. Valid: ${valid.join(", ")}`);
+        },
+    };
+
+    if (!key || !setters[key]) {
+        const keys = Object.keys(setters).join(", ");
+        await sendCommandMessage(
+            sessionID,
+            `▣ Anthropic Set\n\nUsage: /anthropic set <key> <value>\nKeys: ${keys}\nValues: on/off (or specific values for strategy/compaction)`,
+        );
+        return;
+    }
+    if (!value) {
+        await sendCommandMessage(sessionID, `▣ Anthropic Set\n\nMissing value for "${key}".`);
+        return;
+    }
+    setters[key]();
+    Object.assign(config, loadConfigFresh());
+    await sendCommandMessage(sessionID, `▣ Anthropic Set\n\n${key} = ${value}`);
+}

package/src/commands/handlers/files.ts

@@ -0,0 +1,375 @@
+// ---------------------------------------------------------------------------
+// Files API slash-command handler (/anthropic files)
+// ---------------------------------------------------------------------------
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import type { AccountManager } from "../../accounts.js";
+import type { ManagedAccount } from "../../token-refresh.js";
+
+/**
+ * Maximum number of file-to-account pinning entries retained in memory.
+ * Bounded to prevent unbounded growth across long sessions that touch many
+ * Files API uploads. Eviction is FIFO: when the cap is hit, the oldest entry
+ * (Maps preserve insertion order) is dropped before inserting the new one.
+ */
+export const FILE_ACCOUNT_MAP_MAX_SIZE = 1000;
+
+/**
+ * Insert a fileId→accountIndex binding with FIFO eviction when the cap is reached.
+ * See {@link FILE_ACCOUNT_MAP_MAX_SIZE} for the rationale.
+ */
+export function capFileAccountMap(fileAccountMap: Map<string, number>, fileId: string, accountIndex: number): void {
+    if (fileAccountMap.size >= FILE_ACCOUNT_MAP_MAX_SIZE) {
+        const oldestKey = fileAccountMap.keys().next().value;
+        if (oldestKey !== undefined) fileAccountMap.delete(oldestKey);
+    }
+    fileAccountMap.set(fileId, accountIndex);
+}
+
+export interface FilesHandlerDeps {
+    sendCommandMessage: (sessionID: string, message: string) => Promise<void>;
+    accountManager: AccountManager | null;
+    fileAccountMap: Map<string, number>;
+    refreshAccountTokenSingleFlight: (account: ManagedAccount) => Promise<string>;
+}
+
+type ResolvedAccount = { account: ManagedAccount; label: string };
+
+function resolveTargetAccount(accountManager: AccountManager, identifier: string | null): ResolvedAccount | null {
+    const accounts = accountManager.getEnabledAccounts();
+    if (identifier) {
+        const byEmail = accounts.find((a) => a.email === identifier);
+        if (byEmail) return { account: byEmail, label: byEmail.email || `Account ${byEmail.index + 1}` };
+        const idx = parseInt(identifier, 10);
+        if (!isNaN(idx) && idx >= 1) {
+            const byIdx = accounts.find((a) => a.index === idx - 1);
+            if (byIdx) return { account: byIdx, label: byIdx.email || `Account ${byIdx.index + 1}` };
+        }
+        return null;
+    }
+    const current = accountManager.getCurrentAccount();
+    if (!current) return null;
+    return { account: current, label: current.email || `Account ${current.index + 1}` };
+}
+
+async function getFilesAuth(
+    acct: ManagedAccount,
+    refreshAccountTokenSingleFlight: (account: ManagedAccount) => Promise<string>,
+) {
+    let tok = acct.access;
+    if (!tok || !acct.expires || acct.expires < Date.now()) {
+        tok = await refreshAccountTokenSingleFlight(acct);
+    }
+    return {
+        authorization: `Bearer ${tok}`,
+        "anthropic-beta": "oauth-2025-04-20,files-api-2025-04-14",
+    };
+}
+
+const API_BASE = "https://api.anthropic.com";
+
+/**
+ * Handle /anthropic files [list|upload|get|delete|download].
+ */
+export async function handleFilesCommand(sessionID: string, args: string[], deps: FilesHandlerDeps): Promise<void> {
+    const { sendCommandMessage, accountManager, fileAccountMap, refreshAccountTokenSingleFlight } = deps;
+
+    let targetAccountId: string | null = null;
+    const filteredArgs: string[] = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--account" && i + 1 < args.length) {
+            targetAccountId = args[i + 1];
+            i++;
+        } else {
+            filteredArgs.push(args[i]);
+        }
+    }
+    const action = (filteredArgs[1] || "").toLowerCase();
+
+    if (!accountManager || accountManager.getAccountCount() === 0) {
+        await sendCommandMessage(
+            sessionID,
+            "▣ Anthropic Files (error)\n\nNo accounts configured. Use /anthropic login first.",
+        );
+        return;
+    }
+
+    try {
+        if (!action || action === "list") {
+            if (targetAccountId) {
+                const resolved = resolveTargetAccount(accountManager, targetAccountId);
+                if (!resolved) {
+                    await sendCommandMessage(
+                        sessionID,
+                        `▣ Anthropic Files (error)\n\nAccount not found: ${targetAccountId}`,
+                    );
+                    return;
+                }
+                const { account, label } = resolved;
+                const headers = await getFilesAuth(account, refreshAccountTokenSingleFlight);
+                const res = await fetch(`${API_BASE}/v1/files`, { headers });
+                if (!res.ok) {
+                    const errBody = await res.text();
+                    await sendCommandMessage(
+                        sessionID,
+                        `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+                    );
+                    return;
+                }
+                const data = (await res.json()) as {
+                    data?: Array<{ id: string; filename: string; size: number; purpose: string }>;
+                };
+                const files = data.data || [];
+                for (const f of files) capFileAccountMap(fileAccountMap, f.id, account.index);
+                if (files.length === 0) {
+                    await sendCommandMessage(sessionID, `▣ Anthropic Files [${label}]\n\nNo files uploaded.`);
+                    return;
+                }
+                const lines = [`▣ Anthropic Files [${label}]`, "", `${files.length} file(s):`, ""];
+                for (const f of files) {
+                    const sizeKB = (f.size / 1024).toFixed(1);
+                    lines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+                }
+                await sendCommandMessage(sessionID, lines.join("\n"));
+                return;
+            }
+
+            const accounts = accountManager.getEnabledAccounts();
+            const allLines = ["▣ Anthropic Files (all accounts)", ""];
+            let totalFiles = 0;
+            for (const acct of accounts) {
+                const label = acct.email || `Account ${acct.index + 1}`;
+                try {
+                    const headers = await getFilesAuth(acct, refreshAccountTokenSingleFlight);
+                    const res = await fetch(`${API_BASE}/v1/files`, { headers });
+                    if (!res.ok) {
+                        allLines.push(`[${label}] Error: HTTP ${res.status}`);
+                        allLines.push("");
+                        continue;
+                    }
+                    const data = (await res.json()) as {
+                        data?: Array<{ id: string; filename: string; size: number; purpose: string }>;
+                    };
+                    const files = data.data || [];
+                    for (const f of files) capFileAccountMap(fileAccountMap, f.id, acct.index);
+                    totalFiles += files.length;
+                    if (files.length === 0) {
+                        allLines.push(`[${label}] No files`);
+                    } else {
+                        allLines.push(`[${label}] ${files.length} file(s):`);
+                        for (const f of files) {
+                            const sizeKB = (f.size / 1024).toFixed(1);
+                            allLines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+                        }
+                    }
+                    allLines.push("");
+                } catch (err) {
+                    allLines.push(`[${label}] Error: ${(err as Error).message}`);
+                    allLines.push("");
+                }
+            }
+            if (totalFiles === 0 && accounts.length > 0) {
+                allLines.push(`Total: No files across ${accounts.length} account(s).`);
+            } else {
+                allLines.push(`Total: ${totalFiles} file(s) across ${accounts.length} account(s).`);
+            }
+            if (accounts.length > 1) {
+                allLines.push("", "Tip: Use --account <email> to target a specific account.");
+            }
+            await sendCommandMessage(sessionID, allLines.join("\n"));
+            return;
+        }
+
+        const resolved = resolveTargetAccount(accountManager, targetAccountId);
+        if (!resolved) {
+            const errMsg = targetAccountId ? `Account not found: ${targetAccountId}` : "No accounts available.";
+            await sendCommandMessage(sessionID, `▣ Anthropic Files (error)\n\n${errMsg}`);
+            return;
+        }
+        const { account, label } = resolved;
+        const authHeaders = await getFilesAuth(account, refreshAccountTokenSingleFlight);
+
+        if (action === "upload") {
+            const filePath = filteredArgs.slice(2).join(" ").trim();
+            if (!filePath) {
+                await sendCommandMessage(
+                    sessionID,
+                    "▣ Anthropic Files\n\nUsage: /anthropic files upload <path> [--account <email>]",
+                );
+                return;
+            }
+            const resolvedPath = resolve(filePath);
+            if (!existsSync(resolvedPath)) {
+                await sendCommandMessage(sessionID, `▣ Anthropic Files (error)\n\nFile not found: ${resolvedPath}`);
+                return;
+            }
+            const content = readFileSync(resolvedPath);
+            const filename = basename(resolvedPath);
+            const blob = new Blob([content]);
+            const form = new FormData();
+            form.append("file", blob, filename);
+            form.append("purpose", "assistants");
+            const res = await fetch(`${API_BASE}/v1/files`, {
+                method: "POST",
+                headers: {
+                    authorization: authHeaders.authorization,
+                    "anthropic-beta": "oauth-2025-04-20,files-api-2025-04-14",
+                },
+                body: form,
+            });
+            if (!res.ok) {
+                const errBody = await res.text();
+                await sendCommandMessage(
+                    sessionID,
+                    `▣ Anthropic Files (error) [${label}]\n\nUpload failed (HTTP ${res.status}): ${errBody}`,
+                );
+                return;
+            }
+            const file = (await res.json()) as { id: string; filename: string; size?: number };
+            const sizeKB = ((file.size || 0) / 1024).toFixed(1);
+            capFileAccountMap(fileAccountMap, file.id, account.index);
+            await sendCommandMessage(
+                sessionID,
+                `▣ Anthropic Files [${label}]\n\nUploaded: ${file.id}\n  Filename: ${file.filename}\n  Size: ${sizeKB} KB`,
+            );
+            return;
+        }
+
+        if (action === "get" || action === "info") {
+            const fileId = filteredArgs[2]?.trim();
+            if (!fileId) {
+                await sendCommandMessage(
+                    sessionID,
+                    "▣ Anthropic Files\n\nUsage: /anthropic files get <file_id> [--account <email>]",
+                );
+                return;
+            }
+            const res = await fetch(`${API_BASE}/v1/files/${encodeURIComponent(fileId)}`, { headers: authHeaders });
+            if (!res.ok) {
+                const errBody = await res.text();
+                await sendCommandMessage(
+                    sessionID,
+                    `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+                );
+                return;
+            }
+            const file = (await res.json()) as {
+                id: string;
+                filename: string;
+                purpose: string;
+                size?: number;
+                mime_type?: string;
+                created_at?: string;
+            };
+            capFileAccountMap(fileAccountMap, file.id, account.index);
+            const lines = [
+                `▣ Anthropic Files [${label}]`,
+                "",
+                `  ID:       ${file.id}`,
+                `  Filename: ${file.filename}`,
+                `  Purpose:  ${file.purpose}`,
+                `  Size:     ${((file.size || 0) / 1024).toFixed(1)} KB`,
+                `  Type:     ${file.mime_type || "unknown"}`,
+                `  Created:  ${file.created_at || "unknown"}`,
+            ];
+            await sendCommandMessage(sessionID, lines.join("\n"));
+            return;
+        }
+
+        if (action === "delete" || action === "rm") {
+            const fileId = filteredArgs[2]?.trim();
+            if (!fileId) {
+                await sendCommandMessage(
+                    sessionID,
+                    "▣ Anthropic Files\n\nUsage: /anthropic files delete <file_id> [--account <email>]",
+                );
+                return;
+            }
+            const res = await fetch(`${API_BASE}/v1/files/${encodeURIComponent(fileId)}`, {
+                method: "DELETE",
+                headers: authHeaders,
+            });
+            if (!res.ok) {
+                const errBody = await res.text();
+                await sendCommandMessage(
+                    sessionID,
+                    `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+                );
+                return;
+            }
+            fileAccountMap.delete(fileId);
+            await sendCommandMessage(sessionID, `▣ Anthropic Files [${label}]\n\nDeleted: ${fileId}`);
+            return;
+        }
+
+        if (action === "download" || action === "dl") {
+            const fileId = filteredArgs[2]?.trim();
+            if (!fileId) {
+                await sendCommandMessage(
+                    sessionID,
+                    "▣ Anthropic Files\n\nUsage: /anthropic files download <file_id> [output_path] [--account <email>]",
+                );
+                return;
+            }
+            const outputPath = filteredArgs.slice(3).join(" ").trim();
+            const metaRes = await fetch(`${API_BASE}/v1/files/${encodeURIComponent(fileId)}`, { headers: authHeaders });
+            if (!metaRes.ok) {
+                const errBody = await metaRes.text();
+                await sendCommandMessage(
+                    sessionID,
+                    `▣ Anthropic Files (error) [${label}]\n\nHTTP ${metaRes.status}: ${errBody}`,
+                );
+                return;
+            }
+            const meta = (await metaRes.json()) as { filename: string };
+            const savePath = outputPath ? resolve(outputPath) : resolve(meta.filename);
+            const res = await fetch(`${API_BASE}/v1/files/${encodeURIComponent(fileId)}/content`, {
+                headers: authHeaders,
+            });
+            if (!res.ok) {
+                const errBody = await res.text();
+                await sendCommandMessage(
+                    sessionID,
+                    `▣ Anthropic Files (error) [${label}]\n\nDownload failed (HTTP ${res.status}): ${errBody}`,
+                );
+                return;
+            }
+            const buffer = Buffer.from(await res.arrayBuffer());
+            writeFileSync(savePath, buffer);
+            const sizeKB = (buffer.length / 1024).toFixed(1);
+            await sendCommandMessage(
+                sessionID,
+                `▣ Anthropic Files [${label}]\n\nDownloaded: ${meta.filename}\n  Saved to: ${savePath}\n  Size: ${sizeKB} KB`,
+            );
+            return;
+        }
+
+        const helpLines = [
+            "▣ Anthropic Files",
+            "",
+            "Usage: /anthropic files <action> [--account <email|index>]",
+            "",
+            "Actions:",
+            "  list                          List uploaded files (all accounts if no --account)",
+            "  upload <path>                 Upload a file (max 350MB)",
+            "  get <file_id>                 Get file metadata",
+            "  delete <file_id>              Delete a file",
+            "  download <file_id> [path]     Download file content",
+            "",
+            "Options:",
+            "  --account <email|index>       Target a specific account (1-based index)",
+            "",
+            "Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images",
+            "Files can be referenced by file_id in Messages API requests.",
+            "",
+            "When using round-robin, file_ids are automatically pinned to the",
+            "account that owns them for Messages API requests.",
+        ];
+        await sendCommandMessage(sessionID, helpLines.join("\n"));
+        return;
+    } catch (err) {
+        await sendCommandMessage(sessionID, `▣ Anthropic Files (error)\n\n${(err as Error).message}`);
+        return;
+    }
+}