@mars-sea/dsh-commandcode-provider 0.7.0 → 0.8.0

package/lib/index.js

@@ -8,8 +8,10 @@ import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { createServer } from "node:http";
+import { createServer as createServer$1 } from "node:net";
 //#region src/accounts.ts
 /**
 * Multi-account pool for the Command Code provider (host side).
@@ -1859,30 +1861,30 @@ const USAGE_REMOTE_PACKAGE = "@mars-sea/dsh-commandcode-provider";
 /** Canonical `<namespace>/<method>` endpoint of the usage report Remote. */
 const USAGE_REPORT_ENDPOINT = "commandcode/report";
 /** Reject one boundary value with a field-naming error. */
-function reject(field) {
+function reject$1(field) {
 	throw new TypeError(`commandcode/report result: invalid ${field}`);
 }
 /** Read one required finite number field (`field` is the dotted error label). */
 function numberField(source, key, field) {
 	const value = source[key];
-	if (typeof value !== "number" || !Number.isFinite(value)) reject(field);
+	if (typeof value !== "number" || !Number.isFinite(value)) reject$1(field);
 	return value;
 }
 /** Read one required string field (`field` is the dotted error label). */
 function stringField(source, key, field) {
 	const value = source[key];
-	if (typeof value !== "string") reject(field);
+	if (typeof value !== "string") reject$1(field);
 	return value;
 }
 /** Read one required boolean field (`field` is the dotted error label). */
 function booleanField(source, key, field) {
 	const value = source[key];
-	if (typeof value !== "boolean") reject(field);
+	if (typeof value !== "boolean") reject$1(field);
 	return value;
 }
 /** Narrow an unknown value to a plain record, or reject. */
 function record(value, field) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) reject(field);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) reject$1(field);
 	return value;
 }
 /** Validate one window-limit block (`fiveHour` / `weekly`). */
@@ -1903,11 +1905,11 @@ function windowLimit(value, field) {
 function parseUsageReport(value) {
 	const source = record(value, "report");
 	const failures = source.failures;
-	if (!Array.isArray(failures) || failures.some((entry) => typeof entry !== "string")) reject("failures");
+	if (!Array.isArray(failures) || failures.some((entry) => typeof entry !== "string")) reject$1("failures");
 	const report = { failures };
 	if (source.blocked !== void 0) {
 		const blocked = source.blocked;
-		if (blocked !== "invalid-key" && blocked !== "service-unavailable" && blocked !== "network") reject("blocked");
+		if (blocked !== "invalid-key" && blocked !== "service-unavailable" && blocked !== "network") reject$1("blocked");
 		report.blocked = blocked;
 	}
 	if (source.account !== void 0) {
@@ -1945,7 +1947,7 @@ function parseUsageReport(value) {
 	if (source.plan !== void 0) {
 		const plan = record(source.plan, "plan");
 		const monthly = plan.monthlyCredits;
-		if (monthly !== null && (typeof monthly !== "number" || !Number.isFinite(monthly))) reject("plan.monthlyCredits");
+		if (monthly !== null && (typeof monthly !== "number" || !Number.isFinite(monthly))) reject$1("plan.monthlyCredits");
 		report.plan = {
 			planId: stringField(plan, "planId", "plan.planId"),
 			name: stringField(plan, "name", "plan.name"),
@@ -1972,7 +1974,7 @@ function parseAccountUsage(value) {
 /** Parse the wire result into a {@link CommandCodeAccountsReport}. */
 function parseAccountsReport(value) {
 	const accounts = record(value, "result").accounts;
-	if (!Array.isArray(accounts)) reject("accounts");
+	if (!Array.isArray(accounts)) reject$1("accounts");
 	return { accounts: accounts.map(parseAccountUsage) };
 }
 /**
@@ -2001,6 +2003,82 @@ const USAGE_HOST_CONTRIBUTION = {
 	}]
 };
 //#endregion
+//#region src/login-wire.ts
+/** The canonical endpoint paths of the three login Remotes. */
+const LOGIN_BEGIN_ENDPOINT = "commandcode/loginBegin";
+const LOGIN_STATUS_ENDPOINT = "commandcode/loginStatus";
+const LOGIN_CANCEL_ENDPOINT = "commandcode/loginCancel";
+const REASONS = [
+	"denied",
+	"timeout",
+	"invalid-key",
+	"network",
+	"unavailable",
+	"cancelled",
+	"error"
+];
+/** Reject one boundary value with a field-naming error. */
+function reject(field) {
+	throw new TypeError(`commandcode/login result: invalid ${field}`);
+}
+/**
+* Parse one untrusted boundary value into a {@link CommandCodeLoginStatus}.
+* Every field is shape-checked so a malformed frame fails the boundary
+* instead of leaking into the page.
+*/
+function parseLoginStatus(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) reject("status");
+	const source = value;
+	const state = source.state;
+	if (state !== "idle" && state !== "waiting" && state !== "success" && state !== "failed") reject("state");
+	const status = { state };
+	if (source.authUrl !== void 0) {
+		if (typeof source.authUrl !== "string") reject("authUrl");
+		status.authUrl = source.authUrl;
+	}
+	if (source.userName !== void 0) {
+		if (typeof source.userName !== "string") reject("userName");
+		status.userName = source.userName;
+	}
+	if (source.keyName !== void 0) {
+		if (typeof source.keyName !== "string") reject("keyName");
+		status.keyName = source.keyName;
+	}
+	if (source.reason !== void 0) {
+		if (!REASONS.includes(source.reason)) reject("reason");
+		status.reason = source.reason;
+	}
+	if (source.message !== void 0) {
+		if (typeof source.message !== "string") reject("message");
+		status.message = source.message;
+	}
+	return status;
+}
+/** The strict result codec shared by all three login endpoints. */
+const loginStatusSchema = { parse: parseLoginStatus };
+/** Build one login invocation descriptor (uniform result, no parameters). */
+function loginDescriptor(endpoint, method) {
+	return {
+		id: `${USAGE_REMOTE_PACKAGE}#${endpoint}`,
+		service: "commandcodeUsage",
+		namespace: "commandcode",
+		method,
+		invocation: { kind: "direct" },
+		parameters: [],
+		result: {
+			mode: "strict",
+			typeSymbol: `${USAGE_REMOTE_PACKAGE}#CommandCodeLoginStatus`,
+			schema: loginStatusSchema
+		}
+	};
+}
+/** The three login descriptors, shared verbatim by Host registration and Client mount. */
+const LOGIN_DESCRIPTORS = [
+	loginDescriptor(LOGIN_BEGIN_ENDPOINT, "loginBegin"),
+	loginDescriptor(LOGIN_STATUS_ENDPOINT, "loginStatus"),
+	loginDescriptor(LOGIN_CANCEL_ENDPOINT, "loginCancel")
+];
+//#endregion
 //#region src/usage-remote.ts
 /**
 * The Remote receiver: a Cordis service the Gateway resolves by key
@@ -2035,6 +2113,29 @@ var CommandCodeUsageService = class extends TypertRemoteService {
 			report: await this.deps.adapter.getUsage()
 		}] };
 	}
+	/**
+	* Start (or rejoin) a browser-login attempt and return its fresh status —
+	* `waiting` carrying the Studio URL. Rejects when the flow cannot start
+	* (no free loopback port, disposed plugin); the Gateway folds the throw
+	* into the failure branch the page renders.
+	*/
+	async loginBegin() {
+		return this.requireLogin().begin();
+	}
+	/** Poll a login attempt's status. */
+	async loginStatus() {
+		return this.deps.login?.status() ?? { state: "idle" };
+	}
+	/** Cancel a waiting attempt; returns the post-cancel status. */
+	async loginCancel() {
+		this.deps.login?.cancel();
+		return this.deps.login?.status() ?? { state: "idle" };
+	}
+	requireLogin() {
+		const login = this.deps.login;
+		if (login === void 0) throw new Error("login flow is not wired in this setup; paste the API key instead");
+		return login;
+	}
 };
 /**
 * Provide the usage service and register its Remote descriptor. The registry
@@ -2044,11 +2145,395 @@ var CommandCodeUsageService = class extends TypertRemoteService {
 function applyUsageRemote(ctx, deps) {
 	ctx.inject(["typert"], (remoteCtx) => {
 		new CommandCodeUsageService(remoteCtx, deps);
-		const unregister = remoteCtx.typert.register(USAGE_HOST_CONTRIBUTION);
+		const unregister = remoteCtx.typert.register({
+			...USAGE_HOST_CONTRIBUTION,
+			invocations: [...USAGE_HOST_CONTRIBUTION.invocations, ...LOGIN_DESCRIPTORS]
+		});
 		remoteCtx.effect(() => () => void unregister(), "dsh-commandcode-provider: usage remote");
 	});
 }
 //#endregion
+//#region src/login.ts
+/**
+* Host half of the Command Code browser login (the loopback flow).
+*
+* Mirrors what the official `command-code login` CLI command performs
+* (reverse-engineered from `command-code@1.32.1`, `createAuthFlowController`
+* + `createAuthServer` in its bundle):
+*
+* 1. Bind a temporary HTTP server on `127.0.0.1`, first available port from
+*    5959 upward (10 attempts).
+* 2. Generate a random state token and open
+*    `{studio}/studio/auth/cli?callback=http://localhost:{port}/callback&state={state}`.
+* 3. After the user signs in, the Studio page POSTs the credentials JSON
+*    `{ apiKey, state, userId, userName, keyName }` to the loopback callback —
+*    no OAuth code exchange, the page holds the final API key.
+* 4. The delivered key is validated against `GET {apiBase}/alpha/whoami`
+*    before anything is stored.
+*
+* Server behaviour is mirrored exactly: POST-only `/callback`, a 10 KB body
+* cap, JSON responses (`{success:true}` / `{success:false,error}`), CORS for
+* the Studio origins only, and state-token equality as the anti-forgery
+* check. One deliberate hardening over the CLI build: the CORS origin is
+* echoed only when it is allowlisted (the CLI falls back to the first
+* origin), which browsers treat identically.
+*
+* Storage stays out of this module: the plugin entry supplies
+* {@link CommandCodeLoginFlowDeps.storeKey}, which writes through the dsh
+* credentials seam so the next request resolves the new key with no restart.
+* Everything external (fetch, ports, randomness, timing) is injectable for
+* node tests; the tests drive a real loopback server end to end.
+*
+* @module dsh-commandcode-provider/login
+*/
+/** Give up on the browser after this long without a callback (mirrors the CLI). */
+const LOGIN_TIMEOUT_MS = 12e4;
+/** First local port the flow tries (mirrors the CLI). */
+const LOGIN_START_PORT = 5959;
+/** How many consecutive ports to try from {@link LOGIN_START_PORT}. */
+const LOGIN_MAX_PORT_ATTEMPTS = 10;
+/** Reject callback bodies larger than this (mirrors the CLI). */
+const LOGIN_BODY_LIMIT_BYTES = 1e4;
+/** The Studio origins allowed to POST credentials to the loopback server. */
+const LOGIN_ALLOWED_ORIGINS = [
+	"http://localhost:3000",
+	"https://staging.commandcode.ai",
+	"https://commandcode.ai"
+];
+/** The Studio route that performs the browser-side login. */
+const STUDIO_AUTH_PATH = "/studio/auth/cli";
+/** Compose the Studio authorization URL (pure, exported for tests). */
+function buildCommandAuthUrl(options) {
+	const callback = `http://localhost:${options.port}/callback`;
+	return `${options.studioBase}${STUDIO_AUTH_PATH}?callback=${encodeURIComponent(callback)}&state=${encodeURIComponent(options.state)}`;
+}
+/** Map an API base onto the Studio base the CLI pairs it with. */
+function studioBaseForApiBase(apiBase) {
+	if (/^https:\/\/staging-api\.commandcode\.ai/i.test(apiBase)) return "https://staging.commandcode.ai";
+	if (/^http:\/\/localhost(:\d+)?$/i.test(apiBase)) return "http://localhost:3000";
+	return "https://commandcode.ai";
+}
+/**
+* Validate one candidate key against `/alpha/whoami` (pure, exported for
+* tests). Mirrors the CLI's verdicts: 401 → invalid_key, other non-OK →
+* server_error, transport failure → network_error.
+*/
+async function validateCommandApiKey(fetchImpl, apiBase, apiKey) {
+	try {
+		const response = await fetchImpl(`${apiBase}/alpha/whoami`, {
+			method: "GET",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			}
+		});
+		if (response.status === 401) return {
+			valid: false,
+			error: "invalid_key"
+		};
+		if (response.ok) return { valid: true };
+		return {
+			valid: false,
+			error: "server_error"
+		};
+	} catch {
+		return {
+			valid: false,
+			error: "network_error"
+		};
+	}
+}
+/** Whether one loopback port is free right now. */
+function checkPortAvailable(port) {
+	return new Promise((resolve) => {
+		const probe = createServer$1();
+		probe.once("error", () => resolve(false));
+		probe.once("listening", () => probe.close(() => resolve(true)));
+		probe.listen(port, "127.0.0.1");
+	});
+}
+/** Whether a callback body carries every credential field the CLI requires. */
+function isCallbackCredentials(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.apiKey === "string" && record.apiKey !== "" && typeof record.state === "string" && typeof record.userId === "string" && typeof record.userName === "string" && typeof record.keyName === "string";
+}
+/**
+* One browser-login attempt machine. Single-flight by design: `begin()` while
+* waiting returns the live attempt's status instead of starting a second one;
+* a terminal state makes the next `begin()` start fresh.
+*/
+var CommandCodeLoginFlow = class {
+	deps;
+	listeners = /* @__PURE__ */ new Set();
+	statusValue = { state: "idle" };
+	server;
+	timer;
+	/** Settle hooks of the live attempt's callback promise. */
+	settle;
+	disposed = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Subscribe to state transitions. @returns the disposer. */
+	onChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/** The current attempt's status face. */
+	status() {
+		return this.statusValue;
+	}
+	/**
+	* Start an attempt (or rejoin the live one) and resolve with its status —
+	* `waiting` carrying the Studio URL once the loopback server is up.
+	* Rejects only when the flow cannot start at all (no free port, disposed).
+	*/
+	async begin() {
+		if (this.disposed) throw new Error("login flow has been disposed");
+		if (this.statusValue.state === "waiting") return this.statusValue;
+		this.teardown();
+		const port = await this.findPort();
+		const expectedState = this.deps.randomToken?.(32) ?? randomBytes(32).toString("base64url");
+		const settled = new Promise((resolve, reject) => {
+			this.settle = {
+				resolve,
+				reject
+			};
+		});
+		await this.bindServer(port, expectedState);
+		const apiBase = this.readApiBase();
+		this.setStatus({
+			state: "waiting",
+			authUrl: buildCommandAuthUrl({
+				studioBase: studioBaseForApiBase(apiBase),
+				port,
+				state: expectedState
+			})
+		});
+		this.timer = setTimeout(() => {
+			this.teardown();
+			this.setStatus({
+				state: "failed",
+				reason: "timeout",
+				message: "No browser callback arrived within the login window."
+			});
+		}, this.deps.timeoutMs ?? 12e4);
+		this.timer.unref?.();
+		settled.then((credentials) => this.complete(credentials), (failure) => this.failFrom(failure));
+		return this.statusValue;
+	}
+	/** Cancel a waiting attempt; terminal states are untouched. */
+	cancel() {
+		if (this.disposed || this.statusValue.state !== "waiting") return;
+		this.teardown();
+		this.setStatus({
+			state: "failed",
+			reason: "cancelled"
+		});
+	}
+	/** Stop everything; a waiting attempt ends cancelled. Idempotent. */
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const wasWaiting = this.statusValue.state === "waiting";
+		this.teardown();
+		if (wasWaiting) this.setStatus({
+			state: "failed",
+			reason: "cancelled"
+		});
+	}
+	readApiBase() {
+		return (typeof this.deps.apiBase === "function" ? this.deps.apiBase() : this.deps.apiBase) ?? "https://api.commandcode.ai";
+	}
+	setStatus(next) {
+		this.statusValue = next;
+		for (const listener of [...this.listeners]) listener();
+	}
+	/** First free port among the consecutive candidates. */
+	async findPort() {
+		const startPort = this.deps.startPort ?? 5959;
+		const attempts = this.deps.maxPortAttempts ?? 10;
+		for (let index = 0; index < attempts; index += 1) {
+			const candidate = startPort + index;
+			if (await checkPortAvailable(candidate)) return candidate;
+		}
+		throw new Error(`No available port found after ${attempts} attempts starting from port ${startPort}`);
+	}
+	/**
+	* Bind the attempt's loopback server, resolving when the port is live.
+	* Pre-bind failures reject (surfacing from `begin()`); a later server error
+	* settles the live attempt as a tagged failure instead.
+	*/
+	bindServer(port, expectedState) {
+		return new Promise((resolve, reject) => {
+			let binding = true;
+			const server = createServer((request, response) => this.handleCallback(request, response, expectedState));
+			this.server = server;
+			server.once("error", (error) => {
+				if (this.server !== server) return;
+				this.server = void 0;
+				const tagged = new LoginSettleError("error", `Could not bind the login callback server on port ${port}: ${error.code ?? error.message}`);
+				if (binding) {
+					binding = false;
+					reject(tagged);
+				} else this.settle?.reject(tagged);
+			});
+			server.listen(port, "127.0.0.1", () => {
+				if (!binding) return;
+				binding = false;
+				resolve();
+			});
+		});
+	}
+	/** One request against the attempt's callback endpoint (CLI-mirrored). */
+	handleCallback(request, response, expectedState) {
+		response.setHeader("Connection", "close");
+		response.setHeader("Access-Control-Allow-Origin", corsOrigin(request.headers.origin));
+		response.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+		response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+		response.setHeader("Content-Type", "application/json");
+		const json = (code, body) => {
+			response.writeHead(code);
+			response.end(JSON.stringify(body));
+		};
+		if (request.method === "OPTIONS") {
+			response.writeHead(204);
+			response.end();
+			return;
+		}
+		if ((request.url?.split("?")[0] ?? "/") !== "/callback") {
+			json(404, {
+				success: false,
+				error: "Not found"
+			});
+			return;
+		}
+		if (request.method !== "POST") {
+			json(405, {
+				success: false,
+				error: "Method not allowed. Use POST."
+			});
+			return;
+		}
+		let body = "";
+		request.on("data", (chunk) => {
+			body += chunk.toString();
+			if (body.length > 1e4) request.destroy();
+		});
+		request.on("end", () => {
+			let payload;
+			try {
+				payload = JSON.parse(body);
+			} catch {
+				json(400, {
+					success: false,
+					error: "Invalid JSON"
+				});
+				return;
+			}
+			if (typeof payload === "object" && payload !== null && "error" in payload) {
+				const denial = payload;
+				const description = denial.error_description ?? denial.error;
+				this.settleAttempt(json, 200, { success: true }, new LoginSettleError(denial.error === "access_denied" ? "denied" : "error", typeof description === "string" && description !== "" ? description : "Authorization failed"));
+				return;
+			}
+			if (!isCallbackCredentials(payload)) {
+				json(400, {
+					success: false,
+					error: "Missing required fields"
+				});
+				return;
+			}
+			if (payload.state !== expectedState) {
+				json(403, {
+					success: false,
+					error: "Invalid state token"
+				});
+				return;
+			}
+			this.settleAttempt(json, 200, { success: true }, void 0, { ...payload });
+		});
+		request.on("error", () => {});
+	}
+	/** Answer a decisive callback, stop listening, and settle the attempt. */
+	settleAttempt(json, code, body, failure, credentials) {
+		json(code, body);
+		const settle = this.settle;
+		this.teardown();
+		if (settle === void 0) return;
+		if (failure !== void 0) settle.reject(failure);
+		else if (credentials !== void 0) settle.resolve(credentials);
+	}
+	/** Post-validation completion: whoami check, then hand-off to storage. */
+	async complete(credentials) {
+		if (this.disposed || this.statusValue.state !== "waiting") return;
+		const validation = await validateCommandApiKey(this.deps.fetchImpl ?? fetch, this.readApiBase(), credentials.apiKey);
+		if (!validation.valid) {
+			const reason = validation.error === "invalid_key" ? "invalid-key" : validation.error === "network_error" ? "network" : "error";
+			this.setStatus({
+				state: "failed",
+				reason,
+				message: `/alpha/whoami rejected the delivered key (${validation.error}).`
+			});
+			return;
+		}
+		try {
+			await this.deps.storeKey(credentials);
+		} catch (error) {
+			this.setStatus({
+				state: "failed",
+				reason: "unavailable",
+				message: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+		if (this.disposed) return;
+		this.clearTimer();
+		this.setStatus({
+			state: "success",
+			userName: credentials.userName,
+			keyName: credentials.keyName
+		});
+	}
+	/** Map a tagged settle rejection onto the status face. */
+	failFrom(failure) {
+		if (!(failure instanceof LoginSettleError)) return;
+		if (this.disposed || this.statusValue.state !== "waiting") return;
+		this.setStatus({
+			state: "failed",
+			reason: failure.reason,
+			message: failure.message
+		});
+	}
+	clearTimer() {
+		if (this.timer !== void 0) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+	}
+	/** Close the server and watchdog without touching the published status. */
+	teardown() {
+		this.clearTimer();
+		this.server?.close();
+		this.server = void 0;
+		this.settle = void 0;
+	}
+};
+/** A tagged settle failure carrying the stable copy reason. */
+var LoginSettleError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.reason = reason;
+		this.name = "LoginSettleError";
+	}
+};
+/** Echo the Origin header only when the Studio allowlist contains it. */
+function corsOrigin(origin) {
+	return origin !== void 0 && LOGIN_ALLOWED_ORIGINS.includes(origin) ? origin : "";
+}
+//#endregion
 //#region src/index.ts
 /**
 * dsh-commandcode-provider — DeepSeek Harness LLM provider plugin for Command
@@ -2229,9 +2714,20 @@ function apply(ctx, config) {
 			reports: usageReports
 		});
 	});
+	const loginFlow = new CommandCodeLoginFlow({
+		apiBase: () => options().apiBase,
+		storeKey: async ({ apiKey }) => {
+			const ref = credentialRef(current().apiKeyEnv ?? DEFAULT_API_KEY_ENV);
+			const credentials = ctx.get("credentials");
+			if (credentials === void 0) throw new Error("the credentials service is unavailable in this profile; paste the key manually");
+			await credentials.set(ref, apiKey);
+		}
+	});
+	ctx.effect(() => () => loginFlow.dispose(), "dsh-commandcode-provider: login flow");
 	applyUsageRemote(ctx, {
 		adapter,
-		reports: usageReports
+		reports: usageReports,
+		login: loginFlow
 	});
 	installSettingsSection(ctx, NS, Config, config, {
 		setSource: (source) => {
@@ -2241,6 +2737,6 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { BILLING_ACCESS_TTL_MS, COMMAND_CODE_CLI_VERSION, CommandCodeAccountPool, CommandCodeAdapter, CommandCodeUsageService, Config, DEFAULT_API_BASE, DEFAULT_GENERATE_MAX_TOKENS, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_MODELS_CACHE_PATH, DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, KNOWN_DEALS, KNOWN_EFFORTS, KNOWN_IMAGE_MODELS, KNOWN_PEAK_PRICING, KNOWN_PLANS, KNOWN_SUBSCRIPTION_PLANS, KNOWN_THINKING_MODELS, PLAN_LABELS, PLAN_ORDER, PROVIDER, USAGE_REPORT_ENDPOINT, accountUsable, apply, applyCommands, applyUsageRemote, capabilityDescription, commandDefinition, compareByPlan, dealLabel, formatContext, inject, modelVisibleInPlan, name, peakPricingLabel, peakPricingState, planLabel, projectSlugFromPath, resolveAdapterOptions, resolveAuthFileApiKey, selectActiveAccount, subscriptionPlanInfo, usageReportSchema };
+export { BILLING_ACCESS_TTL_MS, COMMAND_CODE_CLI_VERSION, CommandCodeAccountPool, CommandCodeAdapter, CommandCodeLoginFlow, CommandCodeUsageService, Config, DEFAULT_API_BASE, DEFAULT_GENERATE_MAX_TOKENS, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_MODELS_CACHE_PATH, DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, KNOWN_DEALS, KNOWN_EFFORTS, KNOWN_IMAGE_MODELS, KNOWN_PEAK_PRICING, KNOWN_PLANS, KNOWN_SUBSCRIPTION_PLANS, KNOWN_THINKING_MODELS, LOGIN_ALLOWED_ORIGINS, LOGIN_BEGIN_ENDPOINT, LOGIN_BODY_LIMIT_BYTES, LOGIN_CANCEL_ENDPOINT, LOGIN_MAX_PORT_ATTEMPTS, LOGIN_START_PORT, LOGIN_STATUS_ENDPOINT, LOGIN_TIMEOUT_MS, PLAN_LABELS, PLAN_ORDER, PROVIDER, USAGE_REPORT_ENDPOINT, accountUsable, apply, applyCommands, applyUsageRemote, buildCommandAuthUrl, capabilityDescription, commandDefinition, compareByPlan, dealLabel, formatContext, inject, loginStatusSchema, modelVisibleInPlan, name, parseLoginStatus, peakPricingLabel, peakPricingState, planLabel, projectSlugFromPath, resolveAdapterOptions, resolveAuthFileApiKey, selectActiveAccount, studioBaseForApiBase, subscriptionPlanInfo, usageReportSchema, validateCommandApiKey };
 
 //# sourceMappingURL=index.js.map