@khalilgharbaoui/opencode-claude-code-plugin 0.1.4 → 0.1.6

package/README.md

@@ -89,6 +89,53 @@ Variants set the underlying reasoning effort. They're regular opencode model var
 
 The minimum config is just the `plugin` entry above. Everything below is optional override that goes in a `provider.claude-code` block.
 
+### Multiple Claude Code accounts
+
+Declare account names once and the plugin expands them into separate opencode providers:
+
+```json
+{
+  "plugin": ["@khalilgharbaoui/opencode-claude-code-plugin"],
+  "provider": {
+    "claude-code": {
+      "options": {
+        "accounts": ["personal", "work"]
+      }
+    }
+  }
+}
+```
+
+`default` is always implicit, so the config above creates:
+
+| Provider ID | Display name | Claude config dir |
+|---|---|---|
+| `claude-code-default` | `Claude Code (Default)` | normal `~/.claude` |
+| `claude-code-personal` | `Claude Code (Personal)` | `~/.claude-personal` |
+| `claude-code-work` | `Claude Code (Work)` | `~/.claude-work` |
+
+Non-default accounts use `CLAUDE_CONFIG_DIR` through a generated wrapper script, so auth/session state stays isolated per account. Shared capability files and folders are symlinked from `~/.claude` into each account dir when present:
+
+```text
+CLAUDE.md
+settings.json
+skills/
+agents/
+commands/
+plugins/
+```
+
+Identity/session state is not shared.
+
+Login each account once:
+
+```bash
+CLAUDE_CONFIG_DIR="$HOME/.claude-personal" claude auth login
+CLAUDE_CONFIG_DIR="$HOME/.claude-work" claude auth login
+```
+
+The account model IDs are internally suffixed, for example `claude-sonnet-4-6@work`, so long-lived Claude subprocess sessions do not collide across accounts. The generated wrapper strips the suffix before calling `claude --model`.
+
 ### Options reference
 
 ```json
@@ -112,6 +159,7 @@ The minimum config is just the `plugin` entry above. Everything below is optiona
 | Option | Type | Default | Description |
 |---|---|---|---|
 | `cliPath` | string | `process.env.CLAUDE_CLI_PATH ?? "claude"` | Path to the `claude` binary. |
+| `accounts` | string[] | – | Optional account list. `default` is implicit. Expands into `Claude Code (Default)`, `Claude Code (Personal)`, etc. |
 | `cwd` | string | `process.cwd()` | Working directory for the spawned CLI. Resolved **lazily per request**, so opencode's project switching works. |
 | `skipPermissions` | boolean | `true` | Pass `--dangerously-skip-permissions` to `claude`. Ignored when `proxyTools` is set — the proxy handles permissions through opencode instead. |
 | `permissionMode` | `acceptEdits` \| `auto` \| `bypassPermissions` \| `default` \| `dontAsk` \| `plan` | – | Forwarded to `claude --permission-mode`. |
@@ -221,7 +269,7 @@ To replace (rather than augment) bridged MCP with your own:
 
 Each chat keeps a long-lived `claude` subprocess so the model retains its native context across turns.
 
-- **Session key**: `(cwd, model, tool-scope, opencode-session-id)`. The opencode session id comes from the `x-session-affinity` header opencode sets on third-party provider calls. Two chats in the same project on the same model run in **separate** CLI processes — they don't race.
+- **Session key**: `(cwd, model, tool-scope, opencode-session-id)`. The opencode session id comes from the `x-session-affinity` header opencode sets on third-party provider calls. Two chats in the same project on the same model run in **separate** CLI processes — they don't race. In account mode, model IDs are suffixed per account, so account sessions do not collide.
 - **Same chat, multiple turns** → process reused, full Claude context retained.
 - **New chat** → fresh process under the new session key.
 - **Resumed chat after restart** → in-memory state is gone; a new process spawns and the conversation history is summarized and prepended.

package/dist/index.d.ts

@@ -83,6 +83,9 @@ interface ClaudeCodeConfig {
     provider: string;
     cliPath: string;
     cwd?: string;
+    account?: string;
+    configDir?: string;
+    providerID?: string;
     skipPermissions?: boolean;
     permissionMode?: PermissionMode;
     mcpConfig?: string | string[];
@@ -97,6 +100,10 @@ interface ClaudeCodeProviderSettings {
     cliPath?: string;
     cwd?: string;
     name?: string;
+    providerID?: string;
+    account?: string;
+    configDir?: string;
+    accounts?: string[];
     skipPermissions?: boolean;
     permissionMode?: PermissionMode;
     mcpConfig?: string | string[];

package/dist/index.js

@@ -2457,10 +2457,43 @@ function defineModel(opts) {
 var haikuCost = { input: 1e-6, output: 5e-6, cacheRead: 1e-7, cacheWrite: 125e-8 };
 var sonnetCost = { input: 3e-6, output: 15e-6, cacheRead: 3e-7, cacheWrite: 375e-8 };
 var opusCost = { input: 15e-6, output: 75e-6, cacheRead: 15e-7, cacheWrite: 1875e-8 };
+function toConfigModel(model) {
+  const inputMods = [];
+  const outputMods = [];
+  for (const [k, v] of Object.entries(model.capabilities.input)) {
+    if (v) inputMods.push(k);
+  }
+  for (const [k, v] of Object.entries(model.capabilities.output)) {
+    if (v) outputMods.push(k);
+  }
+  return {
+    id: model.api.id,
+    name: model.name,
+    status: model.status,
+    family: model.family ?? "",
+    release_date: model.release_date,
+    temperature: model.capabilities.temperature,
+    reasoning: model.capabilities.reasoning,
+    attachment: model.capabilities.attachment,
+    tool_call: model.capabilities.toolcall,
+    modalities: { input: inputMods, output: outputMods },
+    interleaved: model.capabilities.interleaved,
+    cost: {
+      input: model.cost.input,
+      output: model.cost.output,
+      cache_read: model.cost.cache.read,
+      cache_write: model.cost.cache.write
+    },
+    limit: model.limit,
+    options: model.options,
+    headers: model.headers,
+    variants: model.variants
+  };
+}
 var defaultModels = {
   "claude-haiku-4-5": defineModel({
     id: "claude-haiku-4-5",
-    name: "Claude Code Haiku 4.5",
+    name: "Claude Haiku 4.5",
     family: "haiku",
     reasoning: false,
     context: 2e5,
@@ -2470,7 +2503,7 @@ var defaultModels = {
   }),
   "claude-sonnet-4-5": defineModel({
     id: "claude-sonnet-4-5",
-    name: "Claude Code Sonnet 4.5",
+    name: "Claude Sonnet 4.5",
     family: "sonnet",
     reasoning: true,
     context: 1e6,
@@ -2480,7 +2513,7 @@ var defaultModels = {
   }),
   "claude-sonnet-4-6": defineModel({
     id: "claude-sonnet-4-6",
-    name: "Claude Code Sonnet 4.6",
+    name: "Claude Sonnet 4.6",
     family: "sonnet",
     reasoning: true,
     context: 1e6,
@@ -2490,7 +2523,7 @@ var defaultModels = {
   }),
   "claude-opus-4-5": defineModel({
     id: "claude-opus-4-5",
-    name: "Claude Code Opus 4.5",
+    name: "Claude Opus 4.5",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2500,7 +2533,7 @@ var defaultModels = {
   }),
   "claude-opus-4-6": defineModel({
     id: "claude-opus-4-6",
-    name: "Claude Code Opus 4.6",
+    name: "Claude Opus 4.6",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2510,7 +2543,7 @@ var defaultModels = {
   }),
   "claude-opus-4-7": defineModel({
     id: "claude-opus-4-7",
-    name: "Claude Code Opus 4.7",
+    name: "Claude Opus 4.7",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2520,16 +2553,161 @@ var defaultModels = {
   })
 };
 
+// src/accounts.ts
+import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
+import path3 from "path";
+var BASE_PROVIDER_ID = "claude-code";
+var DEFAULT_ACCOUNT = "default";
+var SHARED_CAPABILITY_ITEMS = [
+  "CLAUDE.md",
+  "settings.json",
+  "skills",
+  "agents",
+  "commands",
+  "plugins"
+];
+function normalizeAccountName(account) {
+  return account.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveAccounts(value) {
+  if (!Array.isArray(value)) return null;
+  const accounts = value.map((account) => normalizeAccountName(String(account))).filter(Boolean);
+  return Array.from(/* @__PURE__ */ new Set([DEFAULT_ACCOUNT, ...accounts]));
+}
+function accountProviderId(account) {
+  return `${BASE_PROVIDER_ID}-${normalizeAccountName(account)}`;
+}
+function accountDisplayName(account) {
+  return `Claude Code (${titleizeAccount(account)})`;
+}
+function accountModelSuffix(account) {
+  const normalized = normalizeAccountName(account);
+  return normalized === DEFAULT_ACCOUNT ? void 0 : normalized;
+}
+function accountConfigDir(account) {
+  const normalized = normalizeAccountName(account);
+  if (!normalized || normalized === DEFAULT_ACCOUNT) return void 0;
+  return `~/.claude-${normalized}`;
+}
+function expandHome(value) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  if (value === "~") return home ?? value;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return home ? path3.join(home, value.slice(2)) : value;
+  }
+  return value;
+}
+async function ensureAccountRuntime(account, baseCliPath) {
+  const configDir = accountConfigDir(account);
+  if (!configDir) return { cliPath: baseCliPath };
+  const expandedConfigDir = expandHome(configDir);
+  await mkdir(expandedConfigDir, { recursive: true });
+  try {
+    await ensureSharedCapabilities(expandedConfigDir);
+  } catch (err) {
+    log.warn("failed to symlink shared capabilities; continuing anyway", {
+      account,
+      configDir: expandedConfigDir,
+      error: String(err)
+    });
+  }
+  const cliPath = await writeAccountWrapper(
+    normalizeAccountName(account),
+    baseCliPath,
+    expandedConfigDir
+  );
+  return { cliPath, configDir };
+}
+async function ensureSharedCapabilities(targetRoot) {
+  const sourceRoot = expandHome("~/.claude");
+  for (const item of SHARED_CAPABILITY_ITEMS) {
+    await ensureSharedCapabilityItem(sourceRoot, targetRoot, item);
+  }
+}
+async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
+  const source = path3.join(sourceRoot, item);
+  const target = path3.join(targetRoot, item);
+  let sourceStat;
+  try {
+    sourceStat = await lstat(source);
+  } catch {
+    return;
+  }
+  try {
+    const targetStat = await lstat(target);
+    if (targetStat.isSymbolicLink()) {
+      const current = await readlink(target);
+      const resolvedCurrent = path3.resolve(path3.dirname(target), current);
+      const resolvedSource = path3.resolve(source);
+      if (resolvedCurrent === resolvedSource) return;
+    }
+    log.warn("shared Claude capability already exists; leaving untouched", {
+      item,
+      target,
+      source
+    });
+    return;
+  } catch {
+  }
+  const type = sourceStat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
+  await symlink(source, target, type);
+}
+async function writeAccountWrapper(account, baseCliPath, configDir) {
+  const cacheRoot = path3.join(
+    process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
+    "opencode-claude-code-plugin"
+  );
+  const wrapperPath = path3.join(cacheRoot, `claude-${account}`);
+  const suffix = `@${account}`;
+  await mkdir(cacheRoot, { recursive: true });
+  const script = `#!/usr/bin/env bash
+set -euo pipefail
+
+args=()
+while [[ $# -gt 0 ]]; do
+  if [[ "$1" == "--model" && $# -ge 2 ]]; then
+    model="$2"
+    if [[ "$model" == *${shellDoubleQuote(suffix)} ]]; then
+      model="\${model%${shellDoubleQuote(suffix)}}"
+    fi
+    args+=("$1" "$model")
+    shift 2
+  else
+    args+=("$1")
+    shift
+  fi
+done
+
+export CLAUDE_CONFIG_DIR=${shellSingleQuote(configDir)}
+exec ${shellSingleQuote(baseCliPath)} "\${args[@]}"
+`;
+  await writeFile(wrapperPath, script, "utf8");
+  await chmod(wrapperPath, 493);
+  return wrapperPath;
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function shellDoubleQuote(value) {
+  return value.replace(/[$`"\\]/g, "\\$&");
+}
+function titleizeAccount(account) {
+  return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
 // src/index.ts
 function createClaudeCode(settings = {}) {
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
-  const providerName = settings.name ?? "claude-code";
+  const providerName = settings.providerID ?? settings.name ?? "claude-code";
   const proxyTools = settings.proxyTools ?? ["Bash", "Edit", "Write", "WebFetch"];
   const createModel = (modelId) => {
     return new ClaudeCodeLanguageModel(modelId, {
       provider: providerName,
       cliPath,
       cwd: settings.cwd,
+      account: settings.account,
+      configDir: settings.configDir,
+      providerID: settings.providerID,
       skipPermissions: settings.skipPermissions ?? true,
       permissionMode: settings.permissionMode,
       mcpConfig: settings.mcpConfig,
@@ -2548,11 +2726,16 @@ function createClaudeCode(settings = {}) {
   provider.languageModel = createModel;
   return provider;
 }
-var PROVIDER_ID2 = "claude-code";
+var PROVIDER_ID2 = BASE_PROVIDER_ID;
 var PACKAGE_NPM = "@khalilgharbaoui/opencode-claude-code-plugin";
 function pluginEntrypoint() {
   return import.meta.url.startsWith("file:") ? import.meta.url : PACKAGE_NPM;
 }
+function cleanProviderOptions(options = {}) {
+  const result = { ...options };
+  delete result.accounts;
+  return result;
+}
 function mergeDefaultVariants(models = {}) {
   const result = { ...models };
   for (const [id, model] of Object.entries(defaultModels)) {
@@ -2569,16 +2752,20 @@ function mergeDefaultVariants(models = {}) {
   }
   return result;
 }
-function defaultModelsForProvider(providerModels) {
+function defaultModelsForProvider(providerModels, providerID = PROVIDER_ID2, modelSuffix) {
   const models = Object.fromEntries(
     Object.entries(defaultModels).map(([id, model]) => {
-      const existing = providerModels[id];
+      const modelId = modelSuffix ? `${id}@${modelSuffix}` : id;
+      const existing = providerModels[id] ?? providerModels[modelId];
       return [
-        id,
+        modelId,
         {
           ...model,
+          id: modelId,
+          providerID,
           api: {
             ...model.api,
+            id: modelId,
             npm: existing?.api?.npm ?? model.api.npm,
             url: existing?.api?.url ?? model.api.url
           }
@@ -2587,29 +2774,113 @@ function defaultModelsForProvider(providerModels) {
     })
   );
   for (const [id, model] of Object.entries(providerModels)) {
-    if (!(id in models)) models[id] = model;
+    if (!(id in models)) {
+      models[id] = {
+        ...model,
+        providerID
+      };
+    }
   }
   return models;
 }
-function providerConfig(existing) {
+function configModelsForProvider(providerModels, providerID, modelSuffix) {
+  const models = {};
+  for (const [id, model] of Object.entries(defaultModels)) {
+    const modelId = modelSuffix ? `${id}@${modelSuffix}` : id;
+    const existing = providerModels[id] ?? providerModels[modelId];
+    const full = {
+      ...model,
+      id: modelId,
+      providerID,
+      api: {
+        ...model.api,
+        id: modelId,
+        npm: existing?.api?.npm ?? model.api.npm,
+        url: existing?.api?.url ?? model.api.url
+      }
+    };
+    models[modelId] = toConfigModel(full);
+  }
+  for (const [id, model] of Object.entries(providerModels)) {
+    if (!(id in models)) {
+      models[id] = toConfigModel({ ...model, providerID });
+    }
+  }
+  return models;
+}
+async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefaults = {}, displayName) {
+  const mergedOptions = {
+    cliPath: "claude",
+    proxyTools: ["Bash", "Edit", "Write", "WebFetch"],
+    ...optionDefaults,
+    ...cleanProviderOptions(existing?.options),
+    providerID
+  };
+  const cliPath = String(mergedOptions.cliPath ?? "claude");
+  const account = typeof mergedOptions.account === "string" ? mergedOptions.account : void 0;
+  const runtime = account ? await ensureAccountRuntime(account, cliPath) : { cliPath };
   return {
-    name: existing?.name,
+    name: displayName ?? existing?.name,
     npm: existing?.npm ?? pluginEntrypoint(),
     options: {
-      cliPath: "claude",
-      proxyTools: ["Bash", "Edit", "Write", "WebFetch"],
-      ...existing?.options ?? {}
+      ...mergedOptions,
+      ...runtime
     },
     models: mergeDefaultVariants(existing?.models)
   };
 }
+async function expandAccountProviders(config) {
+  const seed = config.provider?.[PROVIDER_ID2];
+  const accounts = resolveAccounts(seed?.options?.accounts);
+  if (!accounts) return false;
+  config.provider ??= {};
+  const seedOptions = cleanProviderOptions(seed?.options);
+  let expandedCount = 0;
+  for (const account of accounts) {
+    const providerID = accountProviderId(account);
+    try {
+      const existing = config.provider[providerID];
+      const modelSuffix = accountModelSuffix(account);
+      config.provider[providerID] = {
+        ...existing,
+        ...await providerConfig(
+          existing,
+          providerID,
+          {
+            ...seedOptions,
+            account
+          },
+          accountDisplayName(account)
+        ),
+        models: configModelsForProvider(
+          existing?.models ?? seed?.models ?? {},
+          providerID,
+          modelSuffix
+        )
+      };
+      expandedCount++;
+    } catch (err) {
+      log.error("failed to expand account provider", {
+        account,
+        providerID,
+        error: String(err)
+      });
+    }
+  }
+  if (expandedCount > 0) {
+    delete config.provider[PROVIDER_ID2];
+  }
+  return expandedCount > 0;
+}
 var server = async () => ({
   config: async (config) => {
     config.provider ??= {};
+    const expanded = await expandAccountProviders(config);
+    if (expanded) return;
     const existing = config.provider[PROVIDER_ID2];
     config.provider[PROVIDER_ID2] = {
       ...existing,
-      ...providerConfig(existing)
+      ...await providerConfig(existing)
     };
   },
   provider: {