@hiai-gg/hiai-opencode 0.1.5 → 0.1.6

package/src/index.ts

@@ -18,22 +18,15 @@ import { injectServerAuthIntoClient, log } from "./shared"
 import { hydratePluginConfigWithPlatformDefaults } from "./shared/runtime-plugin-config"
 import { detectExternalSkillPlugin, getSkillPluginConflictWarning } from "./shared/external-plugin-detector"
 import { PLUGIN_NAME } from "./shared/plugin-identity"
+import { autoExportStaticMcpJson } from "./shared/mcp-static-export"
 import { warnIfListPluginEntry, warnMissingRequiredMcpEnv } from "./shared/startup-diagnostics"
 import { startBackgroundCheck as startTmuxCheck } from "./tools/interactive-bash"
 import { lspManager } from "./tools/lsp/client"
 
-import { loadConfig, resolveEnvVars } from "./config/loader"
+import { loadConfig } from "./config/loader"
 import type { HiaiOpencodeConfig } from "./config/types"
 
 import { createPlugin as createSubtask2Plugin } from "./internals/plugins/subtask2/core/plugin"
-import WebsearchCitedPlugin, { 
-  GOOGLE_PROVIDER_ID,
-  OPENAI_PROVIDER_ID,
-  OPENROUTER_PROVIDER_ID,
-  WebsearchCitedGooglePlugin, 
-  WebsearchCitedOpenAIPlugin 
-} from "./internals/plugins/websearch-cited/index"
-import type { WebsearchCitedFallback } from "./internals/plugins/websearch-cited/index"
 import { createBuiltinSkills } from "./features/builtin-skills"
 import {
   materializeBuiltinSkills,
@@ -42,39 +35,6 @@ import {
 
 let activePluginDispose: PluginDispose | null = null
 
-function createWebsearchFallback(config: HiaiOpencodeConfig): WebsearchCitedFallback | undefined {
-  const model = config.agents?.researcher?.model?.trim()
-  if (!model) {
-    return undefined
-  }
-
-  if (model.startsWith("openrouter/")) {
-    return {
-      providerID: OPENROUTER_PROVIDER_ID,
-      model: model.slice("openrouter/".length),
-    }
-  }
-
-  if (model.startsWith("openai/")) {
-    return {
-      providerID: OPENAI_PROVIDER_ID,
-      model: model.slice("openai/".length),
-    }
-  }
-
-  if (model.startsWith("google/")) {
-    return {
-      providerID: GOOGLE_PROVIDER_ID,
-      model: model.slice("google/".length),
-    }
-  }
-
-  return {
-    providerID: OPENROUTER_PROVIDER_ID,
-    model,
-  }
-}
-
 function configureBundledBunPtyLibrary(): void {
   if (process.env.BUN_PTY_LIB?.trim()) {
     return
@@ -126,6 +86,7 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     pluginConfig,
     platformConfig: internalConfig,
   })
+  autoExportStaticMcpJson(ctx.directory, internalConfig)
 
   materializeBuiltinSkills(
     createBuiltinSkills({
@@ -207,10 +168,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
   } catch (err) {
     console.error("[hiai-opencode] PTYPlugin failed to load:", err);
   }
-  const websearchResult = await WebsearchCitedPlugin(ctx, createWebsearchFallback(internalConfig))
-  const websearchGoogleResult = await WebsearchCitedGooglePlugin(ctx)
-  const websearchOpenAIResult = await WebsearchCitedOpenAIPlugin(ctx)
-
   const combinedResult = {
     name: PLUGIN_NAME,
     ...pluginInterface,
@@ -219,7 +176,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     tool: {
       ...pluginInterface.tool,
       ...ptyResult.tool,
-      ...websearchResult.tool,
     },
 
     // Chain hooks: command.execute.before
@@ -250,7 +206,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
     config: async (input: any) => {
       await pluginInterface.config?.(input);
       await (subtask2Result as any).config?.(input);
-      await (websearchResult as any).config?.(input);
     },
 
     // Merge Events
@@ -260,33 +215,6 @@ const HiaiOpenCodePlugin: Plugin = async (ctx) => {
       await (ptyResult as any).event?.(input);
     },
 
-    // Auth (Consolidated)
-    auth: {
-      provider: "hiai-opencode",
-      methods: [
-        { type: "api" as const, label: "Google Search API key" },
-      ],
-      loader: async (getAuth: any) => {
-        const authData = await getAuth();
-        const { registerGetAuth, GOOGLE_PROVIDER_ID, OPENAI_PROVIDER_ID, OPENROUTER_PROVIDER_ID } = await import("./internals/plugins/websearch-cited/index");
-
-        const getConfiguredKey = (configKey?: string) => {
-          if (configKey) return resolveEnvVars(configKey);
-          return undefined;
-        };
-
-        const googleKey = authData["Google Search API key"] || getConfiguredKey(internalConfig.auth?.googleSearch);
-        const openaiKey = getConfiguredKey(internalConfig.auth?.openai);
-        const openRouterKey = getConfiguredKey(internalConfig.auth?.openrouter);
-
-        if (googleKey) registerGetAuth(GOOGLE_PROVIDER_ID, () => Promise.resolve({ type: "api", key: googleKey }));
-        if (openaiKey) registerGetAuth(OPENAI_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openaiKey }));
-        if (openRouterKey) registerGetAuth(OPENROUTER_PROVIDER_ID, () => Promise.resolve({ type: "api", key: openRouterKey }));
-
-        return {};
-      },
-    },
-
     "experimental.session.compacting": async (
       _input: { sessionID: string },
       output: { context: string[] },

package/src/shared/mcp-static-export.ts

@@ -0,0 +1,121 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+import type { HiaiOpencodeConfig, McpServerConfig } from "../config/types"
+import { resolveEnvVars } from "../config/loader"
+import { log } from "./logger"
+
+type StaticMcpServer = {
+  type?: "http" | "stdio"
+  url?: string
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+}
+
+export const MCP_EXPORT_MARKER = "hiai-opencode"
+
+type StaticMcpJsonPayload = {
+  mcpServers: Record<string, StaticMcpServer>
+  _meta?: {
+    generatedBy: typeof MCP_EXPORT_MARKER
+    version: 1
+    generatedAt: string
+  }
+}
+
+function toStaticMcpServer(config: McpServerConfig): StaticMcpServer | null {
+  if (config.enabled === false) return null
+
+  if (config.type === "remote") {
+    const headers = config.headers
+      ? Object.fromEntries(Object.entries(config.headers).map(([key, value]) => [key, resolveEnvVars(value)]))
+      : undefined
+
+    return {
+      type: "http",
+      url: config.url,
+      ...(headers ? { headers } : {}),
+    }
+  }
+
+  const [command, ...args] = config.command ?? []
+  if (!command) return null
+
+  const env = config.environment
+    ? Object.fromEntries(Object.entries(config.environment).map(([key, value]) => [key, resolveEnvVars(value)]))
+    : undefined
+
+  return {
+    command,
+    ...(args.length > 0 ? { args } : {}),
+    ...(env ? { env } : {}),
+  }
+}
+
+export function buildStaticMcpJson(config: HiaiOpencodeConfig): StaticMcpJsonPayload {
+  const mcpServers: Record<string, StaticMcpServer> = {}
+
+  for (const [name, serverConfig] of Object.entries(config.mcp ?? {})) {
+    const converted = toStaticMcpServer(serverConfig)
+    if (converted) {
+      mcpServers[name] = converted
+    }
+  }
+
+  return {
+    _meta: {
+      generatedBy: MCP_EXPORT_MARKER,
+      version: 1,
+      generatedAt: new Date().toISOString(),
+    },
+    mcpServers,
+  }
+}
+
+export function isManagedStaticMcpFile(path: string): boolean {
+  if (!existsSync(path)) return false
+
+  try {
+    const raw = readFileSync(path, "utf-8")
+    const parsed = JSON.parse(raw) as StaticMcpJsonPayload
+    return parsed?._meta?.generatedBy === MCP_EXPORT_MARKER
+  } catch {
+    return false
+  }
+}
+
+export function autoExportStaticMcpJson(directory: string, config: HiaiOpencodeConfig): void {
+  const mode = process.env.HIAI_OPENCODE_AUTO_EXPORT_MCP?.trim().toLowerCase() || "if-missing"
+  if (mode === "0" || mode === "false" || mode === "no" || mode === "off") {
+    return
+  }
+
+  const outputPath = process.env.HIAI_OPENCODE_MCP_EXPORT_PATH?.trim() || join(directory, ".mcp.json")
+  if (mode === "if-missing" && existsSync(outputPath)) {
+    return
+  }
+
+  const isForceMode = mode === "force"
+  if (mode === "always" && existsSync(outputPath) && !isManagedStaticMcpFile(outputPath) && !isForceMode) {
+    console.warn(
+      `[hiai-opencode] WARNING: refusing to overwrite non-managed static MCP config at ${outputPath}. `
+      + "Set HIAI_OPENCODE_AUTO_EXPORT_MCP=force to override.",
+    )
+    return
+  }
+
+  try {
+    mkdirSync(dirname(outputPath), { recursive: true })
+    const payload = buildStaticMcpJson(config)
+    writeFileSync(outputPath, `${JSON.stringify(payload, null, 2)}\n`)
+    log("[hiai-opencode] exported static MCP config", {
+      outputPath,
+      servers: Object.keys(payload.mcpServers),
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(`[hiai-opencode] WARNING: failed to export static MCP config to ${outputPath}: ${message}`)
+  }
+}

package/src/tools/ast-grep/constants.ts

@@ -1,5 +1,5 @@
 export type { EnvironmentCheckResult } from "./environment-check"
 export { checkEnvironment, formatEnvironmentCheck } from "./environment-check"
-export { CLI_LANGUAGES, NAPI_LANGUAGES, LANG_EXTENSIONS } from "./language-support"
+export { CLI_LANGUAGES, LANG_EXTENSIONS } from "./language-support"
 export { DEFAULT_TIMEOUT_MS, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_MAX_MATCHES } from "./language-support"
 export { findSgCliPathSync, getSgCliPath, setSgCliPath } from "./sg-cli-path"

package/src/tools/ast-grep/environment-check.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "fs"
 
-import { CLI_LANGUAGES, NAPI_LANGUAGES } from "./language-support"
+import { CLI_LANGUAGES } from "./language-support"
 import { getSgCliPath } from "./sg-cli-path"
 
 export interface EnvironmentCheckResult {
@@ -9,14 +9,10 @@ export interface EnvironmentCheckResult {
 		path: string
 		error?: string
 	}
-	napi: {
-		available: boolean
-		error?: string
-	}
 }
 
 /**
- * Check if ast-grep CLI and NAPI are available.
+ * Check if ast-grep CLI is available.
  * Call this at startup to provide early feedback about missing dependencies.
  */
 export function checkEnvironment(): EnvironmentCheckResult {
@@ -26,9 +22,6 @@ export function checkEnvironment(): EnvironmentCheckResult {
 			available: false,
 			path: cliPath ?? "not found",
 		},
-		napi: {
-			available: false,
-		},
 	}
 
 	if (cliPath && existsSync(cliPath)) {
@@ -39,17 +32,6 @@ export function checkEnvironment(): EnvironmentCheckResult {
 		result.cli.error = `Binary not found: ${cliPath}`
 	}
 
-	// Check NAPI availability
-	try {
-		require("@ast-grep/napi")
-		result.napi.available = true
-	} catch (error) {
-		result.napi.available = false
-		result.napi.error = `@ast-grep/napi not installed: ${
-			error instanceof Error ? error.message : String(error)
-		}`
-	}
-
 	return result
 }
 
@@ -70,20 +52,8 @@ export function formatEnvironmentCheck(result: EnvironmentCheckResult): string {
 		lines.push("  Install: bun add -D @ast-grep/cli")
 	}
 
-	// NAPI status
-	if (result.napi.available) {
-		lines.push("[OK] NAPI: Available")
-	} else {
-		lines.push("[X] NAPI: Not available")
-		if (result.napi.error) {
-			lines.push(`  Error: ${result.napi.error}`)
-		}
-		lines.push("  Install: bun add -D @ast-grep/napi")
-	}
-
 	lines.push("")
 	lines.push(`CLI supports ${CLI_LANGUAGES.length} languages`)
-	lines.push(`NAPI supports ${NAPI_LANGUAGES.length} languages: ${NAPI_LANGUAGES.join(", ")}`)
 
 	return lines.join("\n")
 }

package/src/tools/ast-grep/language-support.ts

@@ -27,9 +27,6 @@ export const CLI_LANGUAGES = [
 	"yaml",
 ] as const
 
-// NAPI supported languages (5 total - native bindings)
-export const NAPI_LANGUAGES = ["html", "javascript", "tsx", "css", "typescript"] as const
-
 export const DEFAULT_TIMEOUT_MS = 300_000
 export const DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024
 export const DEFAULT_MAX_MATCHES = 500

package/src/tools/ast-grep/types.ts

@@ -1,7 +1,6 @@
-import type { CLI_LANGUAGES, NAPI_LANGUAGES } from "./constants"
+import type { CLI_LANGUAGES } from "./constants"
 
 export type CliLanguage = (typeof CLI_LANGUAGES)[number]
-export type NapiLanguage = (typeof NAPI_LANGUAGES)[number]
 
 export interface Position {
   line: number

package/src/tools/skill-mcp/tools.test.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test"
+import type { ToolContext } from "@opencode-ai/plugin/tool"
+
+import { createSkillMcpTool } from "./tools"
+
+test("skill_mcp falls back to enabled builtin MCP when skill MCP is absent", async () => {
+  let callCaptured: { serverName: string; toolName: string } | null = null
+
+  const toolDef = createSkillMcpTool({
+    manager: {
+      async callTool(info, _context, toolName) {
+        callCaptured = { serverName: info.serverName, toolName }
+        return { ok: true }
+      },
+      async readResource() {
+        return { ok: true }
+      },
+      async getPrompt() {
+        return { ok: true }
+      },
+    } as any,
+    getLoadedSkills: () => [],
+    getSessionID: () => "session-test",
+    builtinMcp: {
+      firecrawl: {
+        enabled: true,
+        type: "local",
+        command: ["node", "firecrawl.mjs"],
+      },
+    },
+  })
+
+  const result = await toolDef.execute(
+    {
+      mcp_name: "firecrawl",
+      tool_name: "firecrawl_search",
+      arguments: { query: "test" },
+    } as any,
+    { sessionID: "session-test" } as ToolContext,
+  )
+
+  expect(callCaptured).toEqual({ serverName: "firecrawl", toolName: "firecrawl_search" })
+  expect(result).toContain("\"ok\": true")
+})

package/dist/config/loader.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/config/models.d.ts

@@ -1,13 +0,0 @@
-export declare const MODEL_ROLE_GUIDE: readonly ["fast: cheap/default for bounded helpers, researcher-style scans, platform chores", "mid: balanced default for steady execution/review work", "high: stronger general-purpose model for primary implementation and planning", "ultrahigh: highest-cost/high-accuracy slot for hard architecture or critical decisions", "vision: preferred for UI/media/multimodal interpretation and visual work", "reasoning: preferred for deeper multi-step reasoning when latency/cost are acceptable"];
-export declare const PROVIDER_MODEL_RULES: readonly ["openai: use `openai/<model>` for direct OpenAI calls, e.g. `openai/gpt-5` or `openai/o1`", "anthropic: use `anthropic/<model>`, e.g. `anthropic/claude-3.5-sonnet`", "deepseek: use `deepseek/<model>` when connected directly", "glm: use `z-ai/<model>` or the provider id exposed by your gateway/client", "minimax: use `minimax/<model>`", "qwen: use `qwen/<model>`", "ollama: use the native local model id in Ollama config, e.g. `qwen3.5:4b`", "openrouter: use `openrouter/<vendor>/<model>`, e.g. `openrouter/anthropic/claude-3.5-sonnet`", "rule: store fully qualified model ids in config; avoid local aliases like `fast`, `sonnet`, or provider-less ids"];
-export declare const MODEL_PRESETS: {
-    readonly fast: "openrouter/google/gemini-2.0-flash";
-    readonly mid: "openrouter/anthropic/claude-3.5-sonnet";
-    readonly high: "openrouter/anthropic/claude-3.5-opus";
-    readonly ultrahigh: "openrouter/openai/gpt-4o";
-    readonly vision: "openrouter/google/gemini-2.0-pro-exp-02-05";
-    readonly reasoning: "openrouter/openai/o1";
-    readonly strategist: "openrouter/z-ai/glm-5.1";
-    readonly critic: "openrouter/qwen/qwen2.5-72b-instruct";
-    readonly writing: "openrouter/kimi/kimi-latest";
-};

package/dist/internals/plugins/websearch-cited/google.d.ts

@@ -1,38 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-type GeminiChunkWeb = {
-    title?: string;
-    uri?: string;
-};
-type GeminiChunk = {
-    web?: GeminiChunkWeb;
-};
-type GeminiSupportSegment = {
-    startIndex?: number;
-    endIndex?: number;
-};
-type GeminiSupport = {
-    segment?: GeminiSupportSegment;
-    groundingChunkIndices?: number[];
-};
-type GeminiMetadata = {
-    groundingChunks?: GeminiChunk[];
-    groundingSupports?: GeminiSupport[];
-};
-type GeminiTextPart = {
-    text?: string;
-    thought?: unknown;
-};
-type GeminiContent = {
-    role?: string;
-    parts?: GeminiTextPart[];
-};
-type GeminiCandidate = {
-    content?: GeminiContent;
-    groundingMetadata?: GeminiMetadata;
-};
-type GeminiGenerateContentResponse = {
-    candidates?: GeminiCandidate[];
-};
-export declare function formatWebSearchResponse(response: GeminiGenerateContentResponse, query: string): string;
-export declare function createGoogleWebsearchClient(model: string): WebsearchClient;
-export {};

package/dist/internals/plugins/websearch-cited/index.d.ts

@@ -1,17 +0,0 @@
-import { type Plugin } from "@opencode-ai/plugin";
-import type { GetAuth } from "./types";
-export declare const GOOGLE_PROVIDER_ID = "google";
-export declare const OPENAI_PROVIDER_ID = "openai";
-export declare const OPENROUTER_PROVIDER_ID = "openrouter";
-type SelectedProviderID = typeof GOOGLE_PROVIDER_ID | typeof OPENAI_PROVIDER_ID | typeof OPENROUTER_PROVIDER_ID;
-export declare function registerGetAuth(providerID: string, getAuth: GetAuth): void;
-export declare function resolveGetAuth(providerID: string): GetAuth | undefined;
-type SelectedWebsearchConfig = {
-    providerID: SelectedProviderID;
-    model: string;
-};
-export type WebsearchCitedFallback = SelectedWebsearchConfig;
-declare const WebsearchCitedPlugin: (_ctx?: unknown, fallback?: WebsearchCitedFallback) => Promise<any>;
-export declare const WebsearchCitedGooglePlugin: Plugin;
-export declare const WebsearchCitedOpenAIPlugin: Plugin;
-export default WebsearchCitedPlugin;

package/dist/internals/plugins/websearch-cited/openai.d.ts

@@ -1,9 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-export type OpenAIWebsearchConfig = {
-    reasoningEffort?: string;
-    reasoningSummary?: string;
-    textVerbosity?: string;
-    store?: boolean;
-    include?: string[];
-};
-export declare function createOpenAIWebsearchClient(model: string, config: OpenAIWebsearchConfig): WebsearchClient;

package/dist/internals/plugins/websearch-cited/openrouter.d.ts

@@ -1,2 +0,0 @@
-import type { WebsearchClient } from "./types.ts";
-export declare function createOpenRouterWebsearchClient(model: string): WebsearchClient;

package/dist/internals/plugins/websearch-cited/types.d.ts

@@ -1,5 +0,0 @@
-import type { Auth as ProviderAuth } from "@opencode-ai/sdk";
-export type GetAuth = () => Promise<ProviderAuth | undefined>;
-export interface WebsearchClient {
-    search(query: string, abortSignal: AbortSignal, getAuth: GetAuth): Promise<string>;
-}