t3code-cli 0.2.0 → 0.4.0

package/dist/src/auth/pairing.d.ts

@@ -0,0 +1,22 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { T3Config } from "../config/service.ts";
+import { AuthConfigError, AuthPairingUrlError, AuthTransportError } from "./error.ts";
+import { T3AuthTransport } from "./transport.ts";
+import type { PairingUrl, PairResult } from "./type.ts";
+declare const T3AuthPairing_base: Context.ServiceClass<T3AuthPairing, "t3cli/T3AuthPairing", {
+    readonly pair: (pairingUrl: string) => Effect.Effect<PairResult, AuthConfigError | AuthPairingUrlError | AuthTransportError>;
+}>;
+export declare class T3AuthPairing extends T3AuthPairing_base {
+}
+export declare const makeT3AuthPairing: () => Effect.Effect<{
+    pair: (pairingUrl: string) => Effect.Effect<{
+        url: string;
+        role: "client" | "owner";
+        expiresAt: string;
+    }, AuthPairingUrlError | AuthConfigError | AuthTransportError, never>;
+}, never, T3Config | T3AuthTransport>;
+export declare const T3AuthPairingLive: Layer.Layer<T3AuthPairing, never, T3Config | T3AuthTransport>;
+export declare function parsePairingUrl(value: string): Effect.Effect<PairingUrl, AuthPairingUrlError>;
+export {};

package/dist/src/auth/schema.d.ts

@@ -0,0 +1,58 @@
+import * as Schema from "effect/Schema";
+export declare const AuthAccessTokenResultSchema: Schema.Struct<{
+    readonly access_token: Schema.String;
+    readonly issued_token_type: Schema.String;
+    readonly token_type: Schema.Literal<"Bearer">;
+    readonly expires_in: Schema.Number;
+    readonly scope: Schema.String;
+}>;
+export type AuthAccessTokenResult = typeof AuthAccessTokenResultSchema.Type;
+export type AuthBearerBootstrapResult = {
+    readonly authenticated: true;
+    readonly role: "owner" | "client";
+    readonly sessionMethod: "bearer-access-token";
+    readonly expiresAt: string;
+    readonly sessionToken: string;
+};
+export declare const AuthSessionStateSchema: Schema.Struct<{
+    readonly authenticated: Schema.Boolean;
+    readonly role: Schema.optionalKey<Schema.Literals<readonly ["owner", "client"]>>;
+    readonly sessionMethod: Schema.optionalKey<Schema.String>;
+    readonly expiresAt: Schema.optionalKey<Schema.String>;
+}>;
+export type AuthSessionState = typeof AuthSessionStateSchema.Type;
+export declare const AuthWebSocketTicketResultSchema: Schema.Struct<{
+    readonly ticket: Schema.String;
+    readonly expiresAt: Schema.String;
+}>;
+export type AuthWebSocketTicketResult = typeof AuthWebSocketTicketResultSchema.Type;
+export declare const AuthLocalRuntimeStateSchema: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly origin: Schema.String;
+}>;
+export type AuthLocalRuntimeState = typeof AuthLocalRuntimeStateSchema.Type;
+export declare const decodeAuthAccessTokenResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly access_token: string;
+    readonly issued_token_type: string;
+    readonly token_type: "Bearer";
+    readonly expires_in: number;
+    readonly scope: string;
+}, Schema.SchemaError, never>;
+export declare const decodeAuthSessionState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly authenticated: boolean;
+    readonly role?: "client" | "owner";
+    readonly sessionMethod?: string;
+    readonly expiresAt?: string;
+}, Schema.SchemaError, never>;
+export declare const decodeAuthWebSocketTicketResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly ticket: string;
+    readonly expiresAt: string;
+}, Schema.SchemaError, never>;
+export declare const decodeAuthLocalRuntimeState: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly version: 1;
+    readonly origin: string;
+}, Schema.SchemaError, never>;
+export declare const decodeAuthLocalRuntimeStateFromJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+    readonly version: 1;
+    readonly origin: string;
+}, Schema.SchemaError, never>;

package/dist/src/auth/service.d.ts

@@ -0,0 +1,14 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
+import type { AuthError } from "./error.ts";
+import type { LocalAuthInput, LocalAuthResult, PairResult } from "./type.ts";
+declare const T3Auth_base: Context.ServiceClass<T3Auth, "t3cli/T3Auth", {
+    readonly pair: (value: string) => Effect.Effect<PairResult, AuthError>;
+    readonly local: (input: LocalAuthInput) => Effect.Effect<LocalAuthResult, AuthError>;
+    readonly status: () => Effect.Effect<AuthSessionState, AuthError>;
+    readonly issueWebSocketTicket: () => Effect.Effect<AuthWebSocketTicketResult, AuthError>;
+}>;
+export declare class T3Auth extends T3Auth_base {
+}
+export {};

package/dist/src/auth/transport.d.ts

@@ -0,0 +1,19 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import type { ResolvedConfig } from "../config/service.ts";
+import { AuthTransportError } from "./error.ts";
+import { type AuthBearerBootstrapResult, type AuthSessionState, type AuthWebSocketTicketResult } from "./schema.ts";
+declare const T3AuthTransport_base: Context.ServiceClass<T3AuthTransport, "t3cli/T3AuthTransport", {
+    readonly bootstrapBearer: (input: {
+        readonly baseUrl: string;
+        readonly credential: string;
+    }) => Effect.Effect<AuthBearerBootstrapResult, AuthTransportError>;
+    readonly getSession: (config: ResolvedConfig) => Effect.Effect<AuthSessionState, AuthTransportError>;
+    readonly issueWebSocketTicket: (config: ResolvedConfig) => Effect.Effect<AuthWebSocketTicketResult, AuthTransportError>;
+}>;
+export declare class T3AuthTransport extends T3AuthTransport_base {
+}
+export declare const T3AuthTransportLive: Layer.Layer<T3AuthTransport, never, HttpClient.HttpClient>;
+export {};

package/dist/src/auth/type.d.ts

@@ -0,0 +1,25 @@
+import type { AuthBearerBootstrapResult } from "./schema.ts";
+export type AuthSessionRole = AuthBearerBootstrapResult["role"];
+export type PairingUrl = {
+    readonly baseUrl: string;
+    readonly credential: string;
+};
+export type PairResult = {
+    readonly url: string;
+    readonly role: AuthBearerBootstrapResult["role"];
+    readonly expiresAt: string;
+};
+export type LocalAuthInput = {
+    readonly baseDir?: string;
+    readonly origin?: string;
+    readonly role: AuthSessionRole;
+    readonly label: string;
+    readonly subject: string;
+};
+export type LocalAuthResult = {
+    readonly url: string;
+    readonly role: AuthSessionRole;
+    readonly expiresAt: string;
+    readonly source: "local";
+    readonly baseDir: string;
+};

package/dist/src/config/error.d.ts

@@ -0,0 +1,18 @@
+import * as Cause from "effect/Cause";
+import * as Schema from "effect/Schema";
+import { PlatformError } from "effect/PlatformError";
+declare const UrlError_base: Schema.Class<UrlError, Schema.TaggedStruct<"UrlError", {
+    readonly message: Schema.String;
+    readonly protocol: Schema.optionalKey<Schema.String>;
+    readonly cause: Schema.optionalKey<Schema.instanceOf<Cause.IllegalArgumentError, Cause.IllegalArgumentError>>;
+}>, Cause.YieldableError>;
+export declare class UrlError extends UrlError_base {
+}
+declare const ConfigError_base: Schema.Class<ConfigError, Schema.TaggedStruct<"ConfigError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [Schema.instanceOf<PlatformError, unknown>, Schema.instanceOf<Schema.SchemaError, unknown>]>>;
+}>, Cause.YieldableError>;
+export declare class ConfigError extends ConfigError_base {
+}
+export type ConfigServiceError = ConfigError | UrlError;
+export {};

package/dist/src/config/layer.d.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import { Environment } from "../environment/service.ts";
+import { ConfigError } from "./error.ts";
+import { T3Config, type StoredConfig } from "./service.ts";
+export declare const makeT3Config: () => Effect.Effect<{
+    readStored: () => Effect.Effect<{
+        readonly url?: string;
+        readonly token?: string;
+    }, ConfigError, never>;
+    writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError, never>;
+    resolve: () => Effect.Effect<{
+        url: string;
+        token: string;
+        source: "config" | "env";
+    }, import("./error.ts").UrlError | ConfigError, never>;
+}, never, Environment | Path.Path | FileSystem.FileSystem>;
+export declare const T3ConfigLive: Layer.Layer<T3Config, never, Environment | Path.Path | FileSystem.FileSystem>;

package/dist/src/config/service.d.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { ConfigError, ConfigServiceError } from "./error.ts";
+export type StoredConfig = {
+    readonly url?: string;
+    readonly token?: string;
+};
+export type ResolvedConfig = {
+    readonly url: string;
+    readonly token: string;
+    readonly source: "env" | "config";
+};
+declare const T3Config_base: Context.ServiceClass<T3Config, "t3cli/T3Config", {
+    readonly readStored: () => Effect.Effect<StoredConfig, ConfigError>;
+    readonly writeStored: (config: StoredConfig) => Effect.Effect<void, ConfigError>;
+    readonly resolve: () => Effect.Effect<ResolvedConfig, ConfigServiceError>;
+}>;
+export declare class T3Config extends T3Config_base {
+}
+export {};

package/dist/src/config/url.d.ts

@@ -0,0 +1,6 @@
+import * as Effect from "effect/Effect";
+import { UrlError } from "./error.ts";
+export declare function normalizeHttpBaseUrl(value: string): Effect.Effect<string, UrlError, never>;
+export declare function toWebSocketBaseUrl(httpBaseUrl: string): Effect.Effect<string, UrlError, never>;
+export declare function toHttpEndpointUrl(httpBaseUrl: string, pathname: string): Effect.Effect<string, UrlError, never>;
+export declare function toWebSocketEndpointUrl(httpBaseUrl: string, pathname: string): Effect.Effect<string, UrlError, never>;

package/dist/src/domain/error.d.ts

@@ -0,0 +1,31 @@
+import * as Schema from "effect/Schema";
+declare const ProjectLookupError_base: Schema.Class<ProjectLookupError, Schema.TaggedStruct<"ProjectLookupError", {
+    readonly message: Schema.String;
+    readonly ref: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectLookupError extends ProjectLookupError_base {
+}
+declare const ModelSelectionError_base: Schema.Class<ModelSelectionError, Schema.TaggedStruct<"ModelSelectionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelSelectionError extends ModelSelectionError_base {
+}
+declare const ThreadEventError_base: Schema.Class<ThreadEventError, Schema.TaggedStruct<"ThreadEventError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ThreadEventError extends ThreadEventError_base {
+}
+declare const ThreadSessionError_base: Schema.Class<ThreadSessionError, Schema.TaggedStruct<"ThreadSessionError", {
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ThreadSessionError extends ThreadSessionError_base {
+}
+declare const ProjectCreateVisibilityError_base: Schema.Class<ProjectCreateVisibilityError, Schema.TaggedStruct<"ProjectCreateVisibilityError", {
+    readonly message: Schema.String;
+    readonly projectId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectCreateVisibilityError extends ProjectCreateVisibilityError_base {
+}
+export type DomainError = ProjectLookupError | ModelSelectionError | ThreadEventError | ThreadSessionError | ProjectCreateVisibilityError;
+export {};

package/dist/src/domain/helpers.d.ts

@@ -0,0 +1,38 @@
+import type * as Path from "effect/Path";
+import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
+export declare function resolveProject(snapshot: OrchestrationShellSnapshot, ref: string, path: Path.Path, cwd: string): {
+    readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly workspaceRoot: string;
+    readonly defaultModelSelection: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+        }[];
+    } | null;
+    readonly scripts: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly command: string;
+        readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+        readonly runOnWorktreeCreate: boolean;
+    }[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly repositoryIdentity?: {
+        readonly canonicalKey: string;
+        readonly locator: {
+            readonly source: "git-remote";
+            readonly remoteName: string;
+            readonly remoteUrl: string;
+        };
+        readonly rootPath?: string;
+        readonly displayName?: string;
+        readonly provider?: string;
+        readonly owner?: string;
+        readonly name?: string;
+    } | null | undefined;
+};
+export declare function findProjectById(snapshot: OrchestrationShellSnapshot, projectId: string): OrchestrationProjectShell | null;

package/dist/src/domain/model-config.d.ts

@@ -0,0 +1,293 @@
+import type { ServerProvider } from "#t3tools/contracts";
+export declare function isSelectableProvider(provider: ServerProvider): boolean;
+export declare function firstSelectableProvider(providers: ReadonlyArray<ServerProvider>): {
+    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+    readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+    readonly enabled: boolean;
+    readonly installed: boolean;
+    readonly version: string | null;
+    readonly status: "error" | "ready" | "warning" | "disabled";
+    readonly auth: {
+        readonly status: "authenticated" | "unknown" | "unauthenticated";
+        readonly type?: string | undefined;
+        readonly label?: string | undefined;
+        readonly email?: string | undefined;
+    };
+    readonly checkedAt: string;
+    readonly models: readonly {
+        readonly slug: string;
+        readonly name: string;
+        readonly isCustom: boolean;
+        readonly capabilities: {
+            readonly optionDescriptors?: readonly ({
+                readonly type: "select";
+                readonly options: readonly {
+                    readonly id: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                    readonly isDefault?: boolean | undefined;
+                }[];
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: string | undefined;
+                readonly promptInjectedValues?: readonly string[] | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly type: "boolean";
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: boolean | undefined;
+                readonly description?: string | undefined;
+            })[] | undefined;
+        } | null;
+        readonly shortName?: string | undefined;
+        readonly subProvider?: string | undefined;
+    }[];
+    readonly slashCommands: readonly {
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input?: {
+            readonly hint: string;
+        } | undefined;
+    }[];
+    readonly skills: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly enabled: boolean;
+        readonly description?: string | undefined;
+        readonly scope?: string | undefined;
+        readonly displayName?: string | undefined;
+        readonly shortDescription?: string | undefined;
+    }[];
+    readonly displayName?: string | undefined;
+    readonly accentColor?: string | undefined;
+    readonly badgeLabel?: string | undefined;
+    readonly continuation?: {
+        readonly groupKey: string;
+    } | undefined;
+    readonly showInteractionModeToggle?: boolean | undefined;
+    readonly message?: string | undefined;
+    readonly availability?: "available" | "unavailable" | undefined;
+    readonly unavailableReason?: string | undefined;
+    readonly versionAdvisory?: {
+        readonly status: "unknown" | "current" | "behind_latest";
+        readonly currentVersion: string | null;
+        readonly latestVersion: string | null;
+        readonly updateCommand: string | null;
+        readonly canUpdate: boolean;
+        readonly checkedAt: string | null;
+        readonly message: string | null;
+    };
+    readonly updateState?: {
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
+        readonly startedAt: string | null;
+        readonly finishedAt: string | null;
+        readonly message: string | null;
+        readonly output: string | null;
+    };
+} | undefined;
+export declare function firstSelectableModel(provider: ServerProvider): {
+    readonly slug: string;
+    readonly name: string;
+    readonly isCustom: boolean;
+    readonly capabilities: {
+        readonly optionDescriptors?: readonly ({
+            readonly type: "select";
+            readonly options: readonly {
+                readonly id: string;
+                readonly label: string;
+                readonly description?: string | undefined;
+                readonly isDefault?: boolean | undefined;
+            }[];
+            readonly id: string;
+            readonly label: string;
+            readonly currentValue?: string | undefined;
+            readonly promptInjectedValues?: readonly string[] | undefined;
+            readonly description?: string | undefined;
+        } | {
+            readonly type: "boolean";
+            readonly id: string;
+            readonly label: string;
+            readonly currentValue?: boolean | undefined;
+            readonly description?: string | undefined;
+        })[] | undefined;
+    } | null;
+    readonly shortName?: string | undefined;
+    readonly subProvider?: string | undefined;
+} | undefined;
+export declare function findSelectableProvider(providers: ReadonlyArray<ServerProvider>, instanceId: string): {
+    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+    readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+    readonly enabled: boolean;
+    readonly installed: boolean;
+    readonly version: string | null;
+    readonly status: "error" | "ready" | "warning" | "disabled";
+    readonly auth: {
+        readonly status: "authenticated" | "unknown" | "unauthenticated";
+        readonly type?: string | undefined;
+        readonly label?: string | undefined;
+        readonly email?: string | undefined;
+    };
+    readonly checkedAt: string;
+    readonly models: readonly {
+        readonly slug: string;
+        readonly name: string;
+        readonly isCustom: boolean;
+        readonly capabilities: {
+            readonly optionDescriptors?: readonly ({
+                readonly type: "select";
+                readonly options: readonly {
+                    readonly id: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                    readonly isDefault?: boolean | undefined;
+                }[];
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: string | undefined;
+                readonly promptInjectedValues?: readonly string[] | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly type: "boolean";
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: boolean | undefined;
+                readonly description?: string | undefined;
+            })[] | undefined;
+        } | null;
+        readonly shortName?: string | undefined;
+        readonly subProvider?: string | undefined;
+    }[];
+    readonly slashCommands: readonly {
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input?: {
+            readonly hint: string;
+        } | undefined;
+    }[];
+    readonly skills: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly enabled: boolean;
+        readonly description?: string | undefined;
+        readonly scope?: string | undefined;
+        readonly displayName?: string | undefined;
+        readonly shortDescription?: string | undefined;
+    }[];
+    readonly displayName?: string | undefined;
+    readonly accentColor?: string | undefined;
+    readonly badgeLabel?: string | undefined;
+    readonly continuation?: {
+        readonly groupKey: string;
+    } | undefined;
+    readonly showInteractionModeToggle?: boolean | undefined;
+    readonly message?: string | undefined;
+    readonly availability?: "available" | "unavailable" | undefined;
+    readonly unavailableReason?: string | undefined;
+    readonly versionAdvisory?: {
+        readonly status: "unknown" | "current" | "behind_latest";
+        readonly currentVersion: string | null;
+        readonly latestVersion: string | null;
+        readonly updateCommand: string | null;
+        readonly canUpdate: boolean;
+        readonly checkedAt: string | null;
+        readonly message: string | null;
+    };
+    readonly updateState?: {
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
+        readonly startedAt: string | null;
+        readonly finishedAt: string | null;
+        readonly message: string | null;
+        readonly output: string | null;
+    };
+} | undefined;
+export declare function filterProvidersForModelListing(input: {
+    readonly providers: ReadonlyArray<ServerProvider>;
+    readonly all: boolean;
+    readonly provider?: string;
+}): {
+    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+    readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+    readonly enabled: boolean;
+    readonly installed: boolean;
+    readonly version: string | null;
+    readonly status: "error" | "ready" | "warning" | "disabled";
+    readonly auth: {
+        readonly status: "authenticated" | "unknown" | "unauthenticated";
+        readonly type?: string | undefined;
+        readonly label?: string | undefined;
+        readonly email?: string | undefined;
+    };
+    readonly checkedAt: string;
+    readonly models: readonly {
+        readonly slug: string;
+        readonly name: string;
+        readonly isCustom: boolean;
+        readonly capabilities: {
+            readonly optionDescriptors?: readonly ({
+                readonly type: "select";
+                readonly options: readonly {
+                    readonly id: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                    readonly isDefault?: boolean | undefined;
+                }[];
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: string | undefined;
+                readonly promptInjectedValues?: readonly string[] | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly type: "boolean";
+                readonly id: string;
+                readonly label: string;
+                readonly currentValue?: boolean | undefined;
+                readonly description?: string | undefined;
+            })[] | undefined;
+        } | null;
+        readonly shortName?: string | undefined;
+        readonly subProvider?: string | undefined;
+    }[];
+    readonly slashCommands: readonly {
+        readonly name: string;
+        readonly description?: string | undefined;
+        readonly input?: {
+            readonly hint: string;
+        } | undefined;
+    }[];
+    readonly skills: readonly {
+        readonly name: string;
+        readonly path: string;
+        readonly enabled: boolean;
+        readonly description?: string | undefined;
+        readonly scope?: string | undefined;
+        readonly displayName?: string | undefined;
+        readonly shortDescription?: string | undefined;
+    }[];
+    readonly displayName?: string | undefined;
+    readonly accentColor?: string | undefined;
+    readonly badgeLabel?: string | undefined;
+    readonly continuation?: {
+        readonly groupKey: string;
+    } | undefined;
+    readonly showInteractionModeToggle?: boolean | undefined;
+    readonly message?: string | undefined;
+    readonly availability?: "available" | "unavailable" | undefined;
+    readonly unavailableReason?: string | undefined;
+    readonly versionAdvisory?: {
+        readonly status: "unknown" | "current" | "behind_latest";
+        readonly currentVersion: string | null;
+        readonly latestVersion: string | null;
+        readonly updateCommand: string | null;
+        readonly canUpdate: boolean;
+        readonly checkedAt: string | null;
+        readonly message: string | null;
+    };
+    readonly updateState?: {
+        readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
+        readonly startedAt: string | null;
+        readonly finishedAt: string | null;
+        readonly message: string | null;
+        readonly output: string | null;
+    };
+}[];