t3code-cli 0.2.0 → 0.4.0

package/dist/upstream-t3code/packages/contracts/src/ipc.d.ts

@@ -0,0 +1,490 @@
+import type { VcsCreateRefInput, VcsCreateRefResult, VcsCreateWorktreeInput, VcsCreateWorktreeResult, VcsInitInput, VcsListRefsInput, VcsListRefsResult, VcsPullInput, VcsPullResult, VcsRemoveWorktreeInput, VcsSwitchRefInput, VcsSwitchRefResult, GitPreparePullRequestThreadInput, GitPreparePullRequestThreadResult, GitPullRequestRefInput, GitResolvePullRequestResult, VcsStatusInput, VcsStatusResult } from "./git.ts";
+import type { ReviewDiffPreviewInput, ReviewDiffPreviewResult } from "./review.ts";
+import type { FilesystemBrowseInput, FilesystemBrowseResult } from "./filesystem.ts";
+import type { ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectWriteFileInput, ProjectWriteFileResult } from "./project.ts";
+import type { ProviderInstanceId } from "./providerInstance.ts";
+import type { ServerConfig, ServerProcessDiagnosticsResult, ServerProcessResourceHistoryInput, ServerProcessResourceHistoryResult, ServerProviderUpdateInput, ServerProviderUpdatedPayload, ServerRemoveKeybindingResult, ServerSignalProcessInput, ServerSignalProcessResult, ServerTraceDiagnosticsResult, ServerUpsertKeybindingResult } from "./server.ts";
+import type { TerminalAttachInput, TerminalAttachStreamEvent, TerminalClearInput, TerminalCloseInput, TerminalMetadataStreamEvent, TerminalOpenInput, TerminalResizeInput, TerminalRestartInput, TerminalSessionSnapshot, TerminalWriteInput } from "./terminal.ts";
+import type { ServerRemoveKeybindingInput, ServerUpsertKeybindingInput } from "./server.ts";
+import * as Schema from "effect/Schema";
+import type { ClientOrchestrationCommand, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationShellSnapshot, OrchestrationShellStreamItem, OrchestrationSubscribeThreadInput, OrchestrationThreadStreamItem } from "./orchestration.ts";
+import { EnvironmentId } from "./baseSchemas.ts";
+import { AuthAccessTokenResult, AuthSessionState, AuthWebSocketTicketResult } from "./auth.ts";
+import { AdvertisedEndpoint } from "./remoteAccess.ts";
+import { EditorId } from "./editor.ts";
+import { ExecutionEnvironmentDescriptor } from "./environment.ts";
+import type { ClientSettings, ServerSettings, ServerSettingsPatch } from "./settings.ts";
+import type { SourceControlCloneRepositoryInput, SourceControlCloneRepositoryResult, SourceControlDiscoveryResult, SourceControlPublishRepositoryInput, SourceControlPublishRepositoryResult, SourceControlRepositoryInfo, SourceControlRepositoryLookupInput } from "./sourceControl.ts";
+export interface ContextMenuItem<T extends string = string> {
+    id: T;
+    label: string;
+    destructive?: boolean;
+    disabled?: boolean;
+    children?: readonly ContextMenuItem<T>[];
+}
+export interface ContextMenuItemSchemaType {
+    readonly id: string;
+    readonly label: string;
+    readonly destructive?: boolean;
+    readonly disabled?: boolean;
+    readonly children?: readonly ContextMenuItemSchemaType[];
+}
+export declare const ContextMenuItemSchema: Schema.Codec<ContextMenuItemSchemaType>;
+export type DesktopUpdateStatus = "disabled" | "idle" | "checking" | "up-to-date" | "available" | "downloading" | "downloaded" | "error";
+export type DesktopRuntimeArch = "arm64" | "x64" | "other";
+export type DesktopTheme = "light" | "dark" | "system";
+export type DesktopUpdateChannel = "latest" | "nightly";
+export type DesktopAppStageLabel = "Alpha" | "Dev" | "Nightly";
+export declare const DesktopUpdateStatusSchema: Schema.Literals<readonly ["disabled", "idle", "checking", "up-to-date", "available", "downloading", "downloaded", "error"]>;
+export declare const DesktopRuntimeArchSchema: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+export declare const DesktopThemeSchema: Schema.Literals<readonly ["light", "dark", "system"]>;
+export declare const DesktopUpdateChannelSchema: Schema.Literals<readonly ["latest", "nightly"]>;
+export declare const DesktopAppStageLabelSchema: Schema.Literals<readonly ["Alpha", "Dev", "Nightly"]>;
+export interface DesktopAppBranding {
+    baseName: string;
+    stageLabel: DesktopAppStageLabel;
+    displayName: string;
+}
+export declare const DesktopAppBrandingSchema: Schema.Struct<{
+    readonly baseName: Schema.String;
+    readonly stageLabel: Schema.Literals<readonly ["Alpha", "Dev", "Nightly"]>;
+    readonly displayName: Schema.String;
+}>;
+export interface DesktopRuntimeInfo {
+    hostArch: DesktopRuntimeArch;
+    appArch: DesktopRuntimeArch;
+    runningUnderArm64Translation: boolean;
+}
+export declare const DesktopRuntimeInfoSchema: Schema.Struct<{
+    readonly hostArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+    readonly appArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+    readonly runningUnderArm64Translation: Schema.Boolean;
+}>;
+export interface DesktopUpdateState {
+    enabled: boolean;
+    status: DesktopUpdateStatus;
+    channel: DesktopUpdateChannel;
+    currentVersion: string;
+    hostArch: DesktopRuntimeArch;
+    appArch: DesktopRuntimeArch;
+    runningUnderArm64Translation: boolean;
+    availableVersion: string | null;
+    downloadedVersion: string | null;
+    downloadPercent: number | null;
+    checkedAt: string | null;
+    message: string | null;
+    errorContext: "check" | "download" | "install" | null;
+    canRetry: boolean;
+}
+export declare const DesktopUpdateStateSchema: Schema.Struct<{
+    readonly enabled: Schema.Boolean;
+    readonly status: Schema.Literals<readonly ["disabled", "idle", "checking", "up-to-date", "available", "downloading", "downloaded", "error"]>;
+    readonly channel: Schema.Literals<readonly ["latest", "nightly"]>;
+    readonly currentVersion: Schema.String;
+    readonly hostArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+    readonly appArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+    readonly runningUnderArm64Translation: Schema.Boolean;
+    readonly availableVersion: Schema.NullOr<Schema.String>;
+    readonly downloadedVersion: Schema.NullOr<Schema.String>;
+    readonly downloadPercent: Schema.NullOr<Schema.Number>;
+    readonly checkedAt: Schema.NullOr<Schema.String>;
+    readonly message: Schema.NullOr<Schema.String>;
+    readonly errorContext: Schema.NullOr<Schema.Literals<readonly ["check", "download", "install"]>>;
+    readonly canRetry: Schema.Boolean;
+}>;
+export interface DesktopUpdateActionResult {
+    accepted: boolean;
+    completed: boolean;
+    state: DesktopUpdateState;
+}
+export declare const DesktopUpdateActionResultSchema: Schema.Struct<{
+    readonly accepted: Schema.Boolean;
+    readonly completed: Schema.Boolean;
+    readonly state: Schema.Struct<{
+        readonly enabled: Schema.Boolean;
+        readonly status: Schema.Literals<readonly ["disabled", "idle", "checking", "up-to-date", "available", "downloading", "downloaded", "error"]>;
+        readonly channel: Schema.Literals<readonly ["latest", "nightly"]>;
+        readonly currentVersion: Schema.String;
+        readonly hostArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+        readonly appArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+        readonly runningUnderArm64Translation: Schema.Boolean;
+        readonly availableVersion: Schema.NullOr<Schema.String>;
+        readonly downloadedVersion: Schema.NullOr<Schema.String>;
+        readonly downloadPercent: Schema.NullOr<Schema.Number>;
+        readonly checkedAt: Schema.NullOr<Schema.String>;
+        readonly message: Schema.NullOr<Schema.String>;
+        readonly errorContext: Schema.NullOr<Schema.Literals<readonly ["check", "download", "install"]>>;
+        readonly canRetry: Schema.Boolean;
+    }>;
+}>;
+export interface DesktopUpdateCheckResult {
+    checked: boolean;
+    state: DesktopUpdateState;
+}
+export declare const DesktopUpdateCheckResultSchema: Schema.Struct<{
+    readonly checked: Schema.Boolean;
+    readonly state: Schema.Struct<{
+        readonly enabled: Schema.Boolean;
+        readonly status: Schema.Literals<readonly ["disabled", "idle", "checking", "up-to-date", "available", "downloading", "downloaded", "error"]>;
+        readonly channel: Schema.Literals<readonly ["latest", "nightly"]>;
+        readonly currentVersion: Schema.String;
+        readonly hostArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+        readonly appArch: Schema.Literals<readonly ["arm64", "x64", "other"]>;
+        readonly runningUnderArm64Translation: Schema.Boolean;
+        readonly availableVersion: Schema.NullOr<Schema.String>;
+        readonly downloadedVersion: Schema.NullOr<Schema.String>;
+        readonly downloadPercent: Schema.NullOr<Schema.Number>;
+        readonly checkedAt: Schema.NullOr<Schema.String>;
+        readonly message: Schema.NullOr<Schema.String>;
+        readonly errorContext: Schema.NullOr<Schema.Literals<readonly ["check", "download", "install"]>>;
+        readonly canRetry: Schema.Boolean;
+    }>;
+}>;
+export interface DesktopEnvironmentBootstrap {
+    label: string;
+    httpBaseUrl: string | null;
+    wsBaseUrl: string | null;
+    bootstrapToken?: string;
+}
+export declare const DesktopEnvironmentBootstrapSchema: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly httpBaseUrl: Schema.NullOr<Schema.String>;
+    readonly wsBaseUrl: Schema.NullOr<Schema.String>;
+    readonly bootstrapToken: Schema.optionalKey<Schema.String>;
+}>;
+export declare const DesktopSshEnvironmentTargetSchema: Schema.Struct<{
+    readonly alias: Schema.String;
+    readonly hostname: Schema.String;
+    readonly username: Schema.NullOr<Schema.String>;
+    readonly port: Schema.NullOr<Schema.Number>;
+}>;
+export type DesktopSshEnvironmentTarget = typeof DesktopSshEnvironmentTargetSchema.Type;
+export type DesktopSshHostSource = "ssh-config" | "known-hosts";
+export declare const DesktopSshHostSourceSchema: Schema.Literals<readonly ["ssh-config", "known-hosts"]>;
+export interface DesktopDiscoveredSshHost extends DesktopSshEnvironmentTarget {
+    source: DesktopSshHostSource;
+}
+export declare const DesktopDiscoveredSshHostSchema: Schema.Struct<{
+    readonly alias: Schema.String;
+    readonly hostname: Schema.String;
+    readonly username: Schema.NullOr<Schema.String>;
+    readonly port: Schema.NullOr<Schema.Number>;
+    readonly source: Schema.Literals<readonly ["ssh-config", "known-hosts"]>;
+}>;
+export interface DesktopSshEnvironmentBootstrap {
+    target: DesktopSshEnvironmentTarget;
+    httpBaseUrl: string;
+    wsBaseUrl: string;
+    pairingToken: string | null;
+    remotePort?: number;
+    remoteServerKind?: "external" | "managed";
+}
+export declare const DesktopSshEnvironmentBootstrapSchema: Schema.Struct<{
+    readonly target: Schema.Struct<{
+        readonly alias: Schema.String;
+        readonly hostname: Schema.String;
+        readonly username: Schema.NullOr<Schema.String>;
+        readonly port: Schema.NullOr<Schema.Number>;
+    }>;
+    readonly httpBaseUrl: Schema.String;
+    readonly wsBaseUrl: Schema.String;
+    readonly pairingToken: Schema.NullOr<Schema.String>;
+    readonly remotePort: Schema.optionalKey<Schema.Number>;
+    readonly remoteServerKind: Schema.optionalKey<Schema.Literals<readonly ["external", "managed"]>>;
+}>;
+export interface DesktopSshPasswordPromptRequest {
+    requestId: string;
+    destination: string;
+    username: string | null;
+    prompt: string;
+    expiresAt: string;
+}
+export declare const DesktopSshPasswordPromptRequestSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly destination: Schema.String;
+    readonly username: Schema.NullOr<Schema.String>;
+    readonly prompt: Schema.String;
+    readonly expiresAt: Schema.String;
+}>;
+export declare const DesktopSshPasswordPromptCancelledType: "ssh-password-prompt-cancelled";
+export declare const DesktopSshPasswordPromptCancelledResultSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"ssh-password-prompt-cancelled">;
+    readonly message: Schema.String;
+}>;
+export declare const DesktopSshEnvironmentEnsureOptionsSchema: Schema.Struct<{
+    readonly issuePairingToken: Schema.optionalKey<Schema.Boolean>;
+}>;
+export declare const DesktopSshEnvironmentEnsureInputSchema: Schema.Struct<{
+    readonly target: Schema.Struct<{
+        readonly alias: Schema.String;
+        readonly hostname: Schema.String;
+        readonly username: Schema.NullOr<Schema.String>;
+        readonly port: Schema.NullOr<Schema.Number>;
+    }>;
+    readonly options: Schema.optionalKey<Schema.Struct<{
+        readonly issuePairingToken: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+}>;
+export declare const DesktopSshEnvironmentEnsureResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly target: Schema.Struct<{
+        readonly alias: Schema.String;
+        readonly hostname: Schema.String;
+        readonly username: Schema.NullOr<Schema.String>;
+        readonly port: Schema.NullOr<Schema.Number>;
+    }>;
+    readonly httpBaseUrl: Schema.String;
+    readonly wsBaseUrl: Schema.String;
+    readonly pairingToken: Schema.NullOr<Schema.String>;
+    readonly remotePort: Schema.optionalKey<Schema.Number>;
+    readonly remoteServerKind: Schema.optionalKey<Schema.Literals<readonly ["external", "managed"]>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"ssh-password-prompt-cancelled">;
+    readonly message: Schema.String;
+}>]>;
+export declare const DesktopSshHttpBaseUrlInputSchema: Schema.Struct<{
+    readonly httpBaseUrl: Schema.String;
+}>;
+export declare const DesktopSshBearerRequestInputSchema: Schema.Struct<{
+    readonly httpBaseUrl: Schema.String;
+    readonly bearerToken: Schema.String;
+}>;
+export declare const DesktopSshBearerBootstrapInputSchema: Schema.Struct<{
+    readonly httpBaseUrl: Schema.String;
+    readonly credential: Schema.String;
+}>;
+export declare const DesktopSshPasswordPromptResolutionInputSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly password: Schema.NullOr<Schema.String>;
+}>;
+export declare const PersistedSavedEnvironmentRecordSchema: Schema.Struct<{
+    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+    readonly label: Schema.String;
+    readonly wsBaseUrl: Schema.String;
+    readonly httpBaseUrl: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly lastConnectedAt: Schema.NullOr<Schema.String>;
+    readonly desktopSsh: Schema.optionalKey<Schema.Struct<{
+        readonly alias: Schema.String;
+        readonly hostname: Schema.String;
+        readonly username: Schema.NullOr<Schema.String>;
+        readonly port: Schema.NullOr<Schema.Number>;
+    }>>;
+    readonly relayManaged: Schema.optionalKey<Schema.Struct<{
+        readonly relayUrl: Schema.String;
+    }>>;
+}>;
+export type PersistedSavedEnvironmentRecord = typeof PersistedSavedEnvironmentRecordSchema.Type;
+export type DesktopServerExposureMode = "local-only" | "network-accessible";
+export declare const DesktopServerExposureModeSchema: Schema.Literals<readonly ["local-only", "network-accessible"]>;
+export interface DesktopServerExposureState {
+    mode: DesktopServerExposureMode;
+    endpointUrl: string | null;
+    advertisedHost: string | null;
+    tailscaleServeEnabled: boolean;
+    tailscaleServePort: number;
+}
+export declare const DesktopServerExposureStateSchema: Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["local-only", "network-accessible"]>;
+    readonly endpointUrl: Schema.NullOr<Schema.String>;
+    readonly advertisedHost: Schema.NullOr<Schema.String>;
+    readonly tailscaleServeEnabled: Schema.Boolean;
+    readonly tailscaleServePort: Schema.Number;
+}>;
+export interface PickFolderOptions {
+    initialPath?: string | null;
+}
+export declare const PickFolderOptionsSchema: Schema.Struct<{
+    readonly initialPath: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+}>;
+export declare const DesktopCloudAuthFetchInputSchema: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly method: Schema.optionalKey<Schema.String>;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.optionalKey<Schema.String>;
+}>;
+export type DesktopCloudAuthFetchInput = typeof DesktopCloudAuthFetchInputSchema.Type;
+export declare const DesktopCloudAuthFetchResultSchema: Schema.Struct<{
+    readonly ok: Schema.Boolean;
+    readonly status: Schema.Number;
+    readonly statusText: Schema.String;
+    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+    readonly body: Schema.String;
+}>;
+export type DesktopCloudAuthFetchResult = typeof DesktopCloudAuthFetchResultSchema.Type;
+export interface DesktopBridge {
+    getAppBranding: () => DesktopAppBranding | null;
+    getLocalEnvironmentBootstrap: () => DesktopEnvironmentBootstrap | null;
+    getClientSettings: () => Promise<ClientSettings | null>;
+    setClientSettings: (settings: ClientSettings) => Promise<void>;
+    getSavedEnvironmentRegistry: () => Promise<readonly PersistedSavedEnvironmentRecord[]>;
+    setSavedEnvironmentRegistry: (records: readonly PersistedSavedEnvironmentRecord[]) => Promise<void>;
+    getSavedEnvironmentSecret: (environmentId: EnvironmentId) => Promise<string | null>;
+    setSavedEnvironmentSecret: (environmentId: EnvironmentId, secret: string) => Promise<boolean>;
+    removeSavedEnvironmentSecret: (environmentId: EnvironmentId) => Promise<void>;
+    discoverSshHosts: () => Promise<readonly DesktopDiscoveredSshHost[]>;
+    ensureSshEnvironment: (target: DesktopSshEnvironmentTarget, options?: {
+        issuePairingToken?: boolean;
+    }) => Promise<DesktopSshEnvironmentBootstrap>;
+    disconnectSshEnvironment: (target: DesktopSshEnvironmentTarget) => Promise<void>;
+    fetchSshEnvironmentDescriptor: (httpBaseUrl: string) => Promise<ExecutionEnvironmentDescriptor>;
+    bootstrapSshBearerSession: (httpBaseUrl: string, credential: string) => Promise<AuthAccessTokenResult>;
+    fetchSshSessionState: (httpBaseUrl: string, bearerToken: string) => Promise<AuthSessionState>;
+    issueSshWebSocketTicket: (httpBaseUrl: string, bearerToken: string) => Promise<AuthWebSocketTicketResult>;
+    onSshPasswordPrompt: (listener: (request: DesktopSshPasswordPromptRequest) => void) => () => void;
+    resolveSshPasswordPrompt: (requestId: string, password: string | null) => Promise<void>;
+    getServerExposureState: () => Promise<DesktopServerExposureState>;
+    setServerExposureMode: (mode: DesktopServerExposureMode) => Promise<DesktopServerExposureState>;
+    setTailscaleServeEnabled: (input: {
+        readonly enabled: boolean;
+        readonly port?: number;
+    }) => Promise<DesktopServerExposureState>;
+    getAdvertisedEndpoints: () => Promise<readonly AdvertisedEndpoint[]>;
+    pickFolder: (options?: PickFolderOptions) => Promise<string | null>;
+    confirm: (message: string) => Promise<boolean>;
+    setTheme: (theme: DesktopTheme) => Promise<void>;
+    showContextMenu: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+        x: number;
+        y: number;
+    }) => Promise<T | null>;
+    openExternal: (url: string) => Promise<boolean>;
+    createCloudAuthRequest: () => Promise<string>;
+    getCloudAuthToken: () => Promise<string | null>;
+    setCloudAuthToken: (token: string) => Promise<boolean>;
+    clearCloudAuthToken: () => Promise<void>;
+    fetchCloudAuth: (input: DesktopCloudAuthFetchInput) => Promise<DesktopCloudAuthFetchResult>;
+    onCloudAuthCallback: (listener: (rawUrl: string) => void) => () => void;
+    onMenuAction: (listener: (action: string) => void) => () => void;
+    getUpdateState: () => Promise<DesktopUpdateState>;
+    setUpdateChannel: (channel: DesktopUpdateChannel) => Promise<DesktopUpdateState>;
+    checkForUpdate: () => Promise<DesktopUpdateCheckResult>;
+    downloadUpdate: () => Promise<DesktopUpdateActionResult>;
+    installUpdate: () => Promise<DesktopUpdateActionResult>;
+    onUpdateState: (listener: (state: DesktopUpdateState) => void) => () => void;
+}
+/**
+ * APIs bound to the local app shell, not to any particular backend environment.
+ *
+ * These capabilities describe the desktop/browser host that the user is
+ * currently running: dialogs, editor/external-link opening, context menus, and
+ * app-level settings/config access. They must not be used as a proxy for
+ * "whatever environment the user is targeting", because in a multi-environment
+ * world the local shell and a selected backend environment are distinct
+ * concepts.
+ */
+export interface LocalApi {
+    dialogs: {
+        pickFolder: (options?: PickFolderOptions) => Promise<string | null>;
+        confirm: (message: string) => Promise<boolean>;
+    };
+    shell: {
+        openInEditor: (cwd: string, editor: EditorId) => Promise<void>;
+        openExternal: (url: string) => Promise<void>;
+    };
+    contextMenu: {
+        show: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+            x: number;
+            y: number;
+        }) => Promise<T | null>;
+    };
+    persistence: {
+        getClientSettings: () => Promise<ClientSettings | null>;
+        setClientSettings: (settings: ClientSettings) => Promise<void>;
+        getSavedEnvironmentRegistry: () => Promise<readonly PersistedSavedEnvironmentRecord[]>;
+        setSavedEnvironmentRegistry: (records: readonly PersistedSavedEnvironmentRecord[]) => Promise<void>;
+        getSavedEnvironmentSecret: (environmentId: EnvironmentId) => Promise<string | null>;
+        setSavedEnvironmentSecret: (environmentId: EnvironmentId, secret: string) => Promise<boolean>;
+        removeSavedEnvironmentSecret: (environmentId: EnvironmentId) => Promise<void>;
+    };
+    server: {
+        getConfig: () => Promise<ServerConfig>;
+        /**
+         * Refresh provider snapshots. When `input.instanceId` is supplied only that
+         * configured instance is probed; otherwise every configured instance is
+         * refreshed (legacy untargeted refresh).
+         */
+        refreshProviders: (input?: {
+            readonly instanceId?: ProviderInstanceId;
+        }) => Promise<ServerProviderUpdatedPayload>;
+        updateProvider: (input: ServerProviderUpdateInput) => Promise<ServerProviderUpdatedPayload>;
+        upsertKeybinding: (input: ServerUpsertKeybindingInput) => Promise<ServerUpsertKeybindingResult>;
+        removeKeybinding: (input: ServerRemoveKeybindingInput) => Promise<ServerRemoveKeybindingResult>;
+        getSettings: () => Promise<ServerSettings>;
+        updateSettings: (patch: ServerSettingsPatch) => Promise<ServerSettings>;
+        discoverSourceControl: () => Promise<SourceControlDiscoveryResult>;
+        getTraceDiagnostics: () => Promise<ServerTraceDiagnosticsResult>;
+        getProcessDiagnostics: () => Promise<ServerProcessDiagnosticsResult>;
+        getProcessResourceHistory: (input: ServerProcessResourceHistoryInput) => Promise<ServerProcessResourceHistoryResult>;
+        signalProcess: (input: ServerSignalProcessInput) => Promise<ServerSignalProcessResult>;
+    };
+}
+/**
+ * APIs bound to a specific backend environment connection.
+ *
+ * These operations must always be routed with explicit environment context.
+ * They represent remote stateful capabilities such as orchestration, terminal,
+ * project, VCS, and provider operations. In multi-environment mode, each environment gets
+ * its own instance of this surface, and callers should resolve it by
+ * `environmentId` rather than reaching through the local desktop bridge.
+ */
+export interface EnvironmentApi {
+    terminal: {
+        open: (input: typeof TerminalOpenInput.Encoded) => Promise<TerminalSessionSnapshot>;
+        attach: (input: typeof TerminalAttachInput.Encoded, callback: (event: TerminalAttachStreamEvent) => void, options?: {
+            onResubscribe?: () => void;
+        }) => () => void;
+        write: (input: typeof TerminalWriteInput.Encoded) => Promise<void>;
+        resize: (input: typeof TerminalResizeInput.Encoded) => Promise<void>;
+        clear: (input: typeof TerminalClearInput.Encoded) => Promise<void>;
+        restart: (input: typeof TerminalRestartInput.Encoded) => Promise<TerminalSessionSnapshot>;
+        close: (input: typeof TerminalCloseInput.Encoded) => Promise<void>;
+        onMetadata: (callback: (event: TerminalMetadataStreamEvent) => void, options?: {
+            onResubscribe?: () => void;
+        }) => () => void;
+    };
+    projects: {
+        searchEntries: (input: ProjectSearchEntriesInput) => Promise<ProjectSearchEntriesResult>;
+        writeFile: (input: ProjectWriteFileInput) => Promise<ProjectWriteFileResult>;
+    };
+    filesystem: {
+        browse: (input: FilesystemBrowseInput) => Promise<FilesystemBrowseResult>;
+    };
+    sourceControl: {
+        lookupRepository: (input: SourceControlRepositoryLookupInput) => Promise<SourceControlRepositoryInfo>;
+        cloneRepository: (input: SourceControlCloneRepositoryInput) => Promise<SourceControlCloneRepositoryResult>;
+        publishRepository: (input: SourceControlPublishRepositoryInput) => Promise<SourceControlPublishRepositoryResult>;
+    };
+    vcs: {
+        listRefs: (input: VcsListRefsInput) => Promise<VcsListRefsResult>;
+        createWorktree: (input: VcsCreateWorktreeInput) => Promise<VcsCreateWorktreeResult>;
+        removeWorktree: (input: VcsRemoveWorktreeInput) => Promise<void>;
+        createRef: (input: VcsCreateRefInput) => Promise<VcsCreateRefResult>;
+        switchRef: (input: VcsSwitchRefInput) => Promise<VcsSwitchRefResult>;
+        init: (input: VcsInitInput) => Promise<void>;
+        pull: (input: VcsPullInput) => Promise<VcsPullResult>;
+        refreshStatus: (input: VcsStatusInput) => Promise<VcsStatusResult>;
+        onStatus: (input: VcsStatusInput, callback: (status: VcsStatusResult) => void, options?: {
+            onResubscribe?: () => void;
+        }) => () => void;
+    };
+    git: {
+        resolvePullRequest: (input: GitPullRequestRefInput) => Promise<GitResolvePullRequestResult>;
+        preparePullRequestThread: (input: GitPreparePullRequestThreadInput) => Promise<GitPreparePullRequestThreadResult>;
+    };
+    review: {
+        getDiffPreview: (input: ReviewDiffPreviewInput) => Promise<ReviewDiffPreviewResult>;
+    };
+    orchestration: {
+        dispatchCommand: (command: ClientOrchestrationCommand) => Promise<{
+            sequence: number;
+        }>;
+        getTurnDiff: (input: OrchestrationGetTurnDiffInput) => Promise<OrchestrationGetTurnDiffResult>;
+        getFullThreadDiff: (input: OrchestrationGetFullThreadDiffInput) => Promise<OrchestrationGetFullThreadDiffResult>;
+        getArchivedShellSnapshot: () => Promise<OrchestrationShellSnapshot>;
+        subscribeShell: (callback: (event: OrchestrationShellStreamItem) => void, options?: {
+            onResubscribe?: () => void;
+        }) => () => void;
+        subscribeThread: (input: OrchestrationSubscribeThreadInput, callback: (event: OrchestrationThreadStreamItem) => void, options?: {
+            onResubscribe?: () => void;
+        }) => () => void;
+    };
+}

package/dist/upstream-t3code/packages/contracts/src/keybindings.d.ts

@@ -0,0 +1,133 @@
+import * as Schema from "effect/Schema";
+export declare const MAX_KEYBINDING_VALUE_LENGTH = 64;
+export declare const MAX_KEYBINDING_WHEN_LENGTH = 256;
+export declare const MAX_WHEN_EXPRESSION_DEPTH = 64;
+export declare const MAX_SCRIPT_ID_LENGTH = 24;
+export declare const MAX_KEYBINDINGS_COUNT = 256;
+export declare const THREAD_JUMP_KEYBINDING_COMMANDS: readonly ["thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"];
+export type ThreadJumpKeybindingCommand = (typeof THREAD_JUMP_KEYBINDING_COMMANDS)[number];
+export declare const MODEL_PICKER_JUMP_KEYBINDING_COMMANDS: readonly ["modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9"];
+export type ModelPickerJumpKeybindingCommand = (typeof MODEL_PICKER_JUMP_KEYBINDING_COMMANDS)[number];
+export declare const THREAD_KEYBINDING_COMMANDS: readonly ["thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"];
+export type ThreadKeybindingCommand = (typeof THREAD_KEYBINDING_COMMANDS)[number];
+export declare const MODEL_PICKER_KEYBINDING_COMMANDS: readonly ["modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9"];
+export type ModelPickerKeybindingCommand = (typeof MODEL_PICKER_KEYBINDING_COMMANDS)[number];
+export declare const SCRIPT_RUN_COMMAND_PATTERN: Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>;
+export declare const KeybindingCommand: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "commandPalette.toggle", "chat.new", "chat.newLocal", "editor.openFavorite", "modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9", "thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>]>;
+export type KeybindingCommand = typeof KeybindingCommand.Type;
+export declare const KeybindingValue: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+export declare const KeybindingWhen: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+export declare const KeybindingRule: Schema.Struct<{
+    readonly key: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "commandPalette.toggle", "chat.new", "chat.newLocal", "editor.openFavorite", "modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9", "thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+}>;
+export type KeybindingRule = typeof KeybindingRule.Type;
+export declare const KeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly key: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "commandPalette.toggle", "chat.new", "chat.newLocal", "editor.openFavorite", "modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9", "thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+}>>;
+export type KeybindingsConfig = typeof KeybindingsConfig.Type;
+export declare const KeybindingShortcut: Schema.Struct<{
+    readonly key: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly metaKey: Schema.Boolean;
+    readonly ctrlKey: Schema.Boolean;
+    readonly shiftKey: Schema.Boolean;
+    readonly altKey: Schema.Boolean;
+    readonly modKey: Schema.Boolean;
+}>;
+export type KeybindingShortcut = typeof KeybindingShortcut.Type;
+export declare const KeybindingWhenNode: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"identifier">;
+    readonly name: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"not">;
+    readonly node: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"and">;
+    readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"or">;
+    readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+}>]>;
+export type KeybindingWhenNode = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "not";
+    node: KeybindingWhenNode;
+} | {
+    type: "and";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+} | {
+    type: "or";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+};
+export declare const ResolvedKeybindingRule: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "commandPalette.toggle", "chat.new", "chat.newLocal", "editor.openFavorite", "modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9", "thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"identifier">;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"not">;
+        readonly node: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"and">;
+        readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+        readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"or">;
+        readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+        readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>]>>;
+}>;
+export type ResolvedKeybindingRule = typeof ResolvedKeybindingRule.Type;
+export declare const ResolvedKeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "commandPalette.toggle", "chat.new", "chat.newLocal", "editor.openFavorite", "modelPicker.toggle", "modelPicker.jump.1", "modelPicker.jump.2", "modelPicker.jump.3", "modelPicker.jump.4", "modelPicker.jump.5", "modelPicker.jump.6", "modelPicker.jump.7", "modelPicker.jump.8", "modelPicker.jump.9", "thread.previous", "thread.next", "thread.jump.1", "thread.jump.2", "thread.jump.3", "thread.jump.4", "thread.jump.5", "thread.jump.6", "thread.jump.7", "thread.jump.8", "thread.jump.9"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.NonEmptyString, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"identifier">;
+        readonly name: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"not">;
+        readonly node: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"and">;
+        readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+        readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"or">;
+        readonly left: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+        readonly right: Schema.suspend<Schema.Codec<KeybindingWhenNode, KeybindingWhenNode, never, never>>;
+    }>]>>;
+}>>;
+export type ResolvedKeybindingsConfig = typeof ResolvedKeybindingsConfig.Type;
+declare const KeybindingsConfigError_base: Schema.Class<KeybindingsConfigError, Schema.TaggedStruct<"KeybindingsConfigParseError", {
+    readonly configPath: Schema.String;
+    readonly detail: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class KeybindingsConfigError extends KeybindingsConfigError_base {
+    get message(): string;
+}
+export {};