opencode-muse-code 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shane Walker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# opencode-muse-code
+
+Use your Muse Code (Meta) subscription in OpenCode.
+
+The plugin reads the login the [`muse`](https://api.meta.ai/muse-launcher.sh) CLI
+already stored on your machine, registers a `muse-code` provider that talks to
+`https://api.meta.ai/v1`, and lists the Muse Spark models with their real limits
+and reasoning-effort variants. Model requests are billed against your Muse Code
+subscription by Meta.
+
+## Requirements
+
+- OpenCode V2
+- The `muse` CLI installed and signed in (`muse`). The plugin reads the login it
+  saved in the macOS keychain (or `~/.config/muse/auth.json` on other systems).
+
+## Install
+
+Add the package to the `plugins` list in `opencode.jsonc`:
+
+```jsonc
+{
+  "plugins": ["opencode-muse-code"]
+}
+```
+
+Or copy this folder to `~/.config/opencode/plugins/muse-code/`; plugin
+directories there are loaded automatically.
+
+Or clone the repository and point OpenCode at the checkout:
+
+```sh
+git clone https://github.com/swalker326/opencode-muse-code.git
+```
+
+```jsonc
+{
+  "plugins": ["/absolute/path/to/opencode-muse-code"]
+}
+```
+
+Restart the OpenCode service (`opencode service restart`) or reopen OpenCode.
+
+## Use
+
+Select a model like `muse-code/muse-spark-1.3` with `/models`, or run:
+
+```sh
+opencode run --model muse-code/muse-spark-1.3 "hello"
+```
+
+Variant suffixes pick a reasoning effort, for example
+`muse-code/muse-spark-1.3#max` (`minimal`, `low`, `medium`, `high`, `xhigh`,
+`max`). The default comes from the model metadata.
+
+## How it works
+
+1. **Find the login.** Credentials are resolved in order: the plugin `key`
+   option, then `META_API_KEY` / `MUSE_API_KEY`, then the macOS keychain item
+   `ai.meta.dev.credentials` (account `meta`), then `~/.config/muse/auth.json`.
+2. **Get an API key.** It uses the stored API key, or mints one from the OAuth
+   token by calling `POST https://api.meta.ai/muse-code/key`. Minting is
+   idempotent: the same account always gets the same key back.
+3. **Discover models.** It reads Meta's catalog from
+   `GET https://api.meta.ai/muse-code/models`, keeping tool-capable text models
+   and their real limits, input types, and reasoning-effort variants.
+4. **Register the provider.** OpenCode receives a provider definition with ID
+   `muse-code`, display name "Muse Code Sub Plugin", the OpenAI-compatible
+   runtime, endpoint `https://api.meta.ai/v1`, the minted key, and one model
+   entry per Muse Spark model. Variants map to the `reasoning_effort` request
+   field.
+5. **Stay fresh.** Every 30 minutes it re-reads the login, re-fetches the
+   catalog, and reloads the provider. On unload it stops the timer and removes
+   its registration.
+
+Requests go from OpenCode to `https://api.meta.ai/v1` with the minted key; Meta
+meters them against your Muse Code subscription.
+
+## Options
+
+Pass a key directly instead of reading the login:
+
+```jsonc
+{
+  "plugins": [{ "package": "opencode-muse-code", "options": { "key": "..." } }]
+}
+```
+
+The `META_API_KEY` and `MUSE_API_KEY` environment variables are also honored.
+
+## Troubleshooting
+
+- **Unauthorized**: run `muse` and sign in again, then restart the service. If
+  you also stored an API key for this provider in OpenCode, update or remove
+  that stored account so it cannot shadow the keychain login.
+- **No models listed**: the first refresh failed and the fallback catalog was
+  used; check the network and restart the service.
+- **Linux**: Muse CLI credential storage differs by platform. If the keychain
+  is not readable, set `META_API_KEY` or the plugin `key` option.

package/index.ts

@@ -0,0 +1,247 @@
+import { execFile } from "node:child_process"
+import { readFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+import { Model, Plugin, Provider } from "@opencode-ai/plugin"
+
+const PROVIDER_ID = "muse-code"
+const PROVIDER_NAME = "Muse Code Sub Plugin"
+const PROVIDER_PACKAGE = "@opencode/ai/providers/openai-compatible"
+const API_ORIGIN = "https://api.meta.ai"
+const API_BASE = `${API_ORIGIN}/v1`
+const KEYCHAIN_SERVICE = "ai.meta.dev.credentials"
+const KEYCHAIN_ACCOUNT = "meta"
+const REFRESH_MS = 30 * 60 * 1_000
+const REQUEST_TIMEOUT_MS = 10_000
+
+type Credential = { api_key?: string; access_token?: string }
+
+type MuseVariant = { reasoningEffort?: string }
+
+type MuseModel = {
+  readonly id: string
+  readonly created?: number
+  readonly metadata?: {
+    readonly "muse-code"?: {
+      readonly name?: string
+      readonly is_hidden?: boolean
+      readonly tool_call?: boolean
+      readonly modalities?: { readonly input?: readonly string[]; readonly output?: readonly string[] }
+      readonly limit?: { readonly context?: number; readonly output?: number }
+      readonly options?: { readonly reasoningEffort?: string }
+      readonly variants?: Readonly<Record<string, MuseVariant>>
+    }
+  }
+}
+
+// The plugin host context is newer than the installed @opencode-ai/plugin
+// types, so the provider domain is described locally.
+type ProviderEditor = {
+  get(providerID: string): unknown
+  add(input: { info: Provider.Info; models: readonly Model.Info[] }): void
+  update(providerID: string, update: (provider: Record<string, unknown>) => void): void
+  models: { set(providerID: string, models: readonly Model.Info[]): void }
+}
+
+type ProviderDomain = {
+  transform(callback: (editor: ProviderEditor) => void): Promise<{ dispose: () => Promise<void> }>
+  reload(): Promise<void>
+}
+
+const FALLBACK_CATALOG: readonly MuseModel[] = [
+  {
+    id: "muse-spark-1.3",
+    metadata: {
+      "muse-code": {
+        name: "Muse Spark 1.3",
+        tool_call: true,
+        modalities: { input: ["text", "image"], output: ["text"] },
+        limit: { context: 1_007_997, output: 128_000 },
+        options: { reasoningEffort: "high" },
+        variants: {
+          minimal: { reasoningEffort: "minimal" },
+          low: { reasoningEffort: "low" },
+          medium: { reasoningEffort: "medium" },
+          high: { reasoningEffort: "high" },
+          xhigh: { reasoningEffort: "xhigh" },
+          max: { reasoningEffort: "max" },
+        },
+      },
+    },
+  },
+]
+
+function run(command: string, args: readonly string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(command, [...args], { encoding: "utf8", timeout: REQUEST_TIMEOUT_MS }, (error, stdout) => {
+      if (error) reject(error)
+      else resolve(stdout)
+    })
+  })
+}
+
+function parseJson<T>(value: string | undefined): T | undefined {
+  if (!value) return undefined
+  try {
+    return JSON.parse(value) as T
+  } catch {
+    return undefined
+  }
+}
+
+// The muse CLI keeps its login in the operating system credential store. On
+// macOS that is the login keychain; on other platforms fall back to the files
+// the CLI may write, and to the environment variables it understands.
+async function readCredential(override: string | undefined): Promise<Credential | undefined> {
+  if (override) return { api_key: override }
+
+  const fromEnv = process.env.META_API_KEY ?? process.env.MUSE_API_KEY
+  if (fromEnv) return { api_key: fromEnv }
+
+  if (process.platform === "darwin") {
+    const raw = await run("security", [
+      "find-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      KEYCHAIN_ACCOUNT,
+      "-w",
+    ]).catch(() => undefined)
+    const parsed = parseJson<Credential>(raw)
+    if (parsed?.api_key || parsed?.access_token) return parsed
+  }
+
+  for (const file of ["auth.json", "secrets.json"]) {
+    const filePath = path.join(os.homedir(), ".config", "muse", file)
+    const parsed = parseJson<Credential>(await readFile(filePath, "utf8").catch(() => undefined))
+    if (parsed?.api_key || parsed?.access_token) return parsed
+  }
+
+  return undefined
+}
+
+// Exchanges the OAuth login for the long-lived API key. Minting is idempotent:
+// the same account always gets the same key back.
+async function mintApiKey(accessToken: string): Promise<string | undefined> {
+  const response = await fetch(`${API_ORIGIN}/muse-code/key`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${accessToken}`,
+      "content-type": "application/json",
+    },
+    body: "{}",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  }).catch(() => undefined)
+  if (!response?.ok) return undefined
+  const body = (await response.json().catch(() => undefined)) as { api_key?: string } | undefined
+  return body?.api_key
+}
+
+async function fetchCatalog(apiKey: string): Promise<readonly MuseModel[] | undefined> {
+  const response = await fetch(`${API_ORIGIN}/muse-code/models`, {
+    headers: { authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  }).catch(() => undefined)
+  if (!response?.ok) return undefined
+  const body = (await response.json().catch(() => undefined)) as { data?: readonly MuseModel[] } | undefined
+  return body?.data
+}
+
+function toModelInfo(providerID: Provider.ID, model: MuseModel): Model.Info {
+  const meta = model.metadata?.["muse-code"] ?? {}
+  const defaultEffort = meta.options?.reasoningEffort
+  return {
+    ...Model.Info.default(providerID, Model.ID.make(model.id)),
+    name: meta.name ?? model.id,
+    capabilities: {
+      tools: meta.tool_call !== false,
+      input: [...(meta.modalities?.input ?? ["text"])],
+      output: ["text"],
+    },
+    limit: {
+      context: meta.limit?.context ?? 200_000,
+      output: meta.limit?.output ?? 32_000,
+    },
+    time: { released: (model.created ?? 0) * 1_000 },
+    variants: Object.entries(meta.variants ?? {}).map(([id, variant]) => ({
+      id: Model.VariantID.make(id),
+      body: { reasoning_effort: variant.reasoningEffort ?? id },
+    })),
+    ...(defaultEffort ? { body: { reasoning_effort: defaultEffort } } : {}),
+  }
+}
+
+export default Plugin.define({
+  id: "muse-code",
+  async setup(ctx) {
+    const provider = (ctx as unknown as { provider: ProviderDomain }).provider
+    const providerID = Provider.ID.make(PROVIDER_ID)
+    const optionKey = typeof ctx.options?.key === "string" ? ctx.options.key : undefined
+
+    // Mutable state the synchronous transform reads. It is refreshed before
+    // every provider reload, so reads during a replay see current data.
+    const state: { apiKey?: string; catalog: readonly MuseModel[] } = { catalog: FALLBACK_CATALOG }
+
+    const refresh = async (): Promise<boolean> => {
+      const credential = await readCredential(optionKey)
+      const apiKey = credential?.api_key ?? (credential?.access_token && (await mintApiKey(credential.access_token)))
+      if (!apiKey) return false
+
+      state.apiKey = apiKey
+      const catalog = await fetchCatalog(apiKey)
+      const usable = catalog?.filter((model) => {
+        const meta = model.metadata?.["muse-code"]
+        return meta && !meta.is_hidden && meta.tool_call !== false && (meta.modalities?.output ?? ["text"]).includes("text")
+      })
+      if (usable?.length) state.catalog = usable
+      return true
+    }
+
+    const connected = await refresh().catch(() => false)
+    if (!connected) {
+      console.warn(
+        "[muse-code] No Muse Code login found. Sign in with the `muse` CLI or set META_API_KEY. " +
+          "Models are listed but requests fail until then.",
+      )
+    }
+
+    const registration = await provider.transform((editor) => {
+      const settings = state.apiKey ? { baseURL: API_BASE, apiKey: state.apiKey } : { baseURL: API_BASE }
+      const models = state.catalog.map((model) => toModelInfo(providerID, model))
+
+      if (editor.get(PROVIDER_ID)) {
+        editor.update(PROVIDER_ID, (draft) => {
+          draft.name = PROVIDER_NAME
+          draft.activation = "enabled"
+          draft.package = PROVIDER_PACKAGE
+          draft.settings = settings
+        })
+        editor.models.set(PROVIDER_ID, models)
+        return
+      }
+
+      editor.add({
+        info: {
+          ...Provider.Info.empty(providerID),
+          name: PROVIDER_NAME,
+          activation: "enabled",
+          package: PROVIDER_PACKAGE,
+          settings,
+        },
+        models,
+      })
+    })
+
+    const timer = setInterval(() => {
+      void refresh()
+        .then((ready) => (ready ? provider.reload() : undefined))
+        .catch((error) => console.error("[muse-code] refresh failed", error))
+    }, REFRESH_MS)
+
+    return () => {
+      clearInterval(timer)
+      void registration.dispose()
+    }
+  },
+})

package/package.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "opencode-muse-code",
+  "version": "0.1.0",
+  "description": "Use a Muse Code (Meta) subscription in OpenCode",
+  "author": "Shane Walker",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swalker326/opencode-muse-code.git"
+  },
+  "homepage": "https://github.com/swalker326/opencode-muse-code#readme",
+  "bugs": {
+    "url": "https://github.com/swalker326/opencode-muse-code/issues"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "muse",
+    "muse-code",
+    "meta"
+  ],
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  }
+}