@khalilgharbaoui/opencode-claude-code-plugin 0.1.0 → 0.1.5

package/dist/index.js

@@ -2520,16 +2520,153 @@ 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 });
+  await ensureSharedCapabilities(expandedConfigDir);
+  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 +2685,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 +2711,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 +2733,76 @@ 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) {
+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);
+  for (const account of accounts) {
+    const providerID = accountProviderId(account);
+    const existing = config.provider[providerID];
+    const modelSuffix = accountModelSuffix(account);
+    config.provider[providerID] = {
+      ...existing,
+      ...await providerConfig(
+        existing,
+        providerID,
+        {
+          ...seedOptions,
+          account
+        },
+        accountDisplayName(account)
+      ),
+      models: defaultModelsForProvider(
+        existing?.models ?? seed?.models ?? {},
+        providerID,
+        modelSuffix
+      )
+    };
+  }
+  delete config.provider[PROVIDER_ID2];
+  return true;
+}
 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: {