@albinocrabs/o-switcher 0.1.0 → 0.2.0

package/dist/plugin.d.cts

@@ -10,7 +10,7 @@ export { PluginInput } from '@opencode-ai/plugin';
  * - tool definitions: 7 operator commands (list, pause, resume, drain, disable, inspect, reload)
  *
  * Install via opencode.json:
- *   "plugin": ["@apolenkov/o-switcher@latest"]
+ *   "plugin": ["@albinocrabs/o-switcher@latest"]
  *
  * Or local dev:
  *   "plugin": ["/path/to/o-switcher"]

package/dist/plugin.d.ts

@@ -10,7 +10,7 @@ export { PluginInput } from '@opencode-ai/plugin';
  * - tool definitions: 7 operator commands (list, pause, resume, drain, disable, inspect, reload)
  *
  * Install via opencode.json:
- *   "plugin": ["@apolenkov/o-switcher@latest"]
+ *   "plugin": ["@albinocrabs/o-switcher@latest"]
  *
  * Or local dev:
  *   "plugin": ["/path/to/o-switcher"]

package/dist/plugin.js

@@ -1,20 +1,42 @@
-import {
-  createAuditLogger,
-  createAuthWatcher,
-  createCircuitBreaker,
-  createConcurrencyTracker,
-  createCooldownManager,
-  createLogSubscriber,
-  createProfileTools,
-  createRegistry,
-  createRequestTraceBuffer,
-  createRoutingEventBus,
-  discoverTargets,
-  discoverTargetsFromProfiles,
-  generateCorrelationId,
-  loadProfiles,
-  validateConfig
-} from "./chunk-BTDKGS7P.js";
+import { createAuditLogger, createOperatorTools, createProfileTools, generateCorrelationId, loadProfiles, discoverTargetsFromProfiles, discoverTargets, createAuthWatcher, validateConfig, createRegistry, createRoutingEventBus, createCircuitBreaker, createConcurrencyTracker, createCooldownManager, createRequestTraceBuffer, createLogSubscriber } from './chunk-7ITX5623.js';
+import { mkdir, writeFile, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+var STATE_DIR = join(homedir(), ".local", "share", "o-switcher");
+var STATE_FILE = join(STATE_DIR, "tui-state.json");
+var STATE_TMP = join(STATE_DIR, "tui-state.json.tmp");
+var writeStateAtomic = async (state) => {
+  await mkdir(dirname(STATE_FILE), { recursive: true });
+  const json = JSON.stringify(state);
+  await writeFile(STATE_TMP, json, "utf8");
+  await rename(STATE_TMP, STATE_FILE);
+};
+var createStateWriter = (debounceMs = 500) => {
+  let pending;
+  let timer;
+  let writePromise = Promise.resolve();
+  const doWrite = () => {
+    if (!pending) return;
+    const snapshot = pending;
+    pending = void 0;
+    writePromise = writeStateAtomic(snapshot).catch(() => void 0);
+  };
+  const write = (state) => {
+    pending = state;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(doWrite, debounceMs);
+  };
+  const flush = async () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    doWrite();
+    await writePromise;
+  };
+  return { write, flush };
+};
 
 // src/plugin.ts
 var initializeSwitcher = (rawConfig) => {
@@ -47,10 +69,52 @@ var initializeSwitcher = (rawConfig) => {
   };
   return { config, registry, logger, circuitBreakers, concurrency, cooldownManager, operatorDeps };
 };
+var snapshotState = (state) => {
+  if (!state.registry) return void 0;
+  const allTargets = state.registry.getAllTargets();
+  const activeTarget = allTargets.find((t) => t.state === "Active" && t.enabled);
+  const targets = allTargets.map((t) => ({
+    target_id: t.target_id,
+    provider_id: t.provider_id,
+    profile: t.profile,
+    state: t.state,
+    health_score: t.health_score,
+    latency_ema_ms: t.latency_ema_ms,
+    enabled: t.enabled
+  }));
+  return {
+    version: 1,
+    updated_at: Date.now(),
+    active_target_id: activeTarget?.target_id,
+    targets
+  };
+};
 var server = async (_input) => {
   const logger = createAuditLogger({ level: "info" });
   logger.info("O-Switcher plugin initializing");
   const state = {};
+  const stateWriter = createStateWriter();
+  const publishTuiState = () => {
+    const snapshot = snapshotState(state);
+    if (snapshot) stateWriter.write(snapshot);
+  };
+  const lazyOperatorDeps = {
+    get registry() {
+      return state.operatorDeps.registry;
+    },
+    get circuitBreakers() {
+      return state.operatorDeps.circuitBreakers;
+    },
+    get configRef() {
+      return state.operatorDeps.configRef;
+    },
+    get logger() {
+      return state.operatorDeps.logger;
+    },
+    get traceBuffer() {
+      return state.operatorDeps.traceBuffer;
+    }
+  };
   const hooks = {
     /**
      * Config hook: initialize O-Switcher when OpenCode config is loaded.
@@ -97,10 +161,8 @@ var server = async (_input) => {
       try {
         const initialized = initializeSwitcher(rawConfig);
         Object.assign(state, initialized);
-        logger.info(
-          { targets: state.registry?.getAllTargets().length },
-          "O-Switcher initialized"
-        );
+        logger.info({ targets: state.registry?.getAllTargets().length }, "O-Switcher initialized");
+        publishTuiState();
         state.authWatcher = createAuthWatcher({ logger });
         await state.authWatcher.start();
         logger.info("Auth watcher started");
@@ -120,9 +182,7 @@ var server = async (_input) => {
       const targets = state.registry.getAllTargets();
       const providerId = input.provider?.info?.id ?? input.provider?.info?.name ?? input.model?.providerID ?? void 0;
       if (!providerId) return;
-      const matchingTargets = targets.filter(
-        (t) => t.provider_id === providerId && t.enabled
-      );
+      const matchingTargets = targets.filter((t) => t.provider_id === providerId && t.enabled);
       if (matchingTargets.length === 0) return;
       const activeTarget = matchingTargets.reduce(
         (best, t) => t.health_score > best.health_score ? t : best
@@ -135,7 +195,11 @@ var server = async (_input) => {
           output.maxOutputTokens = Math.min(output.maxOutputTokens, 4096);
         }
         state.logger?.info(
-          { request_id: requestId, target_id: activeTarget.target_id, health: activeTarget.health_score },
+          {
+            request_id: requestId,
+            target_id: activeTarget.target_id,
+            health: activeTarget.health_score
+          },
           "Adjusted params for degraded target"
         );
       }
@@ -153,21 +217,24 @@ var server = async (_input) => {
         if (error && "providerID" in error) {
           const providerId = error.providerID;
           if (providerId) {
-            const matchingTargets = state.registry.getAllTargets().filter(
-              (t) => t.provider_id === providerId
-            );
+            const matchingTargets = state.registry.getAllTargets().filter((t) => t.provider_id === providerId);
             if (matchingTargets.length === 0) return;
             const target = matchingTargets.length === 1 ? matchingTargets[0] : matchingTargets.reduce(
               (worst, t) => t.health_score < worst.health_score ? t : worst
             );
             if (matchingTargets.length > 1) {
               state.logger?.warn(
-                { provider_id: providerId, attributed_target: target.target_id, profile_count: matchingTargets.length },
+                {
+                  provider_id: providerId,
+                  attributed_target: target.target_id,
+                  profile_count: matchingTargets.length
+                },
                 "Multiple profiles for provider \u2014 error attributed to worst-health target (plugin-only mode limitation)"
               );
             }
             state.registry.recordObservation(target.target_id, 0);
             state.circuitBreakers?.get(target.target_id)?.recordFailure();
+            publishTuiState();
             state.logger?.info(
               { target_id: target.target_id, event_type: event.type },
               "Recorded failure from session event"
@@ -177,7 +244,8 @@ var server = async (_input) => {
       }
     },
     tool: {
-      ...createProfileTools()
+      ...createProfileTools(),
+      ...createOperatorTools(lazyOperatorDeps)
     }
   };
   return hooks;
@@ -187,8 +255,5 @@ var pluginModule = {
   server
 };
 var plugin_default = pluginModule;
-export {
-  plugin_default as default,
-  server
-};
-//# sourceMappingURL=plugin.js.map
+
+export { plugin_default as default, server };

package/package.json

@@ -1,42 +1,73 @@
 {
   "name": "@albinocrabs/o-switcher",
-  "version": "0.1.0",
-  "description": "Routing and execution resilience layer for OpenCode",
+  "version": "0.2.0",
+  "description": "Seamless OpenRouter profile rotation for OpenCode — buy multiple subscriptions, use as one pool",
   "type": "module",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/apolenkov/o-switcher.git"
   },
   "keywords": [
     "opencode",
+    "openrouter",
     "llm",
-    "routing",
+    "profile-rotation",
+    "quota-pool",
     "resilience",
-    "circuit-breaker",
     "failover",
     "retry"
   ],
+  "files": [
+    "dist",
+    "src/tui.tsx",
+    "src/state-bridge.ts",
+    "src/registry/types.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "main": "dist/plugin.js",
   "module": "dist/plugin.js",
   "types": "dist/plugin.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/plugin.js",
-      "require": "./dist/plugin.cjs",
-      "types": "./dist/plugin.d.ts"
+      "import": {
+        "types": "./dist/plugin.d.ts",
+        "default": "./dist/plugin.js"
+      },
+      "require": {
+        "types": "./dist/plugin.d.cts",
+        "default": "./dist/plugin.cjs"
+      }
     },
     "./api": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
-    }
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./tui": "./src/tui.tsx"
   },
   "scripts": {
     "build": "tsup",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "lint:pkg": "publint && attw --pack . --ignore-rules no-resolution --ignore-rules cjs-resolves-to-esm",
+    "format:check": "prettier --check \"src/**/*.ts\" \"*.config.*\" \"*.json\" \".prettierrc\"",
+    "format": "prettier --write \"src/**/*.ts\" \"*.config.*\" \"*.json\" \".prettierrc\"",
+    "test:coverage": "vitest run --coverage",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "npm run build && npm run lint:pkg && changeset publish",
+    "prepublishOnly": "npm run lint && npm run build && npm run lint:pkg"
   },
   "dependencies": {
     "cockatiel": "^3.2.1",
@@ -46,12 +77,23 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@eslint/js": "^10.0.1",
     "@opencode-ai/plugin": "^1.4.3",
+    "@opentui/core": "^0.1.97",
+    "@opentui/solid": "^0.1.97",
     "@tsconfig/node20": "^20.1.9",
-    "@types/node": "^22",
+    "@types/node": "^25",
+    "@vitest/coverage-v8": "^4.1.4",
+    "eslint": "^10.2.0",
     "pino-pretty": "^13",
+    "prettier": "^3.8.2",
+    "publint": "^0.3.18",
     "tsup": "^8.5.1",
     "typescript": "^5.4.0",
+    "typescript-eslint": "^8.58.1",
     "vitest": "^4.1.4"
   },
   "engines": {

package/src/registry/types.ts

@@ -0,0 +1,65 @@
+/**
+ * Target registry types.
+ *
+ * Defines the TargetEntry interface with all FOUN-02 fields,
+ * the TargetState enum, and RegistrySnapshot for read-only access.
+ *
+ * SECURITY: No credential fields (api_key, token, secret, password).
+ * provider_id is a pointer to OpenCode's auth store (D-13, SECU-01, SECU-02).
+ */
+
+/**
+ * All valid states for a target in the registry.
+ *
+ * - Active: healthy and available for routing
+ * - CoolingDown: temporarily unavailable after transient failure
+ * - ReauthRequired: authentication failure, awaiting credential refresh
+ * - PolicyBlocked: blocked by policy (403), no retry
+ * - CircuitOpen: circuit breaker tripped, no requests allowed
+ * - CircuitHalfOpen: circuit breaker probing with limited requests
+ * - Draining: operator-initiated drain, no new requests
+ * - Disabled: operator-disabled or config-disabled
+ */
+export const TARGET_STATES = [
+  'Active',
+  'CoolingDown',
+  'ReauthRequired',
+  'PolicyBlocked',
+  'CircuitOpen',
+  'CircuitHalfOpen',
+  'Draining',
+  'Disabled',
+] as const;
+
+/** Target state type. */
+export type TargetState = (typeof TARGET_STATES)[number];
+
+/**
+ * A single target entry in the registry.
+ *
+ * Contains all fields per FOUN-02: target_id, provider_id, endpoint_id,
+ * capabilities, enabled, state, health_score, cooldown_until, latency_ema_ms,
+ * failure_score, operator_priority, policy_tags.
+ *
+ * NO credential fields -- provider_id maps to OpenCode's credential store.
+ */
+export interface TargetEntry {
+  readonly target_id: string;
+  readonly provider_id: string;
+  readonly profile: string | undefined;
+  readonly endpoint_id: string | undefined;
+  readonly capabilities: readonly string[];
+  readonly enabled: boolean;
+  readonly state: TargetState;
+  readonly health_score: number;
+  readonly cooldown_until: number | null;
+  readonly latency_ema_ms: number;
+  readonly failure_score: number;
+  readonly operator_priority: number;
+  readonly policy_tags: readonly string[];
+}
+
+/** Read-only snapshot of the entire registry. */
+export interface RegistrySnapshot {
+  readonly targets: ReadonlyArray<Readonly<TargetEntry>>;
+}

package/src/state-bridge.ts

@@ -0,0 +1,119 @@
+/**
+ * State bridge between server plugin and TUI plugin.
+ *
+ * Server and TUI plugins run in separate contexts (Node.js vs Bun/Solid).
+ * This module provides a file-based state bridge:
+ *  - Server writes a JSON snapshot after each meaningful state change
+ *  - TUI polls the file to render current state
+ *
+ * Writes are atomic (tmp → rename) and debounced to avoid thrashing.
+ * Reads tolerate missing/corrupt files gracefully.
+ */
+
+import { writeFile, rename, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import type { TargetState } from './registry/types.js';
+
+// ── Shared types ──────────────────────────────────────────────────
+
+/** Compact target summary for TUI display. */
+export interface TuiTargetSummary {
+  readonly target_id: string;
+  readonly provider_id: string;
+  readonly profile: string | undefined;
+  readonly state: TargetState;
+  readonly health_score: number;
+  readonly latency_ema_ms: number;
+  readonly enabled: boolean;
+}
+
+/** Root state file structure written by server plugin. */
+export interface TuiStateFile {
+  readonly version: 1;
+  readonly updated_at: number;
+  readonly active_target_id: string | undefined;
+  readonly targets: readonly TuiTargetSummary[];
+}
+
+// ── File path ─────────────────────────────────────────────────────
+
+const STATE_DIR = join(homedir(), '.local', 'share', 'o-switcher');
+const STATE_FILE = join(STATE_DIR, 'tui-state.json');
+const STATE_TMP = join(STATE_DIR, 'tui-state.json.tmp');
+
+/** Resolved path to the TUI state file. Exposed for tests and TUI reader. */
+export const TUI_STATE_PATH = STATE_FILE;
+
+// ── Writer (server side) ──────────────────────────────────────────
+
+/**
+ * Write state atomically: write to .tmp, then rename.
+ * Ensures TUI never reads a partial file.
+ */
+const writeStateAtomic = async (state: TuiStateFile): Promise<void> => {
+  await mkdir(dirname(STATE_FILE), { recursive: true });
+  const json = JSON.stringify(state);
+  await writeFile(STATE_TMP, json, 'utf8');
+  await rename(STATE_TMP, STATE_FILE);
+};
+
+/**
+ * Create a debounced state writer.
+ *
+ * Collapses rapid state changes into a single file write.
+ * Returns a `write(state)` function and a `flush()` for shutdown.
+ */
+export const createStateWriter = (debounceMs = 500): {
+  write: (state: TuiStateFile) => void;
+  flush: () => Promise<void>;
+} => {
+  let pending: TuiStateFile | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let writePromise: Promise<void> = Promise.resolve();
+
+  const doWrite = (): void => {
+    if (!pending) return;
+    const snapshot = pending;
+    pending = undefined;
+    writePromise = writeStateAtomic(snapshot).catch(() => undefined);
+  };
+
+  const write = (state: TuiStateFile): void => {
+    pending = state;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(doWrite, debounceMs);
+  };
+
+  const flush = async (): Promise<void> => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+    doWrite();
+    await writePromise;
+  };
+
+  return { write, flush };
+};
+
+// ── Reader (TUI side) ─────────────────────────────────────────────
+
+/**
+ * Read the TUI state file. Returns undefined if missing or corrupt.
+ *
+ * Uses dynamic import for readFile to avoid bundling it into the server
+ * plugin (where only the writer is needed). This eliminates tree-shaking
+ * warnings from tsup.
+ */
+export const readTuiState = async (): Promise<TuiStateFile | undefined> => {
+  try {
+    const { readFile } = await import('node:fs/promises');
+    const raw = await readFile(STATE_FILE, 'utf8');
+    const parsed = JSON.parse(raw) as TuiStateFile;
+    if (parsed.version !== 1) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+};