@route_33/opencode 0.1.2

package/dist/tui/index.d.ts

@@ -0,0 +1,5 @@
+import { TuiPluginModule } from '@opencode-ai/plugin/tui';
+
+declare const Route33TuiPlugin: TuiPluginModule;
+
+export { Route33TuiPlugin as default };

package/dist/tui/index.js

@@ -0,0 +1,476 @@
+// src/shared/env-api-key.ts
+var ENV_API_KEY = "ROUTE33_API_KEY";
+
+// src/shared/logger.ts
+var logger = {
+  info: (...args) => {
+    console.log("[route_33]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[route_33]", ...args);
+  },
+  error: (...args) => {
+    console.error("[route_33]", ...args);
+  }
+};
+
+// src/shared/resolve-cache-dir.ts
+import * as os from "os";
+import * as path from "path";
+
+// src/auth/auth-json.ts
+import * as fs from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var PROVIDER_ID = "route_33";
+function usable(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readAuthEntry(env = process.env) {
+  try {
+    const dataHome = usable(env.XDG_DATA_HOME) ?? path2.join(os2.homedir(), ".local", "share");
+    const authPath = path2.join(dataHome, "opencode", "auth.json");
+    const parsed = JSON.parse(fs.readFileSync(authPath, "utf8"));
+    if (!isRecord(parsed)) return {};
+    const entry = parsed[PROVIDER_ID];
+    if (!isRecord(entry) || entry.type !== "api") return {};
+    const result = {};
+    const key = usable(entry.key);
+    if (key !== void 0) result.key = key;
+    const baseURL = isRecord(entry.metadata) ? usable(entry.metadata.baseURL) : void 0;
+    if (baseURL !== void 0) result.baseURL = baseURL;
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// src/auth/workspace-key-file.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+var WORKSPACE_KEY_RELATIVE_PATH = path3.join(".opencode", "route33.key");
+var WORKSPACE_GITIGNORE_RELATIVE_PATH = path3.join(".opencode", ".gitignore");
+var GITIGNORE_ENTRIES = ["route33.key", "tui.json"];
+function usable2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readWorkspaceKey(worktree) {
+  if (worktree === void 0) return void 0;
+  try {
+    const raw = fs2.readFileSync(
+      path3.join(worktree, WORKSPACE_KEY_RELATIVE_PATH),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed) || parsed.type !== "api") return void 0;
+    return usable2(parsed.key);
+  } catch {
+    return void 0;
+  }
+}
+function ensureWorkspaceKeyGitignore(worktree) {
+  if (worktree === void 0 || worktree.trim() === "") return;
+  if (path3.resolve(worktree) === "/") return;
+  const gitignorePath = path3.join(worktree, WORKSPACE_GITIGNORE_RELATIVE_PATH);
+  try {
+    fs2.mkdirSync(path3.dirname(gitignorePath), { recursive: true });
+    let content = "";
+    try {
+      content = fs2.readFileSync(gitignorePath, "utf8");
+    } catch {
+    }
+    const lines = content.split("\n");
+    const missing = GITIGNORE_ENTRIES.filter(
+      (entry) => !lines.some(
+        (line) => line.trim() === entry || line.trim() === `/${entry}`
+      )
+    );
+    if (missing.length === 0) return;
+    const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    fs2.writeFileSync(gitignorePath, `${content}${prefix}${missing.join("\n")}
+`);
+  } catch (error) {
+    logger.warn(
+      `opencode-route33: could not update ${gitignorePath} (${String(error)}) \u2014 verify route33.key and tui.json are git-ignored before committing`
+    );
+  }
+}
+function writeWorkspaceKey(worktree, key) {
+  ensureWorkspaceKeyGitignore(worktree);
+  const filePath = path3.join(worktree, WORKSPACE_KEY_RELATIVE_PATH);
+  fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(
+    filePath,
+    `${JSON.stringify({ type: "api", key }, null, 2)}
+`,
+    { mode: 384 }
+  );
+}
+
+// src/auth/resolve-key.ts
+var UNRESOLVED_TEMPLATE_MARKER = "{env:";
+function usable3(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function keyFromConfig(cfg) {
+  const literal = usable3(cfg?.provider?.route_33?.options?.apiKey);
+  if (literal !== void 0 && !literal.includes(UNRESOLVED_TEMPLATE_MARKER))
+    return literal;
+  return void 0;
+}
+function resolveKey(cfg, env = process.env, worktree) {
+  return usable3(env[ENV_API_KEY]) ?? keyFromConfig(cfg) ?? readWorkspaceKey(worktree) ?? readAuthEntry(env).key;
+}
+
+// src/tui/key-prompt-ui.ts
+var KEY_SELECT_TITLE = "route33.ai project key";
+var KEY_SELECT_ENTER_LABEL = "Enter a project key";
+var KEY_SELECT_ENTER_DESCRIPTION = "Per workspace on purpose \u2014 one shared key would lose the per-project metrics";
+var KEY_SELECT_SKIP_LABEL = "Skip";
+var KEY_SELECT_SKIP_DESCRIPTION = "Ask again in 7 days";
+var KEY_SELECT_PLACEHOLDER = "No route33.ai key found for this workspace yet.";
+var KEY_PROMPT_TITLE = "Paste your route33.ai project key";
+var KEY_SAVED_MESSAGE = "route33.ai project key saved to .opencode/route33.key \u2014 live immediately, no restart needed.";
+var KEY_SAVE_FAILED_MESSAGE = "Could not save the key \u2014 will ask again next start.";
+var GLOBAL_SELECT_TITLE = "route33.ai global token";
+var GLOBAL_SELECT_ENTER_LABEL = "Enter a global token";
+var GLOBAL_SELECT_ENTER_DESCRIPTION = "One token for every workspace without its own project key";
+var GLOBAL_SELECT_SKIP_LABEL = "Skip";
+var GLOBAL_SELECT_SKIP_DESCRIPTION = "Ask again in 7 days";
+var GLOBAL_SELECT_PLACEHOLDER = "No project folder detected \u2014 save a token for all workspaces?";
+var GLOBAL_PROMPT_TITLE = "Paste your route33.ai global token";
+var GLOBAL_TOKEN_SAVED_MESSAGE = "route33.ai global token saved \u2014 applies to all workspaces without a project key.";
+var GLOBAL_TOKEN_SAVE_FAILED_MESSAGE = "Could not save the token \u2014 will ask again next start.";
+
+// src/tui/global-token-flow.ts
+async function runGlobalTokenPromptFlow({
+  ui,
+  globalStore,
+  dismissal,
+  now = Date.now
+}) {
+  if (await ui.askChoice() === "skip") {
+    dismissal.dismiss(now());
+    ui.close();
+    return "skipped";
+  }
+  while (true) {
+    const value = await ui.askKey();
+    if (value === void 0) {
+      dismissal.dismiss(now());
+      ui.close();
+      return "skipped";
+    }
+    const key = value.trim();
+    if (key.length === 0) continue;
+    try {
+      await globalStore.save(key);
+      ui.toastSuccess(GLOBAL_TOKEN_SAVED_MESSAGE);
+      ui.close();
+      return "saved";
+    } catch {
+      ui.toastError(GLOBAL_TOKEN_SAVE_FAILED_MESSAGE);
+      ui.close();
+      return "failed";
+    }
+  }
+}
+
+// src/tui/prompt-flow.ts
+async function runProjectKeyPromptFlow({
+  ui,
+  keyStore,
+  dismissal,
+  now = Date.now
+}) {
+  if (await ui.askChoice() === "skip") {
+    dismissal.dismiss(now());
+    ui.close();
+    return "skipped";
+  }
+  while (true) {
+    const value = await ui.askKey();
+    if (value === void 0) {
+      dismissal.dismiss(now());
+      ui.close();
+      return "skipped";
+    }
+    const key = value.trim();
+    if (key.length === 0) continue;
+    try {
+      await keyStore.save(key);
+      ui.toastSuccess(KEY_SAVED_MESSAGE);
+      ui.close();
+      return "saved";
+    } catch {
+      ui.toastError(KEY_SAVE_FAILED_MESSAGE);
+      ui.close();
+      return "failed";
+    }
+  }
+}
+
+// src/tui/activate.ts
+async function runActivation(deps) {
+  try {
+    if (!await deps.waitUntilReady()) return "state-unready";
+    if (deps.resolveKey() !== void 0) return "key-present";
+    if (deps.isGitWorkspace) {
+      if (deps.dismissal.isDismissed(Date.now())) return "dismissed";
+      return await runProjectKeyPromptFlow({
+        ui: deps.ui,
+        keyStore: deps.keyStore,
+        dismissal: deps.dismissal
+      });
+    }
+    if (deps.globalDismissal.isDismissed(Date.now())) return "dismissed";
+    return await runGlobalTokenPromptFlow({
+      ui: deps.globalUi,
+      globalStore: deps.globalStore,
+      dismissal: deps.globalDismissal
+    });
+  } catch {
+    return "state-unready";
+  }
+}
+
+// src/tui/dismissal-cooldown.ts
+var DISMISSAL_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1e3;
+function isWithinCooldown(dismissedAt, now) {
+  return dismissedAt !== void 0 && now - dismissedAt < DISMISSAL_COOLDOWN_MS;
+}
+
+// src/tui/dismissal-store.ts
+var PROJECT_KEY_PROMPT_DISMISSED_AT_KEY = "project-key-prompt.dismissed-at";
+var GLOBAL_TOKEN_PROMPT_DISMISSED_AT_KEY = "global-token-prompt.dismissed-at";
+function readDismissedAt(kv, key) {
+  try {
+    const value = kv.get(key);
+    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createDismissalStore(kv, key = PROJECT_KEY_PROMPT_DISMISSED_AT_KEY) {
+  return {
+    isDismissed: (now) => isWithinCooldown(readDismissedAt(kv, key), now),
+    dismiss: (now) => {
+      try {
+        kv.set(key, now);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/tui/git-workspace.ts
+import { existsSync } from "fs";
+import * as path4 from "path";
+function isInsideGitWorktree(startDir) {
+  try {
+    let dir = path4.resolve(startDir);
+    for (; ; ) {
+      if (existsSync(path4.join(dir, ".git"))) return true;
+      const parent = path4.dirname(dir);
+      if (parent === dir) return false;
+      dir = parent;
+    }
+  } catch {
+    return false;
+  }
+}
+
+// src/tui/key-prompt-copy.ts
+var PROJECT_COPY = {
+  selectTitle: KEY_SELECT_TITLE,
+  enterLabel: KEY_SELECT_ENTER_LABEL,
+  enterDescription: KEY_SELECT_ENTER_DESCRIPTION,
+  skipLabel: KEY_SELECT_SKIP_LABEL,
+  skipDescription: KEY_SELECT_SKIP_DESCRIPTION,
+  selectPlaceholder: KEY_SELECT_PLACEHOLDER,
+  promptTitle: KEY_PROMPT_TITLE
+};
+var GLOBAL_COPY = {
+  selectTitle: GLOBAL_SELECT_TITLE,
+  enterLabel: GLOBAL_SELECT_ENTER_LABEL,
+  enterDescription: GLOBAL_SELECT_ENTER_DESCRIPTION,
+  skipLabel: GLOBAL_SELECT_SKIP_LABEL,
+  skipDescription: GLOBAL_SELECT_SKIP_DESCRIPTION,
+  selectPlaceholder: GLOBAL_SELECT_PLACEHOLDER,
+  promptTitle: GLOBAL_PROMPT_TITLE
+};
+
+// src/tui/tui-api-adapter.ts
+var READY_POLL_INTERVAL_MS = 100;
+function askChoice(api, copy) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const settle = (choice) => {
+      if (settled) return;
+      settled = true;
+      resolve3(choice);
+    };
+    api.ui.dialog.replace(
+      () => api.ui.DialogSelect({
+        title: copy.selectTitle,
+        placeholder: copy.selectPlaceholder,
+        options: [
+          {
+            title: copy.enterLabel,
+            value: "enter",
+            description: copy.enterDescription
+          },
+          {
+            title: copy.skipLabel,
+            value: "skip",
+            description: copy.skipDescription
+          }
+        ],
+        onSelect: (option) => {
+          settle(option.value === "enter" ? "enter" : "skip");
+        }
+      }),
+      () => {
+        settle("skip");
+      }
+    );
+  });
+}
+function askKey(api, copy) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve3(value);
+    };
+    api.ui.dialog.replace(
+      () => api.ui.DialogPrompt({
+        title: copy.promptTitle,
+        // No description prop: the opencode TUI renders it as a JSX element,
+        // and a bare string crashes the renderer ("orphan text"). The
+        // informational line lives on the DialogSelect placeholder instead.
+        onConfirm: (value) => {
+          settle(value);
+        },
+        onCancel: () => {
+          settle(void 0);
+        }
+      }),
+      () => {
+        settle(void 0);
+      }
+    );
+  });
+}
+function waitUntilReady(api) {
+  return new Promise((resolve3) => {
+    if (api.state.ready) {
+      resolve3(true);
+      return;
+    }
+    const timer = setInterval(() => {
+      if (api.lifecycle.signal.aborted) {
+        clearInterval(timer);
+        resolve3(false);
+        return;
+      }
+      if (api.state.ready) {
+        clearInterval(timer);
+        resolve3(true);
+      }
+    }, READY_POLL_INTERVAL_MS);
+  });
+}
+function createUi(api, copy) {
+  return {
+    askChoice: () => askChoice(api, copy),
+    askKey: () => askKey(api, copy),
+    toastSuccess: (message) => {
+      api.ui.toast({ variant: "success", message });
+    },
+    toastError: (message) => {
+      api.ui.toast({ variant: "error", message });
+    },
+    close: () => {
+      api.ui.dialog.clear();
+    }
+  };
+}
+function createGlobalStore(api) {
+  return {
+    // The sdk client runs with ThrowOnError=false, so a failed auth.set
+    // RESOLVES `{ data, error }` instead of rejecting — inspect the result
+    // and throw on a carried error so the flow can toast + retry.
+    save: async (key) => {
+      const result = await api.client.auth.set({
+        providerID: "route_33",
+        auth: { type: "api", key }
+      });
+      if (result != null && typeof result === "object" && "error" in result && result.error != null) {
+        throw new Error("route_33 auth.set failed");
+      }
+    }
+  };
+}
+function createTuiAdapter(api) {
+  return {
+    ui: createUi(api, PROJECT_COPY),
+    globalUi: createUi(api, GLOBAL_COPY),
+    keyStore: {
+      // The workspace file is the only store needed: the live-auth fetch in
+      // the provider options re-resolves it per request, so the key applies
+      // immediately — even in the session that is open right now.
+      save: async (key) => {
+        writeWorkspaceKey(process.cwd(), key);
+      }
+    },
+    globalStore: createGlobalStore(api),
+    kv: api.kv,
+    waitUntilReady: () => waitUntilReady(api)
+  };
+}
+
+// src/tui/index.ts
+async function activate(api) {
+  const { ui, keyStore, globalUi, globalStore, kv, waitUntilReady: waitUntilReady2 } = createTuiAdapter(api);
+  await runActivation({
+    ui,
+    keyStore,
+    dismissal: createDismissalStore(kv),
+    globalUi,
+    globalStore,
+    globalDismissal: createDismissalStore(
+      kv,
+      GLOBAL_TOKEN_PROMPT_DISMISSED_AT_KEY
+    ),
+    resolveKey: () => resolveKey(api.state.config, process.env, process.cwd()),
+    // api.state.vcs populates asynchronously and arrives too late in real
+    // workspaces; a direct .git walk-up from the launch cwd is deterministic.
+    isGitWorkspace: isInsideGitWorktree(process.cwd()),
+    waitUntilReady: waitUntilReady2
+  });
+}
+var Route33TuiPlugin = {
+  id: "route33",
+  tui: async (api) => {
+    if (process.env.ROUTE33_TUI_PROMPT === "0") return;
+    void activate(api).catch(() => {
+    });
+  }
+};
+var tui_default = Route33TuiPlugin;
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@route_33/opencode",
+  "version": "0.1.2",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "opencode provider plugin for the route33.ai AI gateway — key-scoped model discovery, cost/limit enrichment, auth, and the key-setup wizard.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cronos-AI-Lab/harness-bench.git",
+    "directory": "packages/integrations/opencode-route33"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "route33"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui/index.d.ts",
+      "import": "./dist/tui/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.17.0 <2.0.0"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.12",
+    "@types/node": "^22.10.7",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepack": "bun run build",
+    "bundle": "tsup",
+    "bundle:watch": "tsup --watch",
+    "verify:bundle": "bun run scripts/verify-bundle.ts",
+    "test": "vitest run && bun run verify:bundle",
+    "typecheck": "tsc --noEmit"
+  }
+}