@agent-api/app-engine 0.0.1

package/dist/engine/services.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./engine/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./engine/index.js";

package/dist/profile.d.ts

@@ -0,0 +1,57 @@
+import { AgentAPI, type ApprovedDeviceAuth } from "@agent-api/sdk";
+import { Profile } from "./config.js";
+export interface RuntimeProfile {
+    profile: Profile;
+    token: string;
+    client: AgentAPI;
+}
+export interface AuthStatus {
+    profile: string;
+    baseURL: string;
+    authType: Profile["auth"]["type"];
+    me?: unknown;
+}
+export declare class AuthSessionExpiredError extends Error {
+    readonly profile: string;
+    readonly baseURL: string;
+    constructor(profile: Profile, message?: string);
+}
+export declare function loginWithAPIKey(options: {
+    profile: string;
+    baseURL?: string;
+    apiKey: string;
+}): Promise<Profile>;
+export declare function loginWithBrowser(options: {
+    profile: string;
+    baseURL?: string;
+    clientName?: string;
+    openBrowser?: boolean;
+}): Promise<Profile>;
+export declare function startBrowserAuthChallenge(options: {
+    baseURL?: string;
+    clientName?: string;
+}): Promise<import("@agent-api/sdk").DeviceAuthStart>;
+export declare function waitForBrowserAuthChallenge(options: {
+    baseURL?: string;
+    challenge: Awaited<ReturnType<typeof startBrowserAuthChallenge>>;
+    on_poll?: Parameters<AgentAPI["auth"]["waitForDeviceAuth"]>[0]["on_poll"];
+}): Promise<ApprovedDeviceAuth>;
+export declare function saveBrowserProfile(name: string, baseURL: string, session: ApprovedDeviceAuth): Promise<Profile>;
+export declare function resolveRuntimeProfile(profileName?: string): Promise<RuntimeProfile>;
+export declare function getAuthStatus(profileName?: string): Promise<AuthStatus>;
+export declare function refreshActiveProfileIfNeeded(profileName?: string, refreshWindowMs?: number): Promise<{
+    profile: Profile;
+    refreshed: boolean;
+}>;
+export declare function refreshIfNeeded(profile: Profile, refreshWindowMs?: number): Promise<Profile>;
+export declare function browserAccessTokenExpiresWithin(profile: Profile, refreshWindowMs: number, now?: number): boolean;
+export declare function refreshBrowserSession(profile: Profile): Promise<Profile>;
+export declare function listProfiles(): Promise<{
+    active: string;
+    profiles: Profile[];
+}>;
+export declare function useProfile(name: string): Promise<void>;
+export declare function deleteProfile(name: string): Promise<void>;
+export declare function profileSummary(profile: Profile, active?: boolean): string;
+export declare function formatDeviceUserCode(code: string): string;
+export declare function openBrowserURL(url: string): Promise<void>;

package/dist/profile.js

@@ -0,0 +1,211 @@
+import { AgentAPI, browserAuthSessionExpiresWithin } from "@agent-api/sdk";
+import { execFile } from "node:child_process";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+import { activeProfile, defaultBaseURL, loadConfig, redactSecret, saveConfig, upsertProfile, } from "./config.js";
+const execFileAsync = promisify(execFile);
+export class AuthSessionExpiredError extends Error {
+    profile;
+    baseURL;
+    constructor(profile, message = "browser session refresh failed") {
+        super([
+            "Browser session expired or could not be refreshed.",
+            `Run: agent-api auth login --profile ${profile.name} --base-url ${profile.baseURL}`,
+            `Details: ${message}`,
+        ].join("\n"));
+        this.name = "AuthSessionExpiredError";
+        this.profile = profile.name;
+        this.baseURL = profile.baseURL;
+    }
+}
+export async function loginWithAPIKey(options) {
+    const profile = await upsertProfile({
+        name: options.profile,
+        baseURL: normalizeBaseURL(options.baseURL),
+        auth: { type: "api_key", apiKey: options.apiKey.trim() },
+    });
+    return profile;
+}
+export async function loginWithBrowser(options) {
+    const baseURL = normalizeBaseURL(options.baseURL);
+    const challenge = await startBrowserAuthChallenge({ baseURL, clientName: options.clientName });
+    console.log(`Open this URL to authorize the CLI:\n${challenge.verification_uri_complete}\n`);
+    console.log(`Code: ${formatDeviceUserCode(challenge.user_code)}\n`);
+    if (options.openBrowser !== false) {
+        await openBrowserURL(challenge.verification_uri_complete).catch((error) => {
+            console.warn(`Could not open browser automatically: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    console.log("Waiting for browser approval...");
+    const session = await waitForBrowserAuthChallenge({
+        baseURL,
+        challenge,
+        on_poll(result) {
+            if (result.status && result.status !== "pending") {
+                console.log(`Status: ${result.status}`);
+            }
+        },
+    });
+    const profile = await saveBrowserProfile(options.profile, baseURL, session);
+    console.log(`Signed in as profile "${profile.name}".`);
+    return profile;
+}
+export async function startBrowserAuthChallenge(options) {
+    const baseURL = normalizeBaseURL(options.baseURL);
+    const client = new AgentAPI({ baseURL });
+    return await client.auth.startDeviceAuth({ client_name: options.clientName || "Agent API CLI" });
+}
+export async function waitForBrowserAuthChallenge(options) {
+    const baseURL = normalizeBaseURL(options.baseURL);
+    const client = new AgentAPI({ baseURL });
+    return await client.auth.waitForDeviceAuth({
+        device_code: options.challenge.device_code,
+        interval_seconds: options.challenge.interval_seconds,
+        timeout_ms: Math.max(0, options.challenge.expires_at * 1000 - Date.now()),
+        on_poll: options.on_poll,
+    });
+}
+export async function saveBrowserProfile(name, baseURL, session) {
+    return await upsertProfile({
+        name,
+        baseURL,
+        auth: {
+            type: "browser",
+            accessToken: session.access_token,
+            refreshToken: session.refresh_token,
+            accessTokenExpiresAt: session.access_token_expires_at,
+            refreshTokenExpiresAt: session.refresh_token_expires_at,
+        },
+    });
+}
+export async function resolveRuntimeProfile(profileName) {
+    const { profile: fresh } = await refreshActiveProfileIfNeeded(profileName);
+    const token = fresh.auth.type === "api_key" ? fresh.auth.apiKey : fresh.auth.accessToken;
+    return {
+        profile: fresh,
+        token,
+        client: new AgentAPI({ apiKey: token, baseURL: fresh.baseURL }),
+    };
+}
+export async function getAuthStatus(profileName) {
+    const runtime = await resolveRuntimeProfile(profileName);
+    const response = await fetch(`${runtime.profile.baseURL}/v1/me`, {
+        headers: { Authorization: `Bearer ${runtime.token}` },
+    });
+    const payload = await response.json().catch(() => undefined);
+    if (!response.ok) {
+        throw new Error(errorMessageFromPayload(payload) || `whoami failed with ${response.status}`);
+    }
+    return {
+        profile: runtime.profile.name,
+        baseURL: runtime.profile.baseURL,
+        authType: runtime.profile.auth.type,
+        me: payload,
+    };
+}
+export async function refreshActiveProfileIfNeeded(profileName, refreshWindowMs = 60_000) {
+    const profile = await activeProfile(profileName);
+    const shouldRefresh = browserAccessTokenExpiresWithin(profile, refreshWindowMs);
+    const fresh = await refreshIfNeeded(profile, refreshWindowMs);
+    return { profile: fresh, refreshed: shouldRefresh && profile.auth.type === "browser" };
+}
+export async function refreshIfNeeded(profile, refreshWindowMs = 60_000) {
+    if (profile.auth.type !== "browser")
+        return profile;
+    const expiresAtMs = profile.auth.accessTokenExpiresAt * 1000;
+    if (expiresAtMs - Date.now() > refreshWindowMs)
+        return profile;
+    const refreshed = await refreshBrowserSession(profile);
+    const config = await loadConfig();
+    config.profiles[profile.name] = refreshed;
+    await saveConfig(config);
+    return refreshed;
+}
+export function browserAccessTokenExpiresWithin(profile, refreshWindowMs, now = Date.now()) {
+    if (profile.auth.type !== "browser")
+        return false;
+    return browserAuthSessionExpiresWithin({ access_token_expires_at: profile.auth.accessTokenExpiresAt }, refreshWindowMs, now);
+}
+export async function refreshBrowserSession(profile) {
+    if (profile.auth.type !== "browser")
+        return profile;
+    const client = new AgentAPI({ baseURL: profile.baseURL });
+    let session;
+    try {
+        session = await client.auth.refreshBrowserSession({ refresh_token: profile.auth.refreshToken });
+    }
+    catch (error) {
+        throw new AuthSessionExpiredError(profile, error instanceof Error ? error.message : String(error));
+    }
+    return {
+        ...profile,
+        auth: {
+            type: "browser",
+            accessToken: session.access_token,
+            refreshToken: session.refresh_token || profile.auth.refreshToken,
+            accessTokenExpiresAt: session.access_token_expires_at,
+            refreshTokenExpiresAt: session.refresh_token_expires_at || profile.auth.refreshTokenExpiresAt,
+        },
+        updatedAt: Math.floor(Date.now() / 1000),
+    };
+}
+export async function listProfiles() {
+    const config = await loadConfig();
+    return { active: config.activeProfile, profiles: Object.values(config.profiles).sort((a, b) => a.name.localeCompare(b.name)) };
+}
+export async function useProfile(name) {
+    const config = await loadConfig();
+    if (!config.profiles[name])
+        throw new Error(`Profile not found: ${name}`);
+    config.activeProfile = name;
+    await saveConfig(config);
+}
+export async function deleteProfile(name) {
+    const config = await loadConfig();
+    delete config.profiles[name];
+    if (config.activeProfile === name) {
+        config.activeProfile = Object.keys(config.profiles).sort()[0] || "default";
+    }
+    await saveConfig(config);
+}
+export function profileSummary(profile, active = false) {
+    const auth = profile.auth.type === "api_key"
+        ? `api_key ${redactSecret(profile.auth.apiKey)}`
+        : `browser ${redactSecret(profile.auth.accessToken)}`;
+    return `${active ? "*" : " "} ${profile.name}\t${profile.baseURL}\t${auth}`;
+}
+function errorMessageFromPayload(payload) {
+    if (payload && typeof payload === "object") {
+        const error = payload.error;
+        if (error && typeof error === "object") {
+            const message = error.message;
+            if (typeof message === "string")
+                return message;
+        }
+        const message = payload.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return "";
+}
+function normalizeBaseURL(baseURL) {
+    return (baseURL || process.env.AGENT_API_BASE_URL || defaultBaseURL).replace(/\/+$/, "");
+}
+export function formatDeviceUserCode(code) {
+    const normalized = code.replace(/[-\s]/g, "").toUpperCase();
+    if (normalized.length <= 4)
+        return normalized;
+    return `${normalized.slice(0, 4)}-${normalized.slice(4)}`;
+}
+export async function openBrowserURL(url) {
+    const current = platform();
+    if (current === "darwin") {
+        await execFileAsync("open", [url]);
+        return;
+    }
+    if (current === "win32") {
+        await execFileAsync("cmd", ["/c", "start", "", url]);
+        return;
+    }
+    await execFileAsync("xdg-open", [url]);
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,23 @@
+import type { LocalRuntime, LocalRuntimeOptions } from "@agent-api/sdk/local";
+export declare const defaultAppName = "agent-tui";
+export declare const defaultAppAuthor = "AgentsWay";
+export declare const defaultAppVersion = "0.3.0";
+export interface AgentAppRuntimeOptions extends Omit<LocalRuntimeOptions, "appName" | "appAuthor"> {
+    appName?: string;
+    appAuthor?: string;
+    appVersion?: string;
+    legacyAppName?: string | null;
+}
+export interface AgentAppRuntimeContext {
+    appName: string;
+    appAuthor: string;
+    appVersion: string;
+    legacyAppName?: string | null;
+    runtime: LocalRuntime;
+    legacyRuntime?: LocalRuntime;
+}
+export declare let runtime: LocalRuntime;
+export declare function configureAgentAppRuntime(options?: AgentAppRuntimeOptions): AgentAppRuntimeContext;
+export declare function currentAgentAppRuntime(): AgentAppRuntimeContext;
+export declare function appVersion(): string;
+export declare function ensureRuntime(): Promise<LocalRuntime>;

package/dist/runtime/index.js

@@ -0,0 +1,177 @@
+import { createLocalRuntime } from "@agent-api/sdk/local";
+import { cp, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const defaultAppName = "agent-tui";
+export const defaultAppAuthor = "AgentsWay";
+export const defaultAppVersion = "0.3.0";
+const defaultLegacyAppName = "agent-api-cli";
+let migrationPromise = null;
+let runtimeContext = createRuntimeContext();
+export let runtime = runtimeContext.runtime;
+export function configureAgentAppRuntime(options = {}) {
+    runtimeContext = createRuntimeContext(options);
+    runtime = runtimeContext.runtime;
+    migrationPromise = null;
+    return runtimeContext;
+}
+export function currentAgentAppRuntime() {
+    return runtimeContext;
+}
+export function appVersion() {
+    return runtimeContext.appVersion;
+}
+export async function ensureRuntime() {
+    migrationPromise ??= migrateLegacyRuntime();
+    await migrationPromise;
+    await runtime.ensure();
+    await splitMonolithicConfig();
+    return runtime;
+}
+async function migrateLegacyRuntime() {
+    if (!runtimeContext.legacyRuntime)
+        return;
+    await migrateLegacyConfigDirectory(runtimeContext.legacyRuntime);
+    for (const key of ["data", "cache", "logs"]) {
+        await moveDirectoryIfNeeded(runtimeContext.legacyRuntime.dirs[key], runtime.dirs[key]);
+    }
+}
+async function moveDirectoryIfNeeded(from, to) {
+    if (from === to || !(await isDirectory(from)))
+        return;
+    await mkdir(path.dirname(to), { recursive: true });
+    if (await pathExists(to)) {
+        await cp(from, to, { recursive: true, errorOnExist: false, force: false });
+        await rm(from, { recursive: true, force: true });
+        return;
+    }
+    try {
+        await rename(from, to);
+    }
+    catch (error) {
+        if (error?.code !== "EXDEV")
+            throw error;
+        await cp(from, to, { recursive: true, errorOnExist: false });
+        await rm(from, { recursive: true, force: true });
+    }
+}
+async function migrateLegacyConfigDirectory(legacyRuntime) {
+    const from = legacyRuntime.dirs.config;
+    const to = runtime.dirs.config;
+    if (from === to || !(await isDirectory(from)))
+        return;
+    await mkdir(to, { recursive: true });
+    const legacyProfilesPath = path.join(from, "profiles.json");
+    const profilesPath = path.join(to, "profiles.json");
+    const legacyRaw = await readJSONRecord(legacyProfilesPath);
+    if (legacyRaw) {
+        const nextRaw = await readJSONRecord(profilesPath) ?? {};
+        const legacyProfiles = recordValue(legacyRaw.profiles);
+        const nextProfiles = recordValue(nextRaw.profiles);
+        const mergedProfiles = { ...legacyProfiles, ...nextProfiles };
+        const activeProfile = typeof nextRaw.activeProfile === "string"
+            ? nextRaw.activeProfile
+            : typeof legacyRaw.activeProfile === "string"
+                ? legacyRaw.activeProfile
+                : "default";
+        await writeJSON(profilesPath, { ...nextRaw, activeProfile, profiles: mergedProfiles });
+        const configurationPath = path.join(to, "configuration.json");
+        if ("workbench" in legacyRaw && !(await pathExists(configurationPath))) {
+            await writeJSON(configurationPath, { workbench: recordValue(legacyRaw.workbench) });
+        }
+        const conversationsPath = path.join(to, "conversations.json");
+        if ("conversations" in legacyRaw && !(await pathExists(conversationsPath))) {
+            await writeJSON(conversationsPath, { conversations: recordValue(legacyRaw.conversations) });
+        }
+    }
+    await copyFileIfMissing(path.join(from, "configuration.json"), path.join(to, "configuration.json"));
+    await copyFileIfMissing(path.join(from, "conversations.json"), path.join(to, "conversations.json"));
+    await rm(from, { recursive: true, force: true });
+}
+async function splitMonolithicConfig() {
+    const profilesPath = path.join(runtime.dirs.config, "profiles.json");
+    const raw = await readJSONRecord(profilesPath);
+    if (!raw)
+        return;
+    let changed = false;
+    if ("workbench" in raw && !(await pathExists(path.join(runtime.dirs.config, "configuration.json")))) {
+        await writeJSON(path.join(runtime.dirs.config, "configuration.json"), { workbench: raw.workbench && typeof raw.workbench === "object" ? raw.workbench : {} });
+    }
+    if ("workbench" in raw) {
+        delete raw.workbench;
+        changed = true;
+    }
+    if ("conversations" in raw && !(await pathExists(path.join(runtime.dirs.config, "conversations.json")))) {
+        await writeJSON(path.join(runtime.dirs.config, "conversations.json"), {
+            conversations: raw.conversations && typeof raw.conversations === "object" ? raw.conversations : {},
+        });
+    }
+    if ("conversations" in raw) {
+        delete raw.conversations;
+        changed = true;
+    }
+    if (changed) {
+        await writeJSON(profilesPath, raw);
+    }
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function readJSONRecord(file) {
+    try {
+        const value = JSON.parse(await readFile(file, "utf8"));
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function writeJSON(file, value) {
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+async function copyFileIfMissing(from, to) {
+    if (!(await pathExists(from)) || await pathExists(to))
+        return;
+    await mkdir(path.dirname(to), { recursive: true });
+    await cp(from, to, { errorOnExist: true, force: false });
+}
+async function pathExists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function isDirectory(file) {
+    try {
+        return (await stat(file)).isDirectory();
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function createRuntimeContext(options = {}) {
+    const appName = options.appName || defaultAppName;
+    const appAuthor = options.appAuthor || defaultAppAuthor;
+    const appVersion = options.appVersion || defaultAppVersion;
+    const runtimeOptions = { ...options, appName, appAuthor };
+    delete runtimeOptions.appVersion;
+    delete runtimeOptions.legacyAppName;
+    const legacyAppName = "legacyAppName" in options ? options.legacyAppName : defaultLegacyAppName;
+    return {
+        appName,
+        appAuthor,
+        appVersion,
+        legacyAppName,
+        runtime: createLocalRuntime(runtimeOptions),
+        legacyRuntime: legacyAppName ? createLocalRuntime({ ...runtimeOptions, appName: legacyAppName }) : undefined,
+    };
+}

package/dist/update.d.ts

@@ -0,0 +1,16 @@
+export interface UpdateCheckResult {
+    current: string;
+    latest: string;
+    packageName: string;
+    updateAvailable: boolean;
+}
+export interface UpdateCheckOptions {
+    currentVersion?: string;
+    packageName?: string;
+    registryURL?: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare function checkForUpdate(options?: UpdateCheckOptions): Promise<UpdateCheckResult | null>;
+export declare function formatUpdateNotice(result: UpdateCheckResult): string;
+export declare function compareVersions(a: string, b: string): number;

package/dist/update.js

@@ -0,0 +1,74 @@
+import { appVersion } from "./runtime/index.js";
+const defaultPackageName = "@agent-api/cli";
+const defaultRegistryURL = "https://registry.npmjs.org";
+export async function checkForUpdate(options = {}) {
+    const packageName = options.packageName || process.env.AGENT_TUI_UPDATE_PACKAGE || defaultPackageName;
+    const current = options.currentVersion || appVersion();
+    const registryURL = (options.registryURL || process.env.AGENT_TUI_NPM_REGISTRY || defaultRegistryURL).replace(/\/+$/, "");
+    const timeoutMs = options.timeoutMs ?? 1500;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signal = combineSignals(options.signal, controller.signal);
+    try {
+        const response = await fetch(`${registryURL}/${encodeURIComponent(packageName).replace(/^%40/, "@")}/latest`, {
+            headers: { Accept: "application/json" },
+            signal,
+        });
+        if (!response.ok)
+            return null;
+        const payload = await response.json().catch(() => undefined);
+        const latest = typeof payload?.version === "string" ? payload.version : "";
+        if (!latest)
+            return null;
+        return {
+            current,
+            latest,
+            packageName,
+            updateAvailable: compareVersions(latest, current) > 0,
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function formatUpdateNotice(result) {
+    return `Update available: ${result.packageName} ${result.current} -> ${result.latest}. Run: npm install -g ${result.packageName}@latest`;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const delta = (left[index] ?? 0) - (right[index] ?? 0);
+        if (delta !== 0)
+            return delta > 0 ? 1 : -1;
+    }
+    return 0;
+}
+function parseVersion(version) {
+    return version
+        .replace(/^[^\d]*/, "")
+        .split(/[.-]/)
+        .slice(0, 3)
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+}
+function combineSignals(...signals) {
+    const active = signals.filter((signal) => Boolean(signal));
+    if (active.length === 1)
+        return active[0];
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    for (const signal of active) {
+        if (signal.aborted) {
+            controller.abort();
+            break;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}

package/dist/workbench/auth-controller.d.ts

@@ -0,0 +1,43 @@
+import { deleteProfile, getAuthStatus, loginWithAPIKey, openBrowserURL, refreshActiveProfileIfNeeded, saveBrowserProfile, startBrowserAuthChallenge, waitForBrowserAuthChallenge, type AuthStatus } from "../profile.js";
+export interface WorkbenchAuthController {
+    check(profile?: string, refreshWindowMs?: number): Promise<{
+        profileName: string;
+        refreshed: boolean;
+    }>;
+    loginAPIKey(input: {
+        profile: string;
+        baseURL: string;
+        apiKey: string;
+    }): Promise<{
+        profileName: string;
+    }>;
+    loginBrowser(input: {
+        profile: string;
+        baseURL: string;
+        clientName?: string;
+        onChallenge?: (challenge: {
+            url: string;
+            code: string;
+        }) => void;
+        onStatus?: (status: string) => void;
+    }): Promise<{
+        profileName: string;
+    }>;
+    deleteProfile(name: string): Promise<void>;
+    statusText(profile?: string): Promise<string>;
+    refresh(profile?: string, refreshWindowMs?: number): Promise<{
+        refreshed: boolean;
+    }>;
+}
+export interface WorkbenchAuthControllerOptions {
+    refreshActiveProfileIfNeededImpl?: typeof refreshActiveProfileIfNeeded;
+    loginWithAPIKeyImpl?: typeof loginWithAPIKey;
+    startBrowserAuthChallengeImpl?: typeof startBrowserAuthChallenge;
+    openBrowserURLImpl?: typeof openBrowserURL;
+    waitForBrowserAuthChallengeImpl?: typeof waitForBrowserAuthChallenge;
+    saveBrowserProfileImpl?: typeof saveBrowserProfile;
+    deleteProfileImpl?: typeof deleteProfile;
+    getAuthStatusImpl?: typeof getAuthStatus;
+}
+export declare function createWorkbenchAuthController(options?: WorkbenchAuthControllerOptions): WorkbenchAuthController;
+export declare function authStatusText(status: AuthStatus): string;