@vymalo/opencode-lightbridge 0.16.1 → 0.18.0

package/dist/migration.js

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { FileCacheStore as LegacyFileCacheStore } from "@vymalo/opencode-auth-core/lib";
+import { FileCacheStore as SharedFileCacheStore } from "@vymalo/opencode-provider-sync/lib";
+/**
+* The pre-ADR-0017 on-disk location of lightbridge's human root token:
+* `<cacheRoot>/opencode-lightbridge/lightbridge.json`, a bare `TokenSet`
+* (see the OLD `LIGHTBRIDGE_IDENTITY`/`DEFAULT_CACHE_NAMESPACE` in `plugin.ts`,
+* which are still used verbatim for the exchanged project-token store — only
+* the ROOT token relocated).
+*/
+const OLD_ROOT_CACHE_NAMESPACE = "opencode-lightbridge";
+const OLD_ROOT_KEY = "lightbridge";
+function hasUsableTokenShape(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return false;
+	}
+	const candidate = value;
+	return typeof candidate.accessToken === "string" && candidate.accessToken.length > 0 && typeof candidate.tokenType === "string" && candidate.tokenType.length > 0;
+}
+/**
+* One-time migration read-path (ADR-0017, mandatory — not optional polish).
+*
+* v0.17 moves lightbridge's human root token from its own bespoke file
+* (`<cacheRoot>/opencode-lightbridge/lightbridge.json`, a bare `TokenSet`) to
+* the SAME fused `CachedServerState` file `@vymalo/opencode-oauth2` uses
+* (`<cacheRoot>/<sharedSegment>/<sharedNamespace>/<serverId>.json`) so the two
+* plugins can share one login (ADR-0017 §"one login, shared cache"). An
+* install that already has a valid old-format token must NOT be forced
+* through a fresh device-code/browser login just because the file moved.
+*
+* Behaviour:
+* - If the NEW location already has a persisted state (with or without a
+*   token), this is a no-op — never clobbers a fresher state (e.g. one
+*   oauth2 has already been writing to, with real discovered models).
+* - Else, read the OLD location. If it holds a structurally usable token
+*   (`accessToken` + `tokenType` present — possibly expired; an expired
+*   token with a refresh token is still worth adopting, since `TokenRuntime`
+*   will refresh it transparently), write it into the NEW location as a
+*   fresh `CachedServerState` (empty `models`/`rawModels` — nothing to carry
+*   over, since the old shape never tracked models).
+* - Else (no old file, or it's empty/malformed) this is a no-op; the caller
+*   proceeds to a normal login.
+*
+* The old file is left in place (non-destructive) — this function only ever
+* ADDS the new file, never deletes/mutates the old one. Safe to call more
+* than once: the "new location already has a state" check makes every call
+* after the first a cheap no-op.
+*/
+export async function migrateRootTokenIfNeeded(cacheRoot, sharedSegment, sharedNamespace, serverId, logger) {
+	const sharedStore = new SharedFileCacheStore(join(cacheRoot, sharedSegment, sharedNamespace), logger);
+	let alreadyMigrated;
+	try {
+		alreadyMigrated = await sharedStore.loadServerState(serverId);
+	} catch (error) {
+		logger.debug("lightbridge_root_migration_check_failed", { error: error instanceof Error ? error.message : String(error) });
+		return;
+	}
+	if (alreadyMigrated) {
+		// New location already has SOME state (with or without a token) — either
+		// a previous migration ran, or oauth2/register already populated it.
+		// Never overwrite it from the old file.
+		return;
+	}
+	const legacyStore = new LegacyFileCacheStore(join(cacheRoot, OLD_ROOT_CACHE_NAMESPACE), logger);
+	let legacyToken;
+	try {
+		legacyToken = await legacyStore.load(OLD_ROOT_KEY);
+	} catch (error) {
+		logger.debug("lightbridge_root_migration_legacy_read_failed", { error: error instanceof Error ? error.message : String(error) });
+		return;
+	}
+	if (!hasUsableTokenShape(legacyToken)) {
+		logger.trace("lightbridge_root_migration_nothing_to_adopt", { serverId });
+		return;
+	}
+	const migrated = {
+		serverId,
+		updatedAt: Date.now(),
+		models: [],
+		rawModels: [],
+		token: legacyToken
+	};
+	await sharedStore.ensureReady();
+	await sharedStore.saveServerState(migrated);
+	logger.info("lightbridge_root_migration_adopted", {
+		serverId,
+		hadRefreshToken: Boolean(legacyToken.refreshToken)
+	});
+}
+
+//# sourceMappingURL=migration.js.map

package/dist/migration.js.map

@@ -0,0 +1 @@
+{"mappings":"AAAA,SAAS,YAAY;AAErB,SACE,kBAAkB,4BAGb;AACP,SACE,kBAAkB,4BAEb;;;;;;;;AASP,MAAM,2BAA2B;AACjC,MAAM,eAAe;AAErB,SAAS,oBAAoB,OAAmC;CAC9D,IAAI,CAAC,SAAS,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GAAG;EAC/D,OAAO;CACT;CACA,MAAM,YAAY;CAClB,OACE,OAAO,UAAU,gBAAgB,YACjC,UAAU,YAAY,SAAS,KAC/B,OAAO,UAAU,cAAc,YAC/B,UAAU,UAAU,SAAS;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,eAAe,yBACpB,WACA,eACA,iBACA,UACA,QACe;CACf,MAAM,cAAc,IAAI,qBACtB,KAAK,WAAW,eAAe,eAAe,GAC9C,MACF;CAEA,IAAI;CACJ,IAAI;EACF,kBAAkB,MAAM,YAAY,gBAAgB,QAAQ;CAC9D,SAAS,OAAO;EACd,OAAO,MAAM,2CAA2C,EACtD,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAC9D,CAAC;EACD;CACF;CACA,IAAI,iBAAiB;;;;EAInB;CACF;CAEA,MAAM,cAAc,IAAI,qBAAqB,KAAK,WAAW,wBAAwB,GAAG,MAAM;CAC9F,IAAI;CACJ,IAAI;EACF,cAAc,MAAM,YAAY,KAAe,YAAY;CAC7D,SAAS,OAAO;EACd,OAAO,MAAM,iDAAiD,EAC5D,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAC9D,CAAC;EACD;CACF;CAEA,IAAI,CAAC,oBAAoB,WAAW,GAAG;EACrC,OAAO,MAAM,+CAA+C,EAAE,SAAS,CAAC;EACxE;CACF;CAEA,MAAM,WAA8B;EAClC;EACA,WAAW,KAAK,IAAI;EACpB,QAAQ,CAAC;EACT,WAAW,CAAC;EACZ,OAAO;CACT;CAEA,MAAM,YAAY,YAAY;CAC9B,MAAM,YAAY,gBAAgB,QAAQ;CAC1C,OAAO,KAAK,sCAAsC;EAChD;EACA,iBAAiB,QAAQ,YAAY,YAAY;CACnD,CAAC;AACH","names":[],"sources":["../src/migration.ts"],"version":3,"file":"migration.js","sourceRoot":""}

package/dist/opencode.d.ts

@@ -1,9 +1,19 @@
-import type { Hooks, Plugin } from "@opencode-ai/plugin";
-import { type Logger } from "@vymalo/opencode-auth-core/lib";
+import { Plugin } from "@opencode/plugin/effect";
 import { type EnvSource, type ExporterFactories } from "@vymalo/opencode-core-otel";
+import { ProviderModelSyncEngine } from "@vymalo/opencode-provider-sync/lib";
+import { type Logger } from "./logging.js";
 import { type LightbridgeRuntimeFactory } from "./plugin.js";
-type OpenCodeConfig = Parameters<NonNullable<Hooks["config"]>>[0];
+/** Stable plugin id. v2 requires one and keys storage/registrations by it. */
+export declare const PLUGIN_ID = "vymalo.lightbridge";
+/** Test/embedder handle onto the `register` module's background engine. */
+export interface LightbridgeRegisterHandle {
+	/** Resolves once every queued engine build + warmup (and its reload) has finished. */
+	settled(): Promise<void>;
+	/** The current engine, or `undefined` before it is ready / after a collision stand-down. */
+	engine(): ProviderModelSyncEngine | undefined;
+}
 export interface LightbridgePluginFactoryOptions {
+	/** Override the logger (tests). Defaults to the host's Effect logger. */
 	logger?: Logger;
 	/** Shared-runtime HTTP client (auth-core `TokenRuntime`). Tests only. */
 	fetchImpl?: typeof fetch;
@@ -17,13 +27,15 @@ export interface LightbridgePluginFactoryOptions {
 	* neither module ever touches the network.
 	*/
 	runtimeFactory?: LightbridgeRuntimeFactory;
+	/** Observe the `register` module's background engine (tests). */
+	onRegister?: (handle: LightbridgeRegisterHandle) => void;
 	/** Injected environment; defaults to `process.env`. */
 	env?: EnvSource;
 	/** Substitute exporters (tests use in-memory ones). */
 	exporters?: ExporterFactories;
 	/** Injectable clock; defaults to `Date.now`. */
 	now?: () => number;
-	/** Skip `beforeExit`/`SIGINT`/`SIGTERM` registration (tests). */
+	/** Skip the `beforeExit`/`SIGINT`/`SIGTERM` exit handlers (tests). See ADR-0018. */
 	registerProcessHandlers?: boolean;
 	/** Override the resolved host metadata (hostname, version) for tests. */
 	hostInfo?: {
@@ -34,16 +46,22 @@ export interface LightbridgePluginFactoryOptions {
 	deferredTimeoutMs?: number;
 }
 /**
-* Create the `@vymalo/opencode-lightbridge` umbrella plugin (ADR-0012): ONE
-* shared `TokenRuntime`, built once from `auth`, drives both the gateway
-* bearer (`gateway`) and the OTEL export credential (`otel`) — each module
-* activates independently, and an `auth`-only config is a valid, inert
-* plugin. `config` runs both modules' config-time logic (host log level +
-* OTEL trace propagation); `chat.headers` is the gateway injector;
-* `event`/`chat.message`/`tool.execute.*`/`chat.params`/`permission.ask`/
-* `experimental.*` are the OTEL observers.
+* Create the `@vymalo/opencode-lightbridge` umbrella plugin (ADR-0012,
+* ADR-0017) for the OpenCode v2 plugin API (ADR-0019): ONE shared
+* `TokenRuntime`, built once from `auth`, drives both the gateway bearer
+* (`gateway`) and the OTEL export credential (`otel`) — each module activates
+* independently, and an `auth`-only config is a valid, inert plugin.
+*
+*  - `register`: `provider.transform` registers the provider and merges the
+*    discovered models and cached bearer; a queued background build runs the
+*    `ProviderModelSyncEngine` and calls `provider.reload()` (the transform is
+*    synchronous and cheap by contract — same shape as oauth2).
+*  - `gateway`: `session.hook("model.request")` injects the shared bearer and
+*    fails closed by dying the request when no bearer can be produced.
+*  - `otel`: `event.subscribe` + `prompt`/`context`/`tool`/`permission` hooks
+*    feed the recorder through `otel-adapter.ts`; `http.request` carries W3C
+*    trace context.
 */
-export declare function createLightbridgePlugin(factoryOptions?: LightbridgePluginFactoryOptions): Plugin;
-export declare const LightbridgePlugin: Plugin;
+export declare function createLightbridgePlugin(factoryOptions?: LightbridgePluginFactoryOptions): Plugin.Plugin;
+export declare const LightbridgePlugin: Plugin.Plugin;
 export default LightbridgePlugin;
-export type { OpenCodeConfig };