dsh-opencode 0.1.1 → 0.1.3

package/README.md

@@ -1,108 +1,64 @@
-# dsh-opencode — OpenCode Zen / Go live catalog plugin
+# dsh-opencode
 
-An out-of-tree DSH bundle that serves the OpenCode **Zen** and **Go** products as two independent live LLM routes with a **dynamic model catalog**: models the official lists publish become selectable and executable without a plugin update, rebuild, or DSH restart, as long as they use a known wire protocol and publish the metadata the route needs.
+OpenCode Zen / Go を動的カタログ付きのライブ LLM ルートとして DSH に追加するプラグイン。
 
-- `opencode-zen-live` — **OpenCode Zen (Live)**
-- `opencode-go-live` — **OpenCode Go (Live)**
+- `opencode-zen-live` — OpenCode Zen (Live)
+- `opencode-go-live` — OpenCode Go (Live)
 
-The plugin reuses DSH's public `PiAiAdapter` and pi-ai's public `createProvider()` for all message conversion, streaming, tool calls, images, replay state, usage, cancellation, and idle-timeout behavior. It does **not** port OAuth, does not modify the existing `llm-pi-ai` configuration, does not fail over between Zen and Go automatically, and never sends an inference request as part of a catalog refresh.
-
-## Compatibility
-
-- DSH packages: `0.1.2-rc.1` (published release; peer range `^0.1.2-rc.1`)
-- pi-ai: pinned to the installed DSH adapter's range (`>=0.84.2 <0.86`, verified on `0.84.2`)
-- Cordis: `4.0.2`
-- Node: `^22.19.0 || >=24.0.0`
-
-## Installation
+## インストール
 
 ```sh
 pnpm dsh plugin --profile web add github:askdkc/dsh-opencode
-pnpm dsh --profile web --dump-config
 ```
 
-The dump should contain the `opencode-live` row with both provider routes. A restart applies the bundle once; after that, catalog updates need no restart.
-
-To remove it:
+削除:
 
 ```sh
 pnpm dsh plugin --profile web remove dsh-opencode
 ```
 
-## API key
-
-Both routes resolve the credential reference `apiKeyEnv` per request through the DSH credentials service (or the launch environment when no credential service is mounted). The default reference is `OPENCODE_API_KEY` for both products; set a different one per route in settings, e.g. `DSH_OPENCODE_ZEN_API_KEY` / `DSH_OPENCODE_GO_API_KEY`, and store the value through the standard credentials UI (the web Models page) or export it in the launch environment.
-
-- A missing or unusable key fails the request with `MISSING_CREDENTIAL`; the plugin never falls back to an unrelated ambient key (`OPENAI_API_KEY`, `GEMINI_API_KEY`, …).
-- Catalog fetches are unauthenticated and share no client with inference; keys never appear in URLs, logs, diagnostics, command output, or the cache.
-- Go requests carry an honest `x-opencode-client: opencode-live/<version>` header and an opaque, stable `x-opencode-session` value per DSH session; the plugin never impersonates OpenCode itself.
-
-## How the catalog works
-
-Three public sources feed the catalog: the official Zen list, the official Go list, and the Models.dev `api.json` metadata for the `opencode` / `opencode-go` providers. The plugin joins them by exact model id and keeps every candidate visible:
+## 使い方
 
-| State | Meaning | Selector | Diagnostics |
-|---|---|---|---|
-| `ready` | officially listed with complete metadata and a known wire API | shown | — |
-| `metadata-pending` | officially listed; missing name/context/output/input/api | hidden | shown with the missing fields |
-| `unsupported-protocol` | metadata names an unknown SDK | hidden | shown with the SDK id |
-| `catalog-only` | in Models.dev but absent from the official list | hidden | shown |
-| `removed` | was officially listed before; no longer present | hidden (history keeps the name) | shown |
+1. DSH を再起動すると両ルートが登録される(以降のカタログ更新に再起動は不要)
+2. `/dsh-opencode` を実行して API キーを設定する
+   - キー未設定ならコマンドの入力フィールドにキーを貼って再度実行
+   - DSH の opencode キー保存先(`OPENCODE_API_KEY`)に書き込み、設定や他の参照を変えていないか検証
+3. モデルセレクターから OpenCode のモデルを選んで使う
 
-Wire APIs are chosen from the model-level `provider.npm` (falling back to the provider default) through a fixed allowlist: `@ai-sdk/openai-compatible` → Chat Completions, `@ai-sdk/openai` → Responses, `@ai-sdk/anthropic` → Anthropic Messages, `@ai-sdk/google` → Google Generative AI. Unknown SDK identifiers are never executed and nothing fetched is ever imported or installed. Reasoning-effort controls are offered only where the source publishes a verified effort list; toggle-only models keep the provider's default behavior.
-
-Refreshes run single-flight per source (Models.dev once for both products) with conditional GET/304 handling, timeout and decoded-body caps, empty-list protection, and per-source failure isolation. An executable-set change re-registers the same routes in place, which publishes `llm/adapters-updated` so an open selection UI re-fetches. Snapshots are immutable and generation-bound; a prepared call cannot switch providers mid-request.
-
-## Commands
-
-| Command | Effect |
+| コマンド | 効果 |
 |---|---|
-| `/dsh-opencode [<api-key>]` | Store the API key securely and enable Zen/Go immediately; with no argument, checks status and guides setup |
-| `/opencode-refresh [all\|zen\|go]` | Force a catalog refresh (joins in-flight fetches) |
-| `/opencode-status` | Freshness, per-source errors, ready/pending counts, credential presence |
-| `/opencode-models <zen\|go> [--all]` | Ready models, or every candidate with its state and reason |
+| `/dsh-opencode [<api-key>]` | API キーを保存して Zen/Go を有効化(未入力なら状態表示) |
+| `/opencode-refresh [all\|zen\|go]` | カタログを強制更新 |
+| `/opencode-status` | 更新時刻・エラー・モデル数・キー設定状況 |
+| `/opencode-models <zen\|go> [--all]` | モデル一覧(`--all` で非対応含む) |
 
-None of these commands displays key values or fragments, and none registers a model-visible tool. `/dsh-opencode` accepts the key only as its single argument and writes it through the DSH credential seam (`recordInput: false` keeps it out of session logs); it never echoes the value back.
+- API キーはコマンドの入力フィールドで受け取り、`recordInput: false` でログに残さない
+- 保存後、設定セクションと他の認証参照が変わっていないことを検証してから成功を報告する
+- 環境変数 `OPENCODE_API_KEY`(両ルート既定参照)でも可
 
-## Configuration
+## 設定
 
-Namespace `opencode-live` (composition defaults in `cordis.patch.yml`):
+名前空間 `opencode-live`(デフォルトは `cordis.patch.yml` 参照):
 
 ```yaml
 providers:
   opencode-zen-live:
-    product: zen            # must match the route key
-    apiKeyEnv: OPENCODE_API_KEY
+    product: zen
+    apiKeyEnv: OPENCODE_API_KEY   # 両ルート既定は同一参照
   opencode-go-live:
     product: go
     apiKeyEnv: OPENCODE_API_KEY
 catalog:
-  refreshIntervalMs: 900000   # periodic refresh (with jitter)
-  listRevalidateAfterMs: 60000  # re-check TTL on display/selection
-  timeoutMs: 15000            # per-request HTTP timeout
-  maxStaleMs: 604800000       # 7 days; staleness display bound
-  requireFresh: false         # true refuses requests while the official list is stale
+  refreshIntervalMs: 900000
+  timeoutMs: 15000
+  requireFresh: false
 ```
 
-`cachePath` (optional) relocates the validated-source cache; it defaults to `cache/opencode-live/catalog.json` under the DSH home. The cache stores source payloads and freshness facts only — never normalized output, never secrets.
+- `cachePath` でキャッシュ位置を変更可能(既定は DSH ホーム下 `cache/opencode-live/catalog.json`)
 
-`limit.output` sizes the model's capability; it is never materialized as a per-request token default. `configuredMaxTokens` stays empty by design: only explicit per-model configuration belongs there, and this plugin defines none.
-
-## Development
+## 開発
 
 ```sh
 pnpm install
-pnpm typecheck        # tsc --noEmit
-pnpm test             # vitest run (offline only; live tests skip)
-pnpm test:live        # opt-in: hits the public GET endpoints, no key, no inference
-pnpm build            # tsdown -> lib/
-pnpm pack:check       # npm pack --dry-run
+pnpm typecheck && pnpm test && pnpm build
 ```
-
-Tests mount a real Cordis context with the published DSH packages, stub the three catalog URLs, and cover the candidate states, refresh failure classes, wire-API selection, session headers, credential semantics, registry replacement, unload safety, and packaging.
-
-## Scope notes
-
-- Catalog refreshes never generate inference traffic, and a Go auth/limit error never switches the request to Zen.
-- Model `limit.context` / `limit.output` come only from a validated source; unknown capacities never become fabricated numbers. Source pricing maps into pi-ai's descriptor; absent pricing is the absence of a fact, not a $0 claim.
-- The repository commits the built `lib/` so installation needs no runtime TypeScript compilation.

package/lib/commands.js

@@ -1,5 +1,5 @@
 import { PRODUCT_BY_ROUTE, ROUTE_BY_PRODUCT, describeNonReadyState } from "./normalize.js";
-import { assertUsableApiKey } from "@deepseek-ai/dsh-llm";
+import "./keyring.js";
 //#region src/commands.ts
 const USAGE_REFRESH = "Usage: /opencode-refresh [all|zen|go]";
 const USAGE_MODELS = "Usage: /opencode-models <zen|go> [--all]";
@@ -37,10 +37,6 @@ function parseProduct(raw) {
 	if (raw === "zen") return "zen";
 	if (raw === "go") return "go";
 }
-/** Distinct credential references across the configured routes. */
-function configuredRefs(services) {
-	return [...new Set([...services.config().providers.values()].map((provider) => provider.apiKeyEnv))];
-}
 /** Build the three command definitions. */
 function commandDefinitions(ctx, services) {
 	return [
@@ -134,46 +130,38 @@ function commandDefinitions(ctx, services) {
 		},
 		{
 			name: "dsh-opencode",
-			description: "Store the OpenCode API key and enable Zen/Go immediately",
+			description: "Store the OpenCode API key, or report status",
+			input: { hint: "Paste the OpenCode API key here (required only when unset)" },
 			recordInput: false,
 			handler: async (invocation) => {
-				const raw = invocation.rawInput.trim();
-				let stored = false;
-				if (raw.length > 0) {
-					try {
-						assertUsableApiKey(raw, "opencode-live", "input");
-					} catch (error) {
-						return {
-							kind: "error",
-							text: error.message
-						};
-					}
-					const failures = [];
-					for (const ref of configuredRefs(services)) try {
-						await services.storeCredential(ref, raw);
-					} catch (error) {
-						failures.push(`${ref}: ${error.message}`);
-					}
-					if (failures.length > 0) return {
+				const routes = [ROUTE_BY_PRODUCT.zen, ROUTE_BY_PRODUCT.go];
+				const key = invocation.rawInput.trim();
+				if (key.length > 0) {
+					if (invocation.signal.aborted) return {
+						kind: "success",
+						text: "Storing cancelled."
+					};
+					const failure = await services.storeApiKey(key);
+					if (failure !== void 0) return {
 						kind: "error",
-						text: ["Could not store the OpenCode API key:", ...failures].join("\n")
+						text: failure
 					};
-					stored = true;
-				}
-				const routes = [ROUTE_BY_PRODUCT.zen, ROUTE_BY_PRODUCT.go];
-				if (!stored) {
-					if (!(await Promise.all(routes.map(async (route) => {
-						return (await services.describeCredential(route))?.configured === true;
-					}))).some((configured) => configured)) return {
+					const lines = ["OpenCode API key stored. Zen and Go are enabled:"];
+					for (const route of routes) lines.push(await productStatus(ctx, services, PRODUCT_BY_ROUTE[route]));
+					return {
 						kind: "success",
-						text: [
-							"No OpenCode API key is configured yet.",
-							"Run /dsh-opencode <your-api-key> to store it securely and enable both routes at once,",
-							"or store it through the standard credentials input (the web Models page writes it) and run /dsh-opencode again.",
-							"This command never displays key values."
-						].join("\n")
+						text: lines.join("\n")
 					};
 				}
+				if (!await services.keyConfigured()) return {
+					kind: "success",
+					text: [
+						"No OpenCode API key is configured yet.",
+						"Type the key into this command's input field and run again, or export it in the launch environment.",
+						...await services.keyReadonly() ? ["The credential reference is read-only in this deployment."] : [],
+						"This command never displays key values."
+					].join("\n")
+				};
 				if (invocation.signal.aborted) return {
 					kind: "success",
 					text: "Refresh cancelled."
@@ -184,7 +172,7 @@ function commandDefinitions(ctx, services) {
 						signal: invocation.signal
 					});
 				} catch {}
-				const lines = [stored ? "OpenCode API key stored. Zen and Go are enabled:" : "OpenCode API key configured. Zen and Go are enabled:"];
+				const lines = ["OpenCode API key configured. Zen and Go are enabled:"];
 				for (const route of routes) lines.push(await productStatus(ctx, services, PRODUCT_BY_ROUTE[route]));
 				return {
 					kind: "success",

package/lib/index.js

@@ -4,6 +4,7 @@ import { readySetHash } from "./snapshot.js";
 import { CatalogManager } from "./catalog.js";
 import { Config, DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_REQUEST_IMAGE_MAX_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, assertServiceable, resolveConfig } from "./config.js";
 import { apiKeyOnlyAuth, describeCredential, resolveApiKeyFor, staticAuthBridge } from "./credentials.js";
+import { keyConfigured, keyReadonly, storeApiKey } from "./keyring.js";
 import { registerCommands } from "./commands.js";
 import { buildRouteProvider } from "./transport.js";
 import { resolveImageAttachmentAccess, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
@@ -155,11 +156,9 @@ function apply(ctx, config = {}) {
 				if (provider === void 0) return void 0;
 				return describeCredential(ctx, provider.apiKeyEnv);
 			},
-			storeCredential: async (ref, value) => {
-				const credentials = ctx.get("credentials");
-				if (credentials === void 0) throw new Error("opencode-live: no credentials service is mounted; export the API key in the launch environment instead");
-				await credentials.set(ref, value);
-			}
+			storeApiKey: (value) => storeApiKey(ctx, currentConfig.providers.values(), value),
+			keyConfigured: () => keyConfigured(ctx, currentConfig.providers.values()),
+			keyReadonly: () => keyReadonly(ctx, currentConfig.providers.values())
 		});
 	});
 	let source = () => config;

package/lib/keyring.js

@@ -0,0 +1,109 @@
+import { SETTINGS_NAMESPACE } from "./index.js";
+import { assertUsableApiKey } from "@deepseek-ai/dsh-llm";
+//#region src/keyring.ts
+/**
+* Read one reference's presence, treating an absent credential service as a
+* stable `false` rather than a throw: the caller wants facts, not a diagnosis.
+*/
+async function refState(ctx, ref) {
+	const credentials = ctx.get("credentials");
+	if (credentials === void 0) return {
+		configured: false,
+		writable: false
+	};
+	const described = await credentials.describe(ref);
+	return described === void 0 ? {
+		configured: false,
+		writable: false
+	} : {
+		configured: described.configured,
+		writable: described.writable
+	};
+}
+/**
+* Read the state a key store is about to operate against.
+* @param ctx - the plugin context.
+* @param providers - the currently resolved provider profiles.
+* @returns the immutable snapshot for before/after comparison.
+*/
+async function snapshotKeyring(ctx, providers) {
+	const settings = ctx.get("settings");
+	const sectionValue = settings === void 0 ? void 0 : settings.get(SETTINGS_NAMESPACE);
+	const refs = /* @__PURE__ */ new Map();
+	for (const { apiKeyEnv } of providers) if (!refs.has(apiKeyEnv)) refs.set(apiKeyEnv, await refState(ctx, apiKeyEnv));
+	return {
+		section: JSON.stringify(sectionValue ?? null),
+		refs
+	};
+}
+/**
+* Verify a key store left no stray change. Compares the section snapshot and
+* every reference the plugin knows with a stable JSON text, so a change in
+* either is caught regardless of ordering.
+* @param before - the snapshot taken before the store.
+* @param after - the snapshot taken after the store.
+* @param refs - the references the store wrote (the only ones allowed to move).
+* @returns a failure line, or `undefined` when only the intended refs changed.
+*/
+function verifyNoStrayChange(before, after, refs) {
+	if (before.section !== after.section) return `opencode-live: the settings section changed while storing the key (${SETTINGS_NAMESPACE})`;
+	for (const [ref, state] of before.refs) {
+		const next = after.refs.get(ref);
+		if (next === void 0) return `opencode-live: credential ${ref} vanished after storing the key`;
+		if (state.configured === next.configured && state.writable === next.writable) continue;
+		if (!refs.includes(ref)) return `opencode-live: an unrelated credential reference changed (${ref})`;
+	}
+	for (const [ref, next] of after.refs) {
+		if (before.refs.has(ref)) continue;
+		if (!refs.includes(ref)) return `opencode-live: an unrelated credential reference appeared (${ref})`;
+		if (!next.configured) return `opencode-live: the stored reference ${ref} did not become configured`;
+	}
+}
+/**
+* Store one OpenCode key through the DSH credential seam.
+*
+* This is the whole write surface a command uses. Validation runs before any
+* write, so a key that would be refused is never persisted. The write is
+* fenced by `snapshotKeyring` before and after; a stray settings or unrelated
+* credential change fails the call with a diagnostic instead of silently
+* committing alongside the key.
+* @param ctx - the plugin context.
+* @param providers - the currently resolved provider profiles.
+* @param value - the key typed into the command's input field.
+* @returns `undefined` on success, or a failure line naming the exact problem.
+*/
+async function storeApiKey(ctx, providers, value) {
+	try {
+		assertUsableApiKey(value, "opencode-live", "input");
+	} catch (error) {
+		return error.message;
+	}
+	const credentials = ctx.get("credentials");
+	if (credentials === void 0) return "opencode-live: no credentials service is mounted; export the API key in the launch environment instead";
+	const before = await snapshotKeyring(ctx, providers);
+	const targets = [...new Set([...providers].map(({ apiKeyEnv }) => apiKeyEnv))];
+	try {
+		for (const ref of targets) await credentials.set(ref, value);
+	} catch (error) {
+		return `opencode-live: could not store the API key (${error.message})`;
+	}
+	return verifyNoStrayChange(before, await snapshotKeyring(ctx, providers), targets);
+}
+/**
+* Presence facts for the status path: whether a key is configured, without
+* ever exposing a value.
+* @param ctx - the plugin context.
+* @param providers - the currently resolved provider profiles.
+* @returns whether the shared reference is configured.
+*/
+async function keyConfigured(ctx, providers) {
+	const refs = [...new Set([...providers].map(({ apiKeyEnv }) => apiKeyEnv))];
+	return (await Promise.all(refs.map((ref) => refState(ctx, ref)))).some((state) => state.configured);
+}
+/** Whether any reference is read-only, so the status can say so. */
+async function keyReadonly(ctx, providers) {
+	const refs = [...new Set([...providers].map(({ apiKeyEnv }) => apiKeyEnv))];
+	return (await Promise.all(refs.map((ref) => refState(ctx, ref)))).some((state) => !state.writable);
+}
+//#endregion
+export { keyConfigured, keyReadonly, snapshotKeyring, storeApiKey, verifyNoStrayChange };

package/lib/transport.js

@@ -27,7 +27,7 @@ import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.l
 */
 /** The plugin's honest client identification value. */
 const PLUGIN_ID = "opencode-live";
-const PLUGIN_VERSION = "0.1.0";
+const PLUGIN_VERSION = "0.1.2";
 /** Header OpenCode Go documents for coding-agent session identification. */
 const SESSION_HEADER = "x-opencode-session";
 /** Header carrying this plugin's honest client identity alongside DSH attribution. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-opencode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Out-of-tree DSH bundle with live dynamic OpenCode Zen / Go model catalogs",
   "private": false,
   "license": "MIT",