@telefonica/ai-sdlc-opencode-plugin-v1-dev 0.1.0-snapshot.35846538366

package/README.md

@@ -0,0 +1,124 @@
+# @telefonica/ai-sdlc-opencode-plugin-v1
+
+CDO.AI gateway plugin for **OpenCode 1.x**. Registers the gateway as a provider,
+discovers its models, and renders remaining budget in the sidebar.
+
+For installation and the `/connect` walkthrough, see the
+[plugins README](../../README.md). This file covers the internals.
+
+> Using OpenCode 2.x? Install [`@telefonica/ai-sdlc-opencode-plugin-v2`](../v2)
+> instead — the two major versions have incompatible plugin APIs.
+
+## What it provides
+
+Two flavors are published as separate packages, each built into
+`plugin-dist/<flavor>/` with its own generated manifest — the same layout the v2
+plugin uses.
+
+| Package | Provider id | Shown in `/connect` as |
+| --- | --- | --- |
+| `@telefonica/ai-sdlc-opencode-plugin-v1` | `cdo-ai` | CDO.AI |
+| `@telefonica/ai-sdlc-opencode-plugin-v1-dev` | `cdo-ai-dev` | CDO.AI (dev) |
+
+Each package exposes two entry points, which OpenCode resolves independently:
+
+| Export | Built file | Role |
+| --- | --- | --- |
+| `./server` | `dist/index.js` | Provider registration, `/connect` auth, model discovery |
+| `./tui` | `dist/tui.js` | Sidebar budget panel |
+
+Only `exports["./server"]` and `exports["./tui"]` are consulted. OpenCode never
+reads `exports["."]`, and a `main` field would be picked up as an additional
+server entry point, so neither is declared.
+
+The production panel also covers the hand-written `litellm*` providers from the
+older manual setup, so the budget display keeps working while users migrate. The
+dev panel matches only `cdo-ai-dev`, so installing both packages does not produce
+two panels for the same gateway.
+
+## Architecture notes
+
+These are load-bearing constraints of the OpenCode 1.x plugin API. They look
+arbitrary in isolation, so they are recorded here.
+
+**Models come from the `config` hook, not the `provider.models` hook.** OpenCode
+invokes `provider.models` before config-declared providers exist, so it never
+fires for a provider that is not in the models.dev catalog. Discovery therefore
+happens in the `config` hook, which is async and may perform network calls.
+
+**A provider with no models is discarded.** OpenCode deletes any provider whose
+model map is empty before `/connect` renders, so the config hook seeds a
+placeholder entry that is replaced once discovery succeeds.
+
+**`/connect` does not call `authorize()` for API-key methods.** Values collected
+by `prompts` are stored as credential metadata and the key itself is collected by
+a separate built-in step. The auth method therefore prompts only for the gateway
+URL, and `auth.loader` recombines the stored URL and key into provider options.
+
+**Credentials are read from disk.** Stored auth is not exposed in-process when
+the config hook runs, so it reads `auth.json` directly. Resolution order is
+config `options`, then environment variables, then `auth.json`. Resolved values
+are written back into `options` because a fully custom provider builds its
+completion client from them directly.
+
+**One environment per package.** `Hooks.auth` binds a single provider id, so each
+environment needs its own plugin instance. Rather than smuggling both into one
+module, each flavor is built and published separately, which keeps the plain
+default-export plugin module shape and matches the v2 plugin.
+
+## Layout
+
+```
+src/
+├── flavor.ts             # prod/dev ids and labels, mirroring the v2 plugin
+├── entry-prod.ts         # server entry, prod   -> dist/index.js
+├── entry-dev.ts          # server entry, dev    -> dist/index.js
+├── tui-prod.tsx          # TUI entry, prod      -> dist/tui.js
+├── tui-dev.tsx           # TUI entry, dev       -> dist/tui.js
+├── tui.tsx               # sidebar slot registration and budget polling
+├── components.tsx        # budget panel rendering
+├── usage-client.ts       # /v1/usage fetch for the budget panel
+└── server/
+    ├── plugin.ts         # assembles the hooks for a flavor
+    ├── config-hook.ts    # provider registration and model discovery
+    ├── auth-hook.ts      # /connect prompts and credential loading
+    ├── credentials.ts    # config / env / auth.json resolution
+    ├── models-client.ts  # /v1/models and /v1/model/info
+    ├── model-cache.ts    # 7-day on-disk model cache
+    └── constants.ts
+```
+
+`FLAVOR=dev|prod` is the only build flag. Every identity string lives in
+`src/flavor.ts`; there is no runtime environment lookup.
+
+## Develop
+
+```bash
+npm ci
+npm run build:prod   # writes plugin-dist/prod/dist/
+npm run build:dev    # writes plugin-dist/dev/dist/
+npm run build        # both
+```
+
+Point OpenCode at a built flavor to try it:
+
+```jsonc
+{ "plugin": ["/absolute/path/to/plugins/opencode/v1/plugin-dist/prod"] }
+```
+
+For OpenCode 1.x, put this entry in both `opencode.jsonc` and `tui.jsonc`.
+The server and TUI plugin loaders use separate config files.
+
+Build before launching — OpenCode installs plugins with scripts disabled and will
+not build the package for you. Quit OpenCode fully between attempts, since a
+plugin that fails to load stays cached for the lifetime of the process.
+
+## Release
+
+Published by `.github/workflows/opencode-plugin-release.yml` via
+`semantic-release`, tagged `opencode-v1@<version>`.
+
+`plugin-dist/` is a build output directory and is not committed. The release
+`prepareCmd` builds both flavors and then runs `scripts/write-manifests.js`,
+which generates each publish manifest; `publishCmd` publishes both. The root
+package is `private` and exists only to hold the sources and release config.

package/dist/flavor-CMZWvD--.js

@@ -0,0 +1,13 @@
+//#region src/flavor.ts
+const DEV = {
+	environment: "dev",
+	serverPluginID: "ai-sdlc-opencode-cdo-ai-dev-plugin",
+	tuiPluginID: "ai-sdlc-opencode-cdo-ai-dev-plugin.tui",
+	providerID: "cdo-ai-dev",
+	displayName: "CDO.AI (dev)",
+	connectLabel: "CDO.AI (dev) API key",
+	apiKeyEnvVars: ["CDO_AI_DEV_API_KEY"],
+	matchesPanelProvider: (id) => id === "cdo-ai-dev"
+};
+//#endregion
+export { DEV as t };

package/dist/index-T2VhrgAK.d.ts

@@ -0,0 +1,9 @@
+import * as _opencode_ai_plugin0 from "@opencode-ai/plugin";
+
+//#region src/entry-dev.d.ts
+declare const _default: {
+  id: string;
+  server: _opencode_ai_plugin0.Plugin;
+};
+//#endregion
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,205 @@
+import { t as DEV } from "./flavor-CMZWvD--.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/server/auth-hook.ts
+function createAuthHook(flavor) {
+	return {
+		provider: flavor.providerID,
+		async loader(auth) {
+			const creds = await auth();
+			if (!creds || creds.type !== "api") return {};
+			return {
+				baseURL: creds.metadata?.["url"],
+				apiKey: creds.key
+			};
+		},
+		methods: [{
+			type: "api",
+			label: flavor.connectLabel,
+			prompts: [{
+				type: "text",
+				key: "url",
+				message: `${flavor.displayName} proxy URL`,
+				placeholder: "https://litellm.example.com/v1"
+			}]
+		}]
+	};
+}
+//#endregion
+//#region src/server/constants.ts
+const PROVIDER_NPM = "@ai-sdk/openai-compatible";
+const FETCH_TIMEOUT_MS = 8e3;
+const CACHE_TTL_MS = 6048e5;
+//#endregion
+//#region src/server/credentials.ts
+function normalizeRoot(url) {
+	return url.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+function authFilePath() {
+	const dataHome = process.env["XDG_DATA_HOME"] || join(homedir(), ".local", "share");
+	return join(dataHome, "opencode", "auth.json");
+}
+async function fromAuthFile(providerID) {
+	try {
+		const raw = await readFile(authFilePath(), "utf8");
+		const entry = JSON.parse(raw)[providerID];
+		if (!entry || entry.type !== "api") return {};
+		return {
+			apiKey: entry.key,
+			baseURL: entry.metadata?.["url"]
+		};
+	} catch {
+		return {};
+	}
+}
+function fromEnv(flavor) {
+	for (const name of flavor.apiKeyEnvVars) {
+		const value = process.env[name];
+		if (value) return value;
+	}
+}
+async function resolveCredentials(flavor, options) {
+	const stored = await fromAuthFile(flavor.providerID);
+	const apiKey = (typeof options.apiKey === "string" ? options.apiKey : void 0) || fromEnv(flavor) || stored.apiKey;
+	const baseURL = (typeof options.baseURL === "string" ? options.baseURL : void 0) || stored.baseURL;
+	return {
+		apiKey,
+		baseURL: baseURL ? normalizeRoot(baseURL) : void 0
+	};
+}
+//#endregion
+//#region src/server/model-cache.ts
+function cacheDir() {
+	const cacheHome = process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache");
+	return join(cacheHome, "opencode-cdo-ai");
+}
+function cachePath(root) {
+	const key = createHash("sha256").update(root).digest("hex").slice(0, 16);
+	return join(cacheDir(), `models-${key}.json`);
+}
+async function readCache(root) {
+	try {
+		const parsed = JSON.parse(await readFile(cachePath(root), "utf8"));
+		if (!parsed.models || Object.keys(parsed.models).length === 0) return void 0;
+		return {
+			models: parsed.models,
+			fresh: Date.now() - parsed.savedAt < CACHE_TTL_MS
+		};
+	} catch {
+		return;
+	}
+}
+async function writeCache(root, models) {
+	try {
+		await mkdir(cacheDir(), { recursive: true });
+		const payload = {
+			savedAt: Date.now(),
+			models
+		};
+		await writeFile(cachePath(root), JSON.stringify(payload), "utf8");
+	} catch {}
+}
+//#endregion
+//#region src/server/models-client.ts
+async function getJSON(url, apiKey) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+	try {
+		const res = await fetch(url, {
+			headers: { Authorization: `Bearer ${apiKey}` },
+			signal: controller.signal
+		});
+		if (!res.ok) throw new Error(`HTTP ${res.status}`);
+		return await res.json();
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function parseIds(payload) {
+	const data = payload?.data;
+	if (!Array.isArray(data)) return [];
+	return data.map((m) => m.id).filter((id) => typeof id === "string" && id.length > 0);
+}
+function parseInfo(payload) {
+	const data = payload?.data;
+	if (!Array.isArray(data)) return {};
+	const out = {};
+	for (const row of data) if (typeof row.model_name === "string" && row.model_info) out[row.model_name] = row.model_info;
+	return out;
+}
+function toEntry(id, info) {
+	return {
+		name: id,
+		limit: {
+			context: info?.max_input_tokens ?? info?.max_tokens ?? 128e3,
+			output: info?.max_output_tokens ?? 16384
+		},
+		tool_call: info?.supports_function_calling ?? true,
+		reasoning: info?.supports_reasoning ?? false,
+		attachment: info?.supports_vision ?? false
+	};
+}
+async function discoverModels(root, apiKey) {
+	const [idsResult, infoResult] = await Promise.allSettled([getJSON(`${root}/v1/models`, apiKey), getJSON(`${root}/v1/model/info`, apiKey)]);
+	if (idsResult.status !== "fulfilled") throw idsResult.reason;
+	const ids = parseIds(idsResult.value);
+	const info = infoResult.status === "fulfilled" ? parseInfo(infoResult.value) : {};
+	const models = {};
+	for (const id of ids) {
+		const meta = info[id];
+		if (meta?.mode && meta.mode !== "chat") continue;
+		models[id] = toEntry(id, meta);
+	}
+	return models;
+}
+//#endregion
+//#region src/server/config-hook.ts
+async function resolveModels(root, apiKey) {
+	const cached = await readCache(root);
+	if (cached?.fresh) return cached.models;
+	try {
+		const discovered = await discoverModels(root, apiKey);
+		if (Object.keys(discovered).length === 0) return cached?.models;
+		await writeCache(root, discovered);
+		return discovered;
+	} catch {
+		return cached?.models;
+	}
+}
+function createConfigHook(flavor) {
+	return async function configHook(config) {
+		try {
+			config.provider ??= {};
+			const provider = config.provider[flavor.providerID] ??= {};
+			provider.name ??= flavor.displayName;
+			provider.npm ??= PROVIDER_NPM;
+			provider.options ??= {};
+			provider.models ??= { ["_"]: {} };
+			const { baseURL, apiKey } = await resolveCredentials(flavor, provider.options);
+			if (!baseURL || !apiKey) return;
+			provider.options.baseURL ??= `${baseURL}/v1`;
+			provider.options.apiKey ??= apiKey;
+			const models = await resolveModels(baseURL, apiKey);
+			if (!models || Object.keys(models).length === 0) return;
+			provider.models = models;
+		} catch {}
+	};
+}
+//#endregion
+//#region src/server/plugin.ts
+function createServer(flavor) {
+	return async (_ctx) => ({
+		config: createConfigHook(flavor),
+		auth: createAuthHook(flavor)
+	});
+}
+//#endregion
+//#region src/entry-dev.ts
+var entry_dev_default = {
+	id: DEV.serverPluginID,
+	server: createServer(DEV)
+};
+//#endregion
+export { entry_dev_default as default };

package/dist/tui-BTWQZHT5.d.ts

@@ -0,0 +1,9 @@
+import * as _opencode_ai_plugin_tui0 from "@opencode-ai/plugin/tui";
+
+//#region src/tui-dev.d.ts
+declare const _default: {
+  id: string;
+  tui: _opencode_ai_plugin_tui0.TuiPlugin;
+};
+//#endregion
+export { _default as default };

package/dist/tui.js

@@ -0,0 +1,118 @@
+import { t as DEV } from "./flavor-CMZWvD--.js";
+import { For, createSignal } from "solid-js";
+import { createTextAttributes } from "@opentui/core";
+import { jsx, jsxs } from "@opentui/solid/jsx-runtime";
+//#region src/usage-client.ts
+function deriveApiUrl(litellmBaseURL) {
+	return litellmBaseURL.replace(/^(https?:\/\/)litellm(\.[^/]+).*/, "$1api$2");
+}
+async function fetchUsage(baseURL, apiKey, timeoutMs) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const res = await fetch(`${deriveApiUrl(baseURL)}/v1/usage`, {
+			headers: { Authorization: `Bearer ${apiKey}` },
+			signal: controller.signal
+		});
+		if (!res.ok) return `HTTP ${res.status}`;
+		return await res.json();
+	} catch (e) {
+		return e instanceof Error ? e.message : "network error";
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function round1(n) {
+	return Math.round(n * 10) / 10;
+}
+function toEntry(providerName, result) {
+	if (typeof result === "string") return {
+		providerName,
+		error: result
+	};
+	const percent = result.budget != null ? round1(result.spend / result.budget * 100) : null;
+	return {
+		providerName,
+		...result,
+		percent
+	};
+}
+//#endregion
+//#region src/components.tsx
+const BAR_WIDTH = 20;
+function bar(percent) {
+	if (percent == null) return "∞";
+	const filled = Math.min(Math.round(percent / 100 * BAR_WIDTH), BAR_WIDTH);
+	return "█".repeat(filled) + "░".repeat(BAR_WIDTH - filled);
+}
+function barColor(entry, theme) {
+	const pct = entry.percent ?? 0;
+	return pct >= 100 ? theme.error : pct >= 80 ? theme.warning : theme.success;
+}
+function valuesLine(entry) {
+	if (entry.error != null) return ` ${entry.error}`;
+	return entry.budget != null ? ` $${entry.spend.toFixed(2)} / $${entry.budget.toFixed(2)} (${entry.percent?.toFixed(1)}%)` : ` $${entry.spend.toFixed(2)} / ∞`;
+}
+function UsagePanel(props) {
+	return /* @__PURE__ */ jsx(For, {
+		each: props.entries,
+		children: (entry) => /* @__PURE__ */ jsxs("box", { children: [
+			/* @__PURE__ */ jsx("text", {
+				attributes: createTextAttributes({ bold: true }),
+				children: entry.providerName
+			}),
+			/* @__PURE__ */ jsx("text", {
+				fg: entry.error != null ? props.theme.error : void 0,
+				children: valuesLine(entry)
+			}),
+			/* @__PURE__ */ jsx("text", {
+				fg: barColor(entry, props.theme),
+				children: entry.error == null ? ` ${bar(entry.percent ?? null)}` : ""
+			})
+		] })
+	});
+}
+//#endregion
+//#region src/tui.tsx
+const REFRESH_MS = 6e4;
+const TIMEOUT_MS = 5e3;
+function createTui(flavor) {
+	return (api) => {
+		const [entries, setEntries] = createSignal([]);
+		async function refresh() {
+			try {
+				const providers = api.state.provider.filter((p) => flavor.matchesPanelProvider(p.id));
+				const results = await Promise.all(providers.map(async (p) => {
+					const options = p.options ?? {};
+					const baseURL = options["baseURL"];
+					const apiKey = p.key ?? options["apiKey"];
+					if (!apiKey) return toEntry(p.name, "no API key configured");
+					if (!baseURL) return toEntry(p.name, "no base URL configured");
+					return toEntry(p.name, await fetchUsage(baseURL, apiKey, TIMEOUT_MS));
+				}));
+				setEntries(results);
+			} catch {}
+		}
+		refresh();
+		const interval = setInterval(refresh, REFRESH_MS);
+		api.lifecycle.onDispose(() => clearInterval(interval));
+		api.slots.register({
+			order: 101,
+			slots: { sidebar_content(ctx) {
+				return /* @__PURE__ */ jsx(UsagePanel, {
+					entries: entries(),
+					theme: ctx.theme.current
+				});
+			} }
+		});
+		return Promise.resolve();
+	};
+}
+//#endregion
+//#region src/tui-dev.tsx
+var tui_dev_default = {
+	id: DEV.tuiPluginID,
+	tui: createTui(DEV)
+};
+//#endregion
+export { tui_dev_default as default };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@telefonica/ai-sdlc-opencode-plugin-v1-dev",
+  "version": "0.1.0-snapshot.35846538366",
+  "description": "OpenCode 1.x plugin (dev environment): CDO.AI provider registration, model discovery, and budget panel",
+  "type": "module",
+  "exports": {
+    "./server": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
+  "files": [
+    "dist"
+  ]
+}