opencode-resolve 0.1.6 → 0.1.8

package/scripts/postinstall.mjs

@@ -1,7 +1,9 @@
+import { spawn } from "node:child_process"
 import { constants } from "node:fs"
 import { access, mkdir, readFile, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
+import { createInterface } from "node:readline/promises"
 import { fileURLToPath } from "node:url"
 
 const packageName = "opencode-resolve"
@@ -15,6 +17,30 @@ const ADDITIVE_DEFAULTS = {
   autoApprove: true,
 }
 
+// ZAI local MCP server bootstrap for GLM users.
+// Do not copy provider secrets from OpenCode's auth store into opencode.json.
+// The MCP process should receive credentials from the user's runtime environment.
+const ZAI_MCP_SERVERS = {
+  "zai-mcp-server": {
+    type: "local",
+    command: ["npx", "-y", "@z_ai/mcp-server"],
+    environment: {
+      Z_AI_MODE: "ZAI",
+    },
+  },
+}
+
+const COMPANION_PLUGINS = [
+  {
+    pkg: "@tarquinen/opencode-dcp",
+    desc: "Dynamic Context Pruning — strips obsolete tool outputs so long resolver loops cost fewer tokens",
+  },
+  {
+    pkg: "@slkiser/opencode-quota",
+    desc: "Live token/quota usage indicator — supports GLM coding-plan, OpenAI Plus/Pro, Qwen, and more",
+  },
+]
+
 if (process.env.OPENCODE_RESOLVE_SKIP_POSTINSTALL === "1") {
   process.exit(0)
 }
@@ -24,6 +50,7 @@ console.log(`[${packageName}] installing v${pluginVersion}`)
 
 try {
   await registerPlugin()
+  await offerCompanionPlugins()
   console.log(`[${packageName}] v${pluginVersion} install complete — restart OpenCode to load the plugin`)
 } catch (error) {
   console.warn(`[${packageName}] automatic OpenCode registration skipped: ${formatError(error)}`)
@@ -44,11 +71,19 @@ async function registerPlugin() {
   await mkdir(configDir, { recursive: true })
 
   const config = await readOpenCodeConfig()
-  const changed = addPlugin(config)
+  let configChanged = addPlugin(config)
+
+  // Inject ZAI MCP servers when GLM is detected
+  const allModels = detectAllModels(config)
+  const hasGLM = allModels.some((m) => isGLMModel(m))
+  if (hasGLM) {
+    const mcpChanged = await injectZAIMCPs(config)
+    configChanged = configChanged || mcpChanged
+  }
 
-  if (changed) {
+  if (configChanged) {
     await writeFile(opencodeConfigPath, `${JSON.stringify(config, null, 2)}\n`)
-    console.log(`[${packageName}] registered in ${opencodeConfigPath}`)
+    console.log(`[${packageName}] updated ${opencodeConfigPath}`)
   } else {
     console.log(`[${packageName}] already registered in ${opencodeConfigPath}`)
   }
@@ -67,9 +102,27 @@ async function createAdaptiveResolveConfig(opencodeConfig) {
   const example = JSON.parse(raw)
 
   const currentModel = detectOpenCodeModel(opencodeConfig)
-  const preset = buildModelPreset(currentModel)
-
+  const allModels = detectAllModels(opencodeConfig)
   const resolveConfig = { ...example }
+
+  // Profile selection based on detected providers
+  const hasGLM = allModels.some((m) => isGLMModel(m))
+  const hasGPT = allModels.some((m) => isGPTModel(m))
+  const preset = buildModelPreset(currentModel, allModels)
+
+  if (hasGLM && !hasGPT) {
+    // GLM only → GLM profile, silver tier (token-efficient, no deep-reviewer)
+    resolveConfig.profile = "glm"
+    resolveConfig.tier = "silver"
+  } else if (hasGPT && !hasGLM) {
+    // GPT only → GPT profile, gold tier (full power)
+    resolveConfig.profile = "gpt"
+    resolveConfig.tier = "gold"
+  } else {
+    // Mixed or unknown provider → explicit mix profile. No tier: use DEFAULT_ENABLED.
+    resolveConfig.profile = "mix"
+  }
+
   if (preset && Object.keys(preset).length > 0) {
     resolveConfig.models = preset
   }
@@ -107,54 +160,155 @@ function detectOpenCodeModel(config) {
   return null
 }
 
-function buildModelPreset(currentModel) {
-  if (!currentModel) return {}
-
-  const lower = currentModel.toLowerCase()
+function buildModelPreset(currentModel, allModels = []) {
+  const glmModel = allModels.find((m) => isGLMModel(m))
+  const gptModel = allModels.find((m) => isGPTModel(m))
 
-  // GLM / ZAI mixed preset
-  if (lower.includes("glm") || lower.includes("zai")) {
+  if (glmModel && gptModel) {
     return {
-      glm: "zai-coding-plan/glm-5.1",
-      gpt: "openai/gpt-5.5",
+      mix: "gpt",
+      glm: glmModel,
+      gpt: gptModel,
+      bronze: "glm",
+      silver: "glm",
+      gold: "gpt",
       fast: "glm",
       strong: "gpt",
-      coder: "glm",
-      resolver: "gpt",
-      reviewer: "gpt",
-      "deep-reviewer": "gpt",
-      explorer: "fast",
+      mini: "glm",
+      codex: "gpt",
+      explorer: "bronze",
+      coder: "silver",
+      resolver: "gold",
+      reviewer: "gold",
+      "deep-reviewer": "gold",
+      planner: "gold",
     }
   }
 
+  if (!currentModel) {
+    if (glmModel) return buildGLMOnlyPreset(glmModel)
+    if (gptModel) return buildGPTOnlyPreset(gptModel)
+    return {}
+  }
+
+  const lower = currentModel.toLowerCase()
+
+  // GLM / ZAI — GLM-only preset (no GPT dependency, avoids token-exhaustion errors)
+  if (lower.includes("glm") || lower.includes("zai")) {
+    return buildGLMOnlyPreset(currentModel)
+  }
+
   // OpenAI / GPT single-provider preset
   if (lower.includes("openai/") || lower.includes("gpt")) {
-    return {
-      gpt: currentModel,
-      fast: "gpt",
-      strong: "gpt",
-      mini: "gpt",
-      codex: "gpt",
-      coder: "gpt",
-      resolver: "gpt",
-      explorer: "gpt",
-      reviewer: "gpt",
-      "deep-reviewer": "gpt",
-    }
+    return buildGPTOnlyPreset(currentModel)
   }
 
   // Unknown provider — keep model-neutral
   return {}
 }
 
+function buildGLMOnlyPreset(model) {
+  return {
+    glm: model,
+    fast: "glm",
+    strong: "glm",
+    coder: "glm",
+    resolver: "glm",
+    reviewer: "glm",
+    "deep-reviewer": "glm",
+    explorer: "fast",
+    planner: "glm",
+  }
+}
+
+function buildGPTOnlyPreset(model) {
+  return {
+    gpt: model,
+    fast: "gpt",
+    strong: "gpt",
+    mini: "gpt",
+    codex: "gpt",
+    coder: "gpt",
+    resolver: "gpt",
+    explorer: "gpt",
+    reviewer: "gpt",
+    "deep-reviewer": "gpt",
+  }
+}
+
 function getPresetLabel(currentModel) {
   if (!currentModel) return "inherited"
   const lower = currentModel.toLowerCase()
-  if (lower.includes("glm") || lower.includes("zai")) return "glm+gpt"
+  if (lower.includes("glm") || lower.includes("zai")) return "glm-only"
   if (lower.includes("openai/") || lower.includes("gpt")) return "gpt-only"
   return "inherited"
 }
 
+function isGLMModel(currentModel) {
+  if (!currentModel) return false
+  const lower = currentModel.toLowerCase()
+  return lower.includes("glm") || lower.includes("zai")
+}
+
+function isGPTModel(currentModel) {
+  if (!currentModel) return false
+  const lower = currentModel.toLowerCase()
+  return lower.includes("openai/") || lower.includes("gpt")
+}
+
+function detectAllModels(config) {
+  const models = new Set()
+
+  // Top-level model
+  if (typeof config.model === "string" && config.model.length > 0) {
+    models.add(config.model)
+  }
+
+  // Top-level models object values
+  if (isObject(config.models)) {
+    for (const value of Object.values(config.models)) {
+      if (typeof value === "string" && value.length > 0) {
+        models.add(value)
+      }
+    }
+  }
+
+  // Provider model lists
+  if (isObject(config.provider)) {
+    for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+      if (isObject(providerConfig) && isObject(providerConfig.models)) {
+        for (const [modelKey, modelEntry] of Object.entries(providerConfig.models)) {
+          if (typeof modelKey === "string" && modelKey.length > 0) {
+            models.add(qualifyModelId(providerId, modelKey))
+          }
+          if (typeof modelEntry === "string") {
+            models.add(qualifyModelId(providerId, modelEntry))
+          } else if (isObject(modelEntry) && typeof modelEntry.id === "string") {
+            models.add(qualifyModelId(providerId, modelEntry.id))
+          }
+        }
+      }
+    }
+  }
+
+  // Agent model values
+  if (isObject(config.agent)) {
+    for (const agentConfig of Object.values(config.agent)) {
+      if (isObject(agentConfig) && typeof agentConfig.model === "string" && agentConfig.model.length > 0) {
+        models.add(agentConfig.model)
+      }
+    }
+  }
+
+  return [...models]
+}
+
+function qualifyModelId(providerId, modelId) {
+  if (typeof modelId !== "string" || modelId.length === 0) return modelId
+  if (modelId.includes("/")) return modelId
+  return `${providerId}/${modelId}`
+}
+
 async function migrateResolveConfig() {
   let raw
   try {
@@ -225,6 +379,28 @@ function addPlugin(config) {
   return true
 }
 
+async function injectZAIMCPs(config) {
+  config.mcp ??= {}
+  if (!isObject(config.mcp)) return false
+
+  const added = []
+  for (const [name, mcpConfig] of Object.entries(ZAI_MCP_SERVERS)) {
+    if (config.mcp[name] === undefined) {
+      config.mcp[name] = mcpConfig
+      added.push(name)
+    }
+  }
+
+  if (added.length > 0) {
+    console.log(`[${packageName}] injected ZAI MCP server config: ${added.join(", ")}`)
+    console.log(`[${packageName}] note: API keys are not copied into opencode.json; export Z_AI_API_KEY if the MCP server requires it.`)
+    return true
+  }
+
+  console.log(`[${packageName}] ZAI MCP server already present — skipping`)
+  return false
+}
+
 function isRegisteredPluginEntry(entry) {
   if (typeof entry === "string") return isResolvePluginName(entry)
   if (Array.isArray(entry) && typeof entry[0] === "string") return isResolvePluginName(entry[0])
@@ -261,3 +437,107 @@ function isObject(value) {
 function formatError(error) {
   return error instanceof Error ? error.message : String(error)
 }
+
+async function offerCompanionPlugins() {
+  if (process.env.OPENCODE_RESOLVE_SKIP_COMPANIONS === "1") return
+
+  const config = await readOpenCodeConfig()
+  const existing = collectPluginBaseNames(config.plugin ?? [])
+  const missing = COMPANION_PLUGINS.filter((c) => !existing.has(c.pkg))
+
+  if (missing.length === 0) {
+    console.log(`[${packageName}] recommended companion plugins already present — skipping`)
+    return
+  }
+
+  const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+
+  if (!isInteractive) {
+    console.log(`[${packageName}] recommended companion plugins not detected:`)
+    for (const c of missing) {
+      console.log(`  - ${c.pkg} — ${c.desc}`)
+      console.log(`    install: opencode plugin ${c.pkg}@latest --global --force`)
+    }
+    return
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    for (const c of missing) {
+      console.log("")
+      console.log(`[${packageName}] recommended companion: ${c.pkg}`)
+      console.log(`             ${c.desc}`)
+      const raw = await rl.question("             install now? [Y/n] ")
+      const answer = raw.trim().toLowerCase()
+      const accepted = answer === "" || answer === "y" || answer === "yes"
+      if (!accepted) {
+        console.log(`             skipped — install later via:  opencode plugin ${c.pkg}@latest --global --force`)
+        continue
+      }
+      const installed = await installCompanion(c.pkg)
+      if (!installed) {
+        console.warn(`             ${c.pkg} install command failed — leave plugin list untouched, retry manually`)
+        continue
+      }
+      await addCompanionToOpenCodeConfig(`${c.pkg}@latest`)
+      console.log(`             ${c.pkg} cached and registered — restart OpenCode to activate`)
+    }
+  } finally {
+    rl.close()
+  }
+}
+
+function collectPluginBaseNames(plugins) {
+  const names = new Set()
+  for (const entry of plugins) {
+    const raw = typeof entry === "string"
+      ? entry
+      : Array.isArray(entry) && typeof entry[0] === "string"
+        ? entry[0]
+        : null
+    if (!raw) continue
+    names.add(stripVersionSuffix(raw))
+  }
+  return names
+}
+
+function stripVersionSuffix(name) {
+  if (name.startsWith("@")) {
+    const slashIndex = name.indexOf("/")
+    if (slashIndex === -1) return name
+    const scope = name.slice(0, slashIndex)
+    const rest = name.slice(slashIndex + 1)
+    return `${scope}/${rest.split("@")[0]}`
+  }
+  return name.split("@")[0]
+}
+
+async function installCompanion(pkg) {
+  return new Promise((resolveSpawn) => {
+    const child = spawn("opencode", ["plugin", `${pkg}@latest`, "--global", "--force"], {
+      stdio: "inherit",
+    })
+    child.on("exit", (code) => resolveSpawn(code === 0))
+    child.on("error", () => resolveSpawn(false))
+  })
+}
+
+async function addCompanionToOpenCodeConfig(pluginEntry) {
+  const config = await readOpenCodeConfig()
+  config.plugin ??= []
+  if (!Array.isArray(config.plugin)) {
+    throw new Error(`${opencodeConfigPath}.plugin must be an array`)
+  }
+  const baseName = stripVersionSuffix(pluginEntry)
+  const alreadyPresent = config.plugin.some((entry) => {
+    const raw = typeof entry === "string"
+      ? entry
+      : Array.isArray(entry) && typeof entry[0] === "string"
+        ? entry[0]
+        : null
+    return raw !== null && stripVersionSuffix(raw) === baseName
+  })
+  if (alreadyPresent) return
+  config.plugin.push(pluginEntry)
+  await writeFile(opencodeConfigPath, `${JSON.stringify(config, null, 2)}\n`)
+}