@thelioo/opencode-balancer 0.1.6 → 0.2.0

package/dist/tui/tui.tsx

@@ -1,142 +1,224 @@
 /** @jsxImportSource @opentui/solid */
 
-import type { TuiPlugin, TuiPluginModule, TuiRouteCurrent } from "@opencode-ai/plugin/tui";
+import type {
+	TuiPlugin,
+	TuiPluginModule,
+	TuiRouteCurrent,
+} from "@opencode-ai/plugin/tui";
 import { createComponent } from "solid-js";
-import { setProviderModel } from "../core/priority";
+import { getSelectedAccount, getSelectedModel } from "../core/accounts";
+import { getBalancingEnabled, setProviderModel } from "../core/priority";
 import { activateAccount, removeAccountFromTui } from "./actions";
 import { createTuiBalancerBarSync } from "./balancer-bar-sync";
 import { openNativeConnect } from "./connect";
+import { createNativeModelApplier } from "./native-model-apply";
+import { providerModelOptions } from "./provider-models";
+import { createSelectedAccountBarSync } from "./selected-account-bar-sync";
 import { createBalancerTuiState } from "./state";
 import { createUsageAutoRefresh } from "./usage-auto-refresh";
 
 type DashboardModule = typeof import("./components/dashboard");
 type PriorityScreenModule = typeof import("./components/priority-screen");
-type ProviderModelDialogModule = typeof import("./components/provider-model-dialog");
+type ProviderModelDialogModule =
+	typeof import("./components/provider-model-dialog");
 type RenameDialogModule = typeof import("./components/rename-dialog");
 type SidebarModule = typeof import("./components/sidebar");
 type StatusIndicatorModule = typeof import("./components/status-indicator");
 
 function inferProviderID(session: unknown) {
-    const providerID = (session as { model?: { providerID?: unknown } } | undefined)?.model?.providerID;
-    return typeof providerID === "string" && providerID.length > 0 ? providerID : undefined;
+	const providerID = (
+		session as { model?: { providerID?: unknown } } | undefined
+	)?.model?.providerID;
+	return typeof providerID === "string" && providerID.length > 0
+		? providerID
+		: undefined;
 }
 
 function copyRoute(route: TuiRouteCurrent): TuiRouteCurrent {
-    return "params" in route && route.params
-        ? { name: route.name, params: { ...route.params } }
-        : { name: route.name };
+	return "params" in route && route.params
+		? { name: route.name, params: { ...route.params } }
+		: { name: route.name };
 }
 
 const tui: TuiPlugin = async (api) => {
-    await import("@opentui/solid/runtime-plugin" + "-support");
-
-    const [dashboardModule, priorityScreenModule, providerModelDialogModule, renameDialogModule, sidebarModule, statusIndicatorModule] = await Promise.all([
-        import("./components/dashboard" + ".tsx") as Promise<DashboardModule>,
-        import("./components/priority-screen" + ".tsx") as Promise<PriorityScreenModule>,
-        import("./components/provider-model-dialog" + ".tsx") as Promise<ProviderModelDialogModule>,
-        import("./components/rename-dialog" + ".tsx") as Promise<RenameDialogModule>,
-        import("./components/sidebar" + ".tsx") as Promise<SidebarModule>,
-        import("./components/status-indicator" + ".tsx") as Promise<StatusIndicatorModule>,
-    ]);
-    const state = createBalancerTuiState();
-    const usageAutoRefresh = createUsageAutoRefresh(api, state);
-    const balancerBarSync = createTuiBalancerBarSync(api, state);
-    let dashboardReturnRoute: TuiRouteCurrent | undefined;
-
-    api.lifecycle.onDispose(() => {
-        usageAutoRefresh.dispose();
-        state.dispose();
-    });
-
-    const openDashboard = () => {
-        if (api.route.current.name !== "balancer.dashboard") dashboardReturnRoute = copyRoute(api.route.current);
-        api.route.navigate("balancer.dashboard");
-    };
-
-    const openPriority = () => {
-        api.route.navigate("balancer.priority");
-    };
-
-    const backFromDashboard = () => {
-        const route = dashboardReturnRoute;
-        dashboardReturnRoute = undefined;
-        if (route) api.route.navigate(route.name, "params" in route ? route.params : undefined);
-        else api.route.navigate("home");
-    };
-
-    const unregisterDashboard = api.route.register([
-        {
-            name: "balancer.dashboard",
-            render: () =>
-                createComponent(dashboardModule.Dashboard, {
-                    api,
-                    state,
-                    onBack: backFromDashboard,
-                    openPriority,
-                    openConnect: () => openNativeConnect({ ...api, db: state.db }),
-                    renameAccount: (providerID, alias) => renameDialogModule.openRenameDialog(api, state, providerID, alias),
-                    removeAccount: (providerID, alias) => removeAccountFromTui(api, state, providerID, alias),
-                }),
-        },
-        {
-            name: "balancer.priority",
-            render: () =>
-                createComponent(priorityScreenModule.PriorityScreen, {
-                    api,
-                    state,
-                    onBack: () => api.route.navigate("balancer.dashboard"),
-                    openModelPicker: (providerID) =>
-                        providerModelDialogModule.openProviderModelDialog(api, state, providerID, {
-                            onSelected: (model) => setProviderModel(state.db, model.providerID, model.modelID),
-                        }),
-                }),
-        },
-    ]);
-    api.lifecycle.onDispose(unregisterDashboard);
-
-    const unregisterKeymap = api.keymap.registerLayer({
-        commands: [
-            {
-                name: "balancer.dashboard.open",
-                title: "Open Balancer Dashboard",
-                category: "Plugin",
-                namespace: "palette",
-                slashName: "balancer",
-                run() {
-                    openDashboard();
-                },
-            },
-        ],
-        bindings: [{ key: "ctrl+b", cmd: "balancer.dashboard.open" }],
-    });
-    api.lifecycle.onDispose(unregisterKeymap);
-
-    api.slots.register({
-        slots: {
-            session_prompt_right(_ctx, value) {
-                void usageAutoRefresh.refreshForPrompt();
-                void balancerBarSync.maybeSync();
-                return createComponent(statusIndicatorModule.BalancerStatusIndicator, {
-                    api,
-                    state,
-                    providerID: () => inferProviderID(api.state.session.get(value.session_id)),
-                });
-            },
-            sidebar_content(_ctx, value) {
-                return createComponent(sidebarModule.BalancerSidebar, {
-                    api,
-                    state,
-                    openDashboard,
-                    activateAccount: (providerID, alias) =>
-                        activateAccount(api, state, providerID, alias, {
-                            sessionProviderID: inferProviderID(api.state.session.get(value.session_id)),
-                            openProviderModelPicker: (targetProviderID) =>
-                                providerModelDialogModule.openProviderModelDialog(api, state, targetProviderID),
-                        }),
-                });
-            },
-        },
-    });
+	await import("@opentui/solid/runtime-plugin" + "-support");
+
+	const [
+		dashboardModule,
+		priorityScreenModule,
+		providerModelDialogModule,
+		renameDialogModule,
+		sidebarModule,
+		statusIndicatorModule,
+	] = await Promise.all([
+		import("./components/dashboard" + ".tsx") as Promise<DashboardModule>,
+		import(
+			"./components/priority-screen" + ".tsx"
+		) as Promise<PriorityScreenModule>,
+		import(
+			"./components/provider-model-dialog" + ".tsx"
+		) as Promise<ProviderModelDialogModule>,
+		import(
+			"./components/rename-dialog" + ".tsx"
+		) as Promise<RenameDialogModule>,
+		import("./components/sidebar" + ".tsx") as Promise<SidebarModule>,
+		import(
+			"./components/status-indicator" + ".tsx"
+		) as Promise<StatusIndicatorModule>,
+	]);
+	const state = createBalancerTuiState();
+	const usageAutoRefresh = createUsageAutoRefresh(api, state);
+	const balancerBarSync = createTuiBalancerBarSync(api, state);
+	const nativeModelApplier = createNativeModelApplier(api);
+	let dashboardReturnRoute: TuiRouteCurrent | undefined;
+	let nativeProviderID: string | undefined;
+	let sessionProviderID: string | undefined;
+
+	const applyNativeProviderModel = async (providerID: string) => {
+		const modelOptions = providerModelOptions(api.state.provider, providerID);
+		const selected = getSelectedModel(state.db, providerID);
+		const option =
+			modelOptions.find((item) => item.modelID === selected?.modelID) ??
+			modelOptions[0];
+		if (!option) return false;
+		return nativeModelApplier(
+			{ modelID: option.modelID, providerID: option.providerID },
+			option.title,
+		);
+	};
+
+	const applyNativeProviderModelAndTrack = async (providerID: string) => {
+		const applied = await applyNativeProviderModel(providerID);
+		if (applied) nativeProviderID = providerID;
+		return applied;
+	};
+
+	const selectedAccountBarSync = createSelectedAccountBarSync({
+		applyProvider: applyNativeProviderModelAndTrack,
+		currentProvider: () => nativeProviderID ?? sessionProviderID,
+		dialogOpen: () => api.ui.dialog.open,
+		selectedProvider: () =>
+			getBalancingEnabled(state.db)
+				? undefined
+				: getSelectedAccount(state.db)?.providerID,
+	});
+
+	api.lifecycle.onDispose(() => {
+		usageAutoRefresh.dispose();
+		state.dispose();
+	});
+
+	const openDashboard = () => {
+		if (api.route.current.name !== "balancer.dashboard")
+			dashboardReturnRoute = copyRoute(api.route.current);
+		api.route.navigate("balancer.dashboard");
+	};
+
+	const openPriority = () => {
+		api.route.navigate("balancer.priority");
+	};
+
+	const backFromDashboard = () => {
+		const route = dashboardReturnRoute;
+		dashboardReturnRoute = undefined;
+		if (route)
+			api.route.navigate(
+				route.name,
+				"params" in route ? route.params : undefined,
+			);
+		else api.route.navigate("home");
+	};
+
+	const unregisterDashboard = api.route.register([
+		{
+			name: "balancer.dashboard",
+			render: () =>
+				createComponent(dashboardModule.Dashboard, {
+					api,
+					onBack: backFromDashboard,
+					openConnect: () => openNativeConnect({ ...api, db: state.db }),
+					openPriority,
+					removeAccount: (providerID, alias) =>
+						removeAccountFromTui(api, state, providerID, alias),
+					renameAccount: (providerID, alias) =>
+						renameDialogModule.openRenameDialog(api, state, providerID, alias),
+					state,
+				}),
+		},
+		{
+			name: "balancer.priority",
+			render: () =>
+				createComponent(priorityScreenModule.PriorityScreen, {
+					api,
+					onBack: () => api.route.navigate("balancer.dashboard"),
+					openModelPicker: (providerID, onComplete) =>
+						providerModelDialogModule.openProviderModelDialog(
+							api,
+							state,
+							providerID,
+							{
+								applyNativeSelection: false,
+								onComplete,
+								onSelected: (model) =>
+									setProviderModel(state.db, model.providerID, model.modelID),
+							},
+						),
+					state,
+				}),
+		},
+	]);
+	api.lifecycle.onDispose(unregisterDashboard);
+
+	const unregisterKeymap = api.keymap.registerLayer({
+		bindings: [{ cmd: "balancer.dashboard.open", key: "ctrl+b" }],
+		commands: [
+			{
+				category: "Plugin",
+				name: "balancer.dashboard.open",
+				namespace: "palette",
+				run() {
+					openDashboard();
+				},
+				slashName: "balancer",
+				title: "Open Balancer Dashboard",
+			},
+		],
+	});
+	api.lifecycle.onDispose(unregisterKeymap);
+
+	api.slots.register({
+		slots: {
+			session_prompt_right(_ctx, value) {
+				sessionProviderID = inferProviderID(
+					api.state.session.get(value.session_id),
+				);
+				void usageAutoRefresh.refreshForPrompt();
+				void selectedAccountBarSync.maybeSync();
+				void balancerBarSync.maybeSync();
+				return createComponent(statusIndicatorModule.BalancerStatusIndicator, {
+					api,
+					providerID: () =>
+						inferProviderID(api.state.session.get(value.session_id)),
+					state,
+				});
+			},
+			sidebar_content(_ctx, value) {
+				return createComponent(sidebarModule.BalancerSidebar, {
+					activateAccount: (providerID, alias) => {
+						return activateAccount(api, state, providerID, alias, {
+							applyNativeProviderModel: applyNativeProviderModelAndTrack,
+							sessionProviderID:
+								nativeProviderID ??
+								inferProviderID(api.state.session.get(value.session_id)),
+						});
+					},
+					api,
+					openDashboard,
+					state,
+				});
+			},
+		},
+	});
 };
 
 export default { id: "opencode-balancer", tui } satisfies TuiPluginModule;

package/dist/tui/usage-auto-refresh.ts

@@ -1,64 +1,71 @@
 import { listAccounts } from "../core/accounts";
-import { refreshAccountUsage } from "../core/usage";
+import type { refreshAccountUsage } from "../core/usage";
 import { refreshUsageForAccount } from "./actions";
 import type { BalancerTuiState } from "./state";
 
 type ToastApi = Parameters<typeof refreshUsageForAccount>[0];
 
 type UsageAutoRefreshOptions = {
-    intervalMs?: number;
-    promptDebounceMs?: number;
-    refreshUsage?: typeof refreshAccountUsage;
-    now?: () => number;
+	intervalMs?: number;
+	promptDebounceMs?: number;
+	refreshUsage?: typeof refreshAccountUsage;
+	now?: () => number;
 };
 
 export function createUsageAutoRefresh(
-    api: ToastApi,
-    state: BalancerTuiState,
-    options: UsageAutoRefreshOptions = {},
+	api: ToastApi,
+	state: BalancerTuiState,
+	options: UsageAutoRefreshOptions = {},
 ) {
-    const intervalMs = options.intervalMs ?? 60_000;
-    const promptDebounceMs = options.promptDebounceMs ?? 30_000;
-    const now = options.now ?? Date.now;
-    const inFlight = new Set<string>();
-    let lastPromptRefreshAt = 0;
+	const intervalMs = options.intervalMs ?? 60_000;
+	const promptDebounceMs = options.promptDebounceMs ?? 30_000;
+	const now = options.now ?? Date.now;
+	const inFlight = new Set<string>();
+	let lastPromptRefreshAt = 0;
 
-    const refreshOne = async (providerID: string, alias: string) => {
-        const key = `${providerID}/${alias}`;
-        if (inFlight.has(key)) return;
+	const refreshOne = async (providerID: string, alias: string) => {
+		const key = `${providerID}/${alias}`;
+		if (inFlight.has(key)) return;
 
-        inFlight.add(key);
-        try {
-            await refreshUsageForAccount(api, state, providerID, alias, {
-                refreshUsage: options.refreshUsage,
-                silent: true,
-            });
-        } finally {
-            inFlight.delete(key);
-        }
-    };
+		inFlight.add(key);
+		try {
+			await refreshUsageForAccount(api, state, providerID, alias, {
+				refreshUsage: options.refreshUsage,
+				silent: true,
+			});
+		} finally {
+			inFlight.delete(key);
+		}
+	};
 
-    const refreshNow = async () => {
-        const accounts = listAccounts(state.db).filter((account) => !account.disabled);
-        await Promise.all(accounts.map((account) => refreshOne(account.providerID, account.alias)));
-    };
+	const refreshNow = async () => {
+		const accounts = listAccounts(state.db).filter(
+			(account) => !account.disabled,
+		);
+		await Promise.all(
+			accounts.map((account) => refreshOne(account.providerID, account.alias)),
+		);
+	};
 
-    const refreshForPrompt = async () => {
-        const current = now();
-        if (current - lastPromptRefreshAt < promptDebounceMs) return;
+	const refreshForPrompt = async () => {
+		const current = now();
+		if (current - lastPromptRefreshAt < promptDebounceMs) return;
 
-        lastPromptRefreshAt = current;
-        await refreshNow();
-    };
+		lastPromptRefreshAt = current;
+		await refreshNow();
+	};
 
-    const timer = intervalMs > 0 ? setInterval(() => void refreshNow(), intervalMs) : undefined;
-    void refreshNow();
+	const timer =
+		intervalMs > 0
+			? setInterval(() => void refreshNow(), intervalMs)
+			: undefined;
+	void refreshNow();
 
-    return {
-        refreshNow,
-        refreshForPrompt,
-        dispose() {
-            if (timer) clearInterval(timer);
-        },
-    };
+	return {
+		dispose() {
+			if (timer) clearInterval(timer);
+		},
+		refreshForPrompt,
+		refreshNow,
+	};
 }

package/dist/tui/usage-format.ts

@@ -1,14 +1,14 @@
 export function formatUsageBar(percent: number | undefined, width = 8) {
-    if (percent === undefined) return `${"─".repeat(width)} --`;
-    const value = Math.max(0, Math.min(100, Math.round(percent)));
-    const filled = Math.max(0, Math.min(width, Math.ceil((value / 100) * width)));
-    return `${"█".repeat(filled)}${"░".repeat(width - filled)} ${value}%`;
+	if (percent === undefined) return `${"─".repeat(width)} --`;
+	const value = Math.max(0, Math.min(100, Math.round(percent)));
+	const filled = Math.max(0, Math.min(width, Math.ceil((value / 100) * width)));
+	return `${"█".repeat(filled)}${"░".repeat(width - filled)} ${value}%`;
 }
 
 export function truncateMiddle(value: string, maxLength: number) {
-    if (value.length <= maxLength) return value;
-    if (maxLength <= 1) return "…";
-    const left = Math.ceil((maxLength - 1) / 2);
-    const right = Math.floor((maxLength - 1) / 2);
-    return `${value.slice(0, left)}…${value.slice(value.length - right)}`;
+	if (value.length <= maxLength) return value;
+	if (maxLength <= 1) return "…";
+	const left = Math.ceil((maxLength - 1) / 2);
+	const right = Math.floor((maxLength - 1) / 2);
+	return `${value.slice(0, left)}…${value.slice(value.length - right)}`;
 }

package/package.json

@@ -1,54 +1,63 @@
 {
-    "name": "@thelioo/opencode-balancer",
-    "version": "0.1.6",
-    "description": "Account balancer plugin for opencode.",
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        },
-        "./tui": {
-            "types": "./dist/tui/tui.d.ts",
-            "default": "./dist/tui/tui.tsx"
-        }
-    },
-    "files": [
-        "dist",
-        "README.md",
-        "INSTALL.txt",
-        "LICENSE"
-    ],
-    "scripts": {
-        "build": "tsc --project tsconfig.json && node scripts/copy-tui-source.mjs",
-        "check": "tsc --noEmit --project tsconfig.json",
-        "test": "bun test",
-        "prepublishOnly": "npm run build"
-    },
-    "keywords": [
-        "opencode",
-        "opencode-plugin",
-        "balancer",
-        "accounts"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/thelioo/opencode-balancer.git"
-    },
-    "bugs": {
-        "url": "https://github.com/thelioo/opencode-balancer/issues"
-    },
-    "homepage": "https://github.com/thelioo/opencode-balancer#readme",
-    "license": "MIT",
-    "dependencies": {
-        "@opencode-ai/plugin": "^1.14.51",
-        "@opentui/solid": "^0.2.16",
-        "solid-js": "^1.9.12"
-    },
-    "devDependencies": {
-        "@types/bun": "^1.3.14",
-        "typescript": "^5.9.3"
-    }
+	"bugs": {
+		"url": "https://github.com/thelioo/opencode-balancer/issues"
+	},
+	"dependencies": {
+		"@opencode-ai/plugin": "^1.14.51",
+		"@opentui/solid": "^0.2.16",
+		"solid-js": "^1.9.12"
+	},
+	"description": "Account balancer plugin for opencode.",
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.16",
+		"@changesets/cli": "^2.31.0",
+		"@types/bun": "^1.3.14",
+		"@typescript/native-preview": "7.0.0-dev.20260607.1",
+		"concurrently": "^10.0.3",
+		"husky": "^9.1.7"
+	},
+	"exports": {
+		".": {
+			"default": "./dist/index.js"
+		},
+		"./tui": {
+			"default": "./dist/tui/tui.tsx"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"INSTALL.txt",
+		"LICENSE"
+	],
+	"homepage": "https://github.com/thelioo/opencode-balancer#readme",
+	"keywords": [
+		"opencode",
+		"opencode-plugin",
+		"balancer",
+		"accounts"
+	],
+	"license": "MIT",
+	"main": "./dist/index.js",
+	"name": "@thelioo/opencode-balancer",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/thelioo/opencode-balancer.git"
+	},
+	"scripts": {
+		"build": "bun scripts/build.ts",
+		"changeset": "changeset",
+		"checktypes": "tsgo --noEmit",
+		"format": "biome format --write",
+		"lint": "biome check .",
+		"lint:fix": "biome check . --fix",
+		"lint:unsafe": "biome check . --fix --unsafe",
+		"prepare": "husky",
+		"prepublishOnly": "bun run build",
+		"release": "changeset publish",
+		"test": "bun test",
+		"version": "changeset version"
+	},
+	"type": "module",
+	"version": "0.2.0"
 }

package/dist/balancer/accounts.d.ts

@@ -1,9 +0,0 @@
-import type { Account, AuthInfo, ProviderState } from "./types";
-export declare function normalizeAlias(alias: string): string;
-export declare function saveAccount(providerID: string, aliasInput: string, auth: AuthInfo): Promise<Account>;
-export declare function getProviderState(providerID: string): Promise<ProviderState | undefined>;
-export declare function getActiveAccount(providerID: string): Promise<Account | undefined>;
-export declare function listAccountsText(): Promise<string>;
-export declare function nextAvailableAccount(providerID: string, currentAlias?: string): Promise<Account | undefined>;
-export declare function markRateLimited(providerID: string, alias: string, retryAfterMs?: number): Promise<void>;
-export declare function markUsed(providerID: string, alias: string): Promise<void>;