@thelioo/opencode-balancer 0.1.8 → 0.2.1

package/dist/tui/components/usage-display.tsx

@@ -5,25 +5,41 @@ import type { ProviderUsageSnapshot } from "../../core/usage/types";
 import { UsageBar } from "./usage-bar";
 
 export function snapshotPercent(snapshot: ProviderUsageSnapshot | undefined) {
-    if (!snapshot || snapshot.confidence === "unavailable") return undefined;
-    if (snapshot.usedPercent !== undefined) return snapshot.usedPercent;
-    if (snapshot.usedTokens !== undefined && snapshot.remainingTokens !== undefined) {
-        const total = snapshot.usedTokens + snapshot.remainingTokens;
-        if (total > 0) return (snapshot.usedTokens / total) * 100;
-    }
-    return undefined;
+	if (!snapshot || snapshot.confidence === "unavailable") return undefined;
+	if (snapshot.usedPercent !== undefined) return snapshot.usedPercent;
+	if (
+		snapshot.usedTokens !== undefined &&
+		snapshot.remainingTokens !== undefined
+	) {
+		const total = snapshot.usedTokens + snapshot.remainingTokens;
+		if (total > 0) return (snapshot.usedTokens / total) * 100;
+	}
+	return undefined;
 }
 
 export function snapshotLabel(snapshot: ProviderUsageSnapshot | undefined) {
-    if (!snapshot) return "usage unavailable";
-    if (snapshot.confidence === "unavailable") return snapshot.message;
-    const parts: string[] = [];
-    if (snapshot.usedTokens !== undefined) parts.push(`used ${snapshot.usedTokens}`);
-    if (snapshot.remainingTokens !== undefined) parts.push(`remaining ${snapshot.remainingTokens}`);
-    if (snapshot.planName) parts.push(snapshot.planName);
-    return parts.length > 0 ? parts.join(" · ") : snapshot.message;
+	if (!snapshot) return "usage unavailable";
+	if (snapshot.confidence === "unavailable") return snapshot.message;
+	const parts: string[] = [];
+	if (snapshot.usedTokens !== undefined)
+		parts.push(`used ${snapshot.usedTokens}`);
+	if (snapshot.remainingTokens !== undefined)
+		parts.push(`remaining ${snapshot.remainingTokens}`);
+	if (snapshot.planName) parts.push(snapshot.planName);
+	return parts.length > 0 ? parts.join(" · ") : snapshot.message;
 }
 
-export function UsageSnapshotBar(props: { theme: TuiThemeCurrent; snapshot?: ProviderUsageSnapshot; muted?: boolean }) {
-    return <UsageBar theme={props.theme} percent={snapshotPercent(props.snapshot)} label={snapshotLabel(props.snapshot)} muted={props.muted} />;
+export function UsageSnapshotBar(props: {
+	theme: TuiThemeCurrent;
+	snapshot?: ProviderUsageSnapshot;
+	muted?: boolean;
+}) {
+	return (
+		<UsageBar
+			label={snapshotLabel(props.snapshot)}
+			muted={props.muted}
+			percent={snapshotPercent(props.snapshot)}
+			theme={props.theme}
+		/>
+	);
 }

package/dist/tui/connect.ts

@@ -1,102 +1,133 @@
 import type { Database } from "bun:sqlite";
 import { listAccounts, saveAccount } from "../core/accounts";
-import { clearNativeConnectInProgress, markNativeConnectInProgress } from "../core/native-connect";
-import { readNativeAuth, sameSavedAuth } from "../server/auth-watcher";
+import {
+	clearNativeConnectInProgress,
+	markNativeConnectInProgress,
+} from "../core/native-connect";
 import type { AuthInfo } from "../core/types";
+import { readNativeAuth, sameSavedAuth } from "../server/auth-watcher";
 
 type NativeAuthReadResult =
-    | { ok: true; auth: Record<string, AuthInfo> }
-    | { ok: false };
+	| { ok: true; auth: Record<string, AuthInfo> }
+	| { ok: false };
 
 type ConnectApi = {
-    db?: Database;
-    readAuth?: () => NativeAuthReadResult;
-    generateAlias?: () => string;
-    wait?: (ms: number) => Promise<void>;
-    maxWaitMs?: number;
-    pollIntervalMs?: number;
-    keymap?: {
-        dispatchCommand?: (command: string) => unknown;
-    };
-    ui?: {
-        dialog?: { open?: boolean };
-        toast?: (input: { variant: "success" | "error"; message: string }) => unknown;
-    };
+	db?: Database;
+	readAuth?: () => NativeAuthReadResult;
+	generateAlias?: () => string;
+	wait?: (ms: number) => Promise<void>;
+	maxWaitMs?: number;
+	pollIntervalMs?: number;
+	keymap?: {
+		dispatchCommand?: (command: string) => unknown;
+	};
+	ui?: {
+		dialog?: { open?: boolean };
+		toast?: (input: {
+			variant: "success" | "error";
+			message: string;
+		}) => unknown;
+	};
 };
 
 const aliasAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
 
 function generatedAlias() {
-    let alias = "";
-    for (let index = 0; index < 5; index++) alias += aliasAlphabet[Math.floor(Math.random() * aliasAlphabet.length)];
-    return alias;
+	let alias = "";
+	for (let index = 0; index < 5; index++)
+		alias += aliasAlphabet[Math.floor(Math.random() * aliasAlphabet.length)];
+	return alias;
 }
 
 function authKey(auth: AuthInfo | undefined) {
-    return JSON.stringify(auth ?? null);
+	return JSON.stringify(auth ?? null);
 }
 
-function changedProvider(before: Record<string, AuthInfo>, after: Record<string, AuthInfo>) {
-    return Object.entries(after).find(([providerID, auth]) => authKey(before[providerID]) !== authKey(auth));
+function changedProvider(
+	before: Record<string, AuthInfo>,
+	after: Record<string, AuthInfo>,
+) {
+	return Object.entries(after).find(
+		([providerID, auth]) => authKey(before[providerID]) !== authKey(auth),
+	);
 }
 
 function uniqueAlias(db: Database, providerID: string, generate: () => string) {
-    for (let attempt = 0; attempt < 100; attempt++) {
-        const alias = generate();
-        const existing = db
-            .query<{ alias: string }, [string, string]>("SELECT alias FROM accounts WHERE provider_id = ? AND alias = ?")
-            .get(providerID, alias);
-        if (!existing) return alias;
-    }
-    throw new Error("Could not generate a unique alias");
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const alias = generate();
+		const existing = db
+			.query<{ alias: string }, [string, string]>(
+				"SELECT alias FROM accounts WHERE provider_id = ? AND alias = ?",
+			)
+			.get(providerID, alias);
+		if (!existing) return alias;
+	}
+	throw new Error("Could not generate a unique alias");
 }
 
 async function waitForChangedProvider(
-    readAuth: () => NativeAuthReadResult,
-    before: NativeAuthReadResult,
-    options: { wait: (ms: number) => Promise<void>; maxWaitMs: number; pollIntervalMs: number },
+	readAuth: () => NativeAuthReadResult,
+	before: NativeAuthReadResult,
+	options: {
+		wait: (ms: number) => Promise<void>;
+		maxWaitMs: number;
+		pollIntervalMs: number;
+	},
 ) {
-    const started = Date.now();
-    while (true) {
-        const after = readAuth();
-        if (before.ok && after.ok) {
-            const changed = changedProvider(before.auth, after.auth);
-            if (changed) return changed;
-        }
-        if (Date.now() - started >= options.maxWaitMs) return;
-        await options.wait(options.pollIntervalMs);
-    }
+	const started = Date.now();
+	while (true) {
+		const after = readAuth();
+		if (before.ok && after.ok) {
+			const changed = changedProvider(before.auth, after.auth);
+			if (changed) return changed;
+		}
+		if (Date.now() - started >= options.maxWaitMs) return;
+		await options.wait(options.pollIntervalMs);
+	}
 }
 
 export async function openNativeConnect(api: ConnectApi) {
-    if (api.keymap?.dispatchCommand) {
-        const readAuth = api.readAuth ?? readNativeAuth;
-        const before = readAuth();
-        if (api.db) markNativeConnectInProgress(api.db);
-        await api.keymap.dispatchCommand("provider.connect");
-        if (api.db) {
-            try {
-                const changed = await waitForChangedProvider(readAuth, before, {
-                    wait: api.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
-                    maxWaitMs: api.maxWaitMs ?? (api.ui?.dialog ? 10 * 60 * 1000 : 0),
-                    pollIntervalMs: api.pollIntervalMs ?? 500,
-                });
-                if (changed) {
-                    const [providerID, auth] = changed;
-                    const existing = listAccounts(api.db, providerID).find((candidate) => sameSavedAuth(candidate.auth, auth));
-                    const alias = existing?.alias ?? uniqueAlias(api.db, providerID, api.generateAlias ?? generatedAlias);
-                    const account = saveAccount(api.db, providerID, alias, auth);
-                    api.ui?.toast?.({ variant: "success", message: `Saved ${account.providerID}/${account.alias}.` });
-                }
-            } finally {
-                clearNativeConnectInProgress(api.db);
-            }
-        }
-        return;
-    }
+	if (api.keymap?.dispatchCommand) {
+		const readAuth = api.readAuth ?? readNativeAuth;
+		const before = readAuth();
+		if (api.db) markNativeConnectInProgress(api.db);
+		await api.keymap.dispatchCommand("provider.connect");
+		if (api.db) {
+			try {
+				const changed = await waitForChangedProvider(readAuth, before, {
+					maxWaitMs: api.maxWaitMs ?? (api.ui?.dialog ? 10 * 60 * 1000 : 0),
+					pollIntervalMs: api.pollIntervalMs ?? 500,
+					wait:
+						api.wait ??
+						((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+				});
+				if (changed) {
+					const [providerID, auth] = changed;
+					const existing = listAccounts(api.db, providerID).find((candidate) =>
+						sameSavedAuth(candidate.auth, auth),
+					);
+					const alias =
+						existing?.alias ??
+						uniqueAlias(
+							api.db,
+							providerID,
+							api.generateAlias ?? generatedAlias,
+						);
+					const account = saveAccount(api.db, providerID, alias, auth);
+					api.ui?.toast?.({
+						message: `Saved ${account.providerID}/${account.alias}.`,
+						variant: "success",
+					});
+				}
+			} finally {
+				clearNativeConnectInProgress(api.db);
+			}
+		}
+		return;
+	}
 
-    api.ui?.toast?.({
-        variant: "error",
-        message: "Native provider connect is unavailable in this opencode build.",
-    });
+	api.ui?.toast?.({
+		message: "Native provider connect is unavailable in this opencode build.",
+		variant: "error",
+	});
 }

package/dist/tui/dashboard-keys.ts

@@ -1,60 +1,72 @@
 export type DashboardKey = {
-    name: string;
+	name: string;
 };
 
 export type DashboardIntent =
-    | { type: "move-cursor"; delta: -1 | 1 }
-    | { type: "move-header"; delta: -1 | 1 }
-    | { type: "primary" }
-    | { type: "priority" }
-    | { type: "connect" }
-    | { type: "alias" }
-    | { type: "rename" }
-    | { type: "remove" }
-    | { type: "confirm" }
-    | { type: "cancel" }
-    | { type: "back" }
-    | { type: "none" };
+	| { type: "move-cursor"; delta: -1 | 1 }
+	| { type: "move-header"; delta: -1 | 1 }
+	| { type: "primary" }
+	| { type: "priority" }
+	| { type: "connect" }
+	| { type: "alias" }
+	| { type: "rename" }
+	| { type: "remove" }
+	| { type: "confirm" }
+	| { type: "cancel" }
+	| { type: "back" }
+	| { type: "none" };
 
 export type DashboardFocusArea = "header" | "content";
 
 export function moveDashboardFocus(
-    state: { area: DashboardFocusArea; cursor: number; rowCount: number },
-    delta: -1 | 1,
+	state: { area: DashboardFocusArea; cursor: number; rowCount: number },
+	delta: -1 | 1,
 ): { area: DashboardFocusArea; cursor: number } {
-    if (state.area === "header") {
-        return delta > 0 ? { area: "content", cursor: Math.max(0, Math.min(state.cursor, state.rowCount - 1)) } : { area: "header", cursor: state.cursor };
-    }
+	if (state.area === "header") {
+		return delta > 0
+			? {
+					area: "content",
+					cursor: Math.max(0, Math.min(state.cursor, state.rowCount - 1)),
+				}
+			: { area: "header", cursor: state.cursor };
+	}
 
-    if (delta < 0 && state.cursor <= 0) return { area: "header", cursor: 0 };
+	if (delta < 0 && state.cursor <= 0) return { area: "header", cursor: 0 };
 
-    return {
-        area: "content",
-        cursor: Math.max(0, Math.min(state.cursor + delta, Math.max(0, state.rowCount - 1))),
-    };
+	return {
+		area: "content",
+		cursor: Math.max(
+			0,
+			Math.min(state.cursor + delta, Math.max(0, state.rowCount - 1)),
+		),
+	};
 }
 
 export function dashboardSelectionMarker(input: {
-    focusedArea: DashboardFocusArea;
-    itemArea: DashboardFocusArea;
-    selected: boolean;
+	focusedArea: DashboardFocusArea;
+	itemArea: DashboardFocusArea;
+	selected: boolean;
 }) {
-    return input.selected && input.focusedArea === input.itemArea ? "▶" : " ";
+	return input.selected && input.focusedArea === input.itemArea ? "▶" : " ";
 }
 
 export function reduceDashboardKey(key: DashboardKey): DashboardIntent {
-    if (key.name === "up" || key.name === "k") return { type: "move-cursor", delta: -1 };
-    if (key.name === "down" || key.name === "j") return { type: "move-cursor", delta: 1 };
-    if (key.name === "left" || key.name === "h") return { type: "move-header", delta: -1 };
-    if (key.name === "right" || key.name === "l") return { type: "move-header", delta: 1 };
-    if (key.name === "return" || key.name === "space") return { type: "primary" };
-    if (key.name === "p") return { type: "priority" };
-    if (key.name === "c") return { type: "connect" };
-    if (key.name === "a") return { type: "alias" };
-    if (key.name === "r") return { type: "rename" };
-    if (key.name === "d") return { type: "remove" };
-    if (key.name === "y") return { type: "confirm" };
-    if (key.name === "n") return { type: "cancel" };
-    if (key.name === "escape") return { type: "back" };
-    return { type: "none" };
+	if (key.name === "up" || key.name === "k")
+		return { delta: -1, type: "move-cursor" };
+	if (key.name === "down" || key.name === "j")
+		return { delta: 1, type: "move-cursor" };
+	if (key.name === "left" || key.name === "h")
+		return { delta: -1, type: "move-header" };
+	if (key.name === "right" || key.name === "l")
+		return { delta: 1, type: "move-header" };
+	if (key.name === "return" || key.name === "space") return { type: "primary" };
+	if (key.name === "p") return { type: "priority" };
+	if (key.name === "c") return { type: "connect" };
+	if (key.name === "a") return { type: "alias" };
+	if (key.name === "r") return { type: "rename" };
+	if (key.name === "d") return { type: "remove" };
+	if (key.name === "y") return { type: "confirm" };
+	if (key.name === "n") return { type: "cancel" };
+	if (key.name === "escape") return { type: "back" };
+	return { type: "none" };
 }

package/dist/tui/native-model-apply.ts

@@ -6,8 +6,9 @@ const ESCAPE = "\x1B";
 type StdinLike = { emit: (event: string, data: unknown) => unknown };
 
 function rendererStdin(api: TuiPluginApi): StdinLike | undefined {
-    const stdin = (api.renderer as unknown as { stdin?: StdinLike } | undefined)?.stdin;
-    return stdin && typeof stdin.emit === "function" ? stdin : undefined;
+	const stdin = (api.renderer as unknown as { stdin?: StdinLike } | undefined)
+		?.stdin;
+	return stdin && typeof stdin.emit === "function" ? stdin : undefined;
 }
 
 /**
@@ -17,20 +18,23 @@ function rendererStdin(api: TuiPluginApi): StdinLike | undefined {
  * Solid instance and cannot touch opencode's reactive state directly.
  */
 function feed(api: TuiPluginApi, sequence: string): boolean {
-    const stdin = rendererStdin(api);
-    if (!stdin) return false;
-    stdin.emit("data", Buffer.from(sequence));
-    return true;
+	const stdin = rendererStdin(api);
+	if (!stdin) return false;
+	stdin.emit("data", Buffer.from(sequence));
+	return true;
 }
 
-export type NativeModelApplier = (model: { providerID: string; modelID: string }, title: string) => Promise<boolean>;
+export type NativeModelApplier = (
+	model: { providerID: string; modelID: string },
+	title: string,
+) => Promise<boolean>;
 
 export type NativeModelApplyDeps = {
-    dispatchCommand: (command: string) => void;
-    isDialogOpen: () => boolean;
-    feed: (sequence: string) => boolean;
-    wait: (ms: number) => Promise<void>;
-    settleMs?: number;
+	dispatchCommand: (command: string) => void;
+	isDialogOpen: () => boolean;
+	feed: (sequence: string) => boolean;
+	wait: (ms: number) => Promise<void>;
+	settleMs?: number;
 };
 
 /**
@@ -40,34 +44,39 @@ export type NativeModelApplyDeps = {
  *   3. press Enter to select -> opencode runs `local.model.set` and the bar updates
  *   4. dismiss a follow-up variant dialog if one appears
  */
-export async function applyNativeModelSelection(deps: NativeModelApplyDeps, title: string): Promise<boolean> {
-    const settle = deps.settleMs ?? 90;
+export async function applyNativeModelSelection(
+	deps: NativeModelApplyDeps,
+	title: string,
+): Promise<boolean> {
+	const settle = deps.settleMs ?? 90;
 
-    deps.dispatchCommand("model.list");
-    await deps.wait(settle);
-    if (!deps.isDialogOpen()) return false;
+	deps.dispatchCommand("model.list");
+	await deps.wait(settle);
+	if (!deps.isDialogOpen()) return false;
 
-    if (!deps.feed(title)) return false;
-    await deps.wait(settle);
+	if (!deps.feed(title)) return false;
+	await deps.wait(settle);
 
-    if (!deps.feed(ENTER)) return false;
-    await deps.wait(settle);
+	if (!deps.feed(ENTER)) return false;
+	await deps.wait(settle);
 
-    // A model with variants opens a follow-up dialog; close it so the bar keeps
-    // the model we just set (with its default variant).
-    if (deps.isDialogOpen()) deps.feed(ESCAPE);
-    return true;
+	// A model with variants opens a follow-up dialog; close it so the bar keeps
+	// the model we just set (with its default variant).
+	if (deps.isDialogOpen()) deps.feed(ESCAPE);
+	return true;
 }
 
-export function createNativeModelApplier(api: TuiPluginApi): NativeModelApplier {
-    return (_model, title) =>
-        applyNativeModelSelection(
-            {
-                dispatchCommand: (command) => api.keymap.dispatchCommand(command),
-                isDialogOpen: () => api.ui.dialog.open,
-                feed: (sequence) => feed(api, sequence),
-                wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-            },
-            title,
-        );
+export function createNativeModelApplier(
+	api: TuiPluginApi,
+): NativeModelApplier {
+	return (_model, title) =>
+		applyNativeModelSelection(
+			{
+				dispatchCommand: (command) => api.keymap.dispatchCommand(command),
+				feed: (sequence) => feed(api, sequence),
+				isDialogOpen: () => api.ui.dialog.open,
+				wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+			},
+			title,
+		);
 }

package/dist/tui/priority-keys.ts

@@ -1,41 +1,49 @@
 export type PriorityKey = {
-    name: string;
-    shift?: boolean;
+	name: string;
+	shift?: boolean;
 };
 
 export type PriorityIntent =
-    | { type: "move-cursor"; delta: -1 | 1 }
-    | { type: "reorder"; direction: -1 | 1 }
-    | { type: "toggle-enabled" }
-    | { type: "open-model" }
-    | { type: "toggle-balancing" }
-    | { type: "back" }
-    | { type: "none" };
+	| { type: "move-cursor"; delta: -1 | 1 }
+	| { type: "reorder"; direction: -1 | 1 }
+	| { type: "toggle-enabled" }
+	| { type: "open-model" }
+	| { type: "toggle-balancing" }
+	| { type: "back" }
+	| { type: "none" };
 
 export type PriorityFocusArea = "header" | "content";
 
 export function movePriorityFocus(
-    state: { area: PriorityFocusArea; cursor: number; rowCount: number },
-    delta: -1 | 1,
+	state: { area: PriorityFocusArea; cursor: number; rowCount: number },
+	delta: -1 | 1,
 ): { area: PriorityFocusArea; cursor: number } {
-    if (state.area === "header") {
-        return delta > 0 ? { area: "content", cursor: Math.max(0, Math.min(state.cursor, state.rowCount - 1)) } : { area: "header", cursor: state.cursor };
-    }
+	if (state.area === "header") {
+		return delta > 0
+			? {
+					area: "content",
+					cursor: Math.max(0, Math.min(state.cursor, state.rowCount - 1)),
+				}
+			: { area: "header", cursor: state.cursor };
+	}
 
-    if (delta < 0 && state.cursor <= 0) return { area: "header", cursor: 0 };
+	if (delta < 0 && state.cursor <= 0) return { area: "header", cursor: 0 };
 
-    return {
-        area: "content",
-        cursor: Math.max(0, Math.min(state.cursor + delta, Math.max(0, state.rowCount - 1))),
-    };
+	return {
+		area: "content",
+		cursor: Math.max(
+			0,
+			Math.min(state.cursor + delta, Math.max(0, state.rowCount - 1)),
+		),
+	};
 }
 
 export function prioritySelectionMarker(input: {
-    focusedArea: PriorityFocusArea;
-    itemArea: PriorityFocusArea;
-    selected: boolean;
+	focusedArea: PriorityFocusArea;
+	itemArea: PriorityFocusArea;
+	selected: boolean;
 }) {
-    return input.selected && input.focusedArea === input.itemArea ? "▶" : " ";
+	return input.selected && input.focusedArea === input.itemArea ? "▶" : " ";
 }
 
 /**
@@ -43,17 +51,17 @@ export function prioritySelectionMarker(input: {
  * rendering so the whole keyboard contract is testable without a terminal.
  */
 export function reducePriorityKey(key: PriorityKey): PriorityIntent {
-    const name = key.name;
-
-    if ((name === "up" || name === "down") && key.shift) {
-        return { type: "reorder", direction: name === "up" ? -1 : 1 };
-    }
-    if (name === "up" || name === "k") return { type: "move-cursor", delta: -1 };
-    if (name === "down" || name === "j") return { type: "move-cursor", delta: 1 };
-    if (name === "space") return { type: "toggle-enabled" };
-    if (name === "return") return { type: "open-model" };
-    if (name === "b") return { type: "toggle-balancing" };
-    if (name === "escape") return { type: "back" };
-
-    return { type: "none" };
+	const name = key.name;
+
+	if ((name === "up" || name === "down") && key.shift) {
+		return { direction: name === "up" ? -1 : 1, type: "reorder" };
+	}
+	if (name === "up" || name === "k") return { delta: -1, type: "move-cursor" };
+	if (name === "down" || name === "j") return { delta: 1, type: "move-cursor" };
+	if (name === "space") return { type: "toggle-enabled" };
+	if (name === "return") return { type: "open-model" };
+	if (name === "b") return { type: "toggle-balancing" };
+	if (name === "escape") return { type: "back" };
+
+	return { type: "none" };
 }