@otto-code/protocol 0.5.0

package/dist/schedule/rpc-schemas.js

@@ -0,0 +1,155 @@
+import { z } from "zod";
+import { ScheduleCadenceSchema, ScheduleRunSchema, ScheduleSummarySchema, StoredScheduleSchema, ScheduleTargetSchema, } from "./types.js";
+const ScheduleCreateNewAgentConfigSchema = ScheduleTargetSchema.options[1].shape.config;
+const ScheduleCreateTargetSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("self"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("agent"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("new-agent"),
+        config: ScheduleCreateNewAgentConfigSchema,
+    }),
+]);
+export const ScheduleCreateRequestSchema = z.object({
+    type: z.literal("schedule/create"),
+    requestId: z.string(),
+    prompt: z.string().min(1),
+    name: z.string().optional(),
+    cadence: ScheduleCadenceSchema,
+    target: ScheduleCreateTargetSchema,
+    maxRuns: z.number().int().positive().optional(),
+    expiresAt: z.string().optional(),
+    runOnCreate: z.boolean().optional(),
+});
+export const ScheduleListRequestSchema = z.object({
+    type: z.literal("schedule/list"),
+    requestId: z.string(),
+});
+export const ScheduleInspectRequestSchema = z.object({
+    type: z.literal("schedule/inspect"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleLogsRequestSchema = z.object({
+    type: z.literal("schedule/logs"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const SchedulePauseRequestSchema = z.object({
+    type: z.literal("schedule/pause"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleResumeRequestSchema = z.object({
+    type: z.literal("schedule/resume"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleDeleteRequestSchema = z.object({
+    type: z.literal("schedule/delete"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+export const ScheduleRunOnceRequestSchema = z.object({
+    type: z.literal("schedule/run-once"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+});
+const ScheduleUpdateNewAgentConfigSchema = z.object({
+    provider: z.string().trim().min(1).optional(),
+    model: z.string().trim().min(1).nullable().optional(),
+    modeId: z.string().trim().min(1).nullable().optional(),
+    thinkingOptionId: z.string().trim().min(1).nullable().optional(),
+    archiveOnFinish: z.boolean().optional(),
+    isolation: z.enum(["local", "worktree"]).optional(),
+    cwd: z.string().trim().min(1).optional(),
+});
+export const ScheduleUpdateRequestSchema = z.object({
+    type: z.literal("schedule/update"),
+    requestId: z.string(),
+    scheduleId: z.string(),
+    name: z.string().nullable().optional(),
+    prompt: z.string().min(1).optional(),
+    cadence: ScheduleCadenceSchema.optional(),
+    newAgentConfig: ScheduleUpdateNewAgentConfigSchema.optional(),
+    maxRuns: z.number().int().positive().nullable().optional(),
+    expiresAt: z.string().nullable().optional(),
+});
+export const ScheduleCreateResponseSchema = z.object({
+    type: z.literal("schedule/create/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleListResponseSchema = z.object({
+    type: z.literal("schedule/list/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedules: z.array(ScheduleSummarySchema),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleInspectResponseSchema = z.object({
+    type: z.literal("schedule/inspect/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleLogsResponseSchema = z.object({
+    type: z.literal("schedule/logs/response"),
+    payload: z.object({
+        requestId: z.string(),
+        runs: z.array(ScheduleRunSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const SchedulePauseResponseSchema = z.object({
+    type: z.literal("schedule/pause/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleResumeResponseSchema = z.object({
+    type: z.literal("schedule/resume/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: ScheduleSummarySchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleDeleteResponseSchema = z.object({
+    type: z.literal("schedule/delete/response"),
+    payload: z.object({
+        requestId: z.string(),
+        scheduleId: z.string(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleRunOnceResponseSchema = z.object({
+    type: z.literal("schedule/run-once/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const ScheduleUpdateResponseSchema = z.object({
+    type: z.literal("schedule/update/response"),
+    payload: z.object({
+        requestId: z.string(),
+        schedule: StoredScheduleSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+//# sourceMappingURL=rpc-schemas.js.map

package/dist/schedule/types.d.ts

@@ -0,0 +1,236 @@
+import { z } from "zod";
+export declare const ScheduleStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    active: "active";
+    paused: "paused";
+}>;
+export type ScheduleStatus = z.infer<typeof ScheduleStatusSchema>;
+export declare const ScheduleCadenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"every">;
+    everyMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type ScheduleCadence = z.infer<typeof ScheduleCadenceSchema>;
+export declare const ScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"agent">;
+    agentId: z.ZodGUID;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"new-agent">;
+    config: z.ZodObject<{
+        provider: z.ZodString;
+        cwd: z.ZodString;
+        personality: z.ZodOptional<z.ZodString>;
+        modeId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        thinkingOptionId: z.ZodOptional<z.ZodString>;
+        archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+        isolation: z.ZodOptional<z.ZodEnum<{
+            worktree: "worktree";
+            local: "local";
+        }>>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        approvalPolicy: z.ZodOptional<z.ZodString>;
+        sandboxMode: z.ZodOptional<z.ZodString>;
+        networkAccess: z.ZodOptional<z.ZodBoolean>;
+        webSearch: z.ZodOptional<z.ZodBoolean>;
+        featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        extra: z.ZodOptional<z.ZodObject<{
+            codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type ScheduleTarget = z.infer<typeof ScheduleTargetSchema>;
+export declare const ScheduleRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    scheduledFor: z.ZodString;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    agentId: z.ZodNullable<z.ZodGUID>;
+    workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    output: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ScheduleRun = z.infer<typeof ScheduleRunSchema>;
+export declare const StoredScheduleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"every">;
+        everyMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        agentId: z.ZodGUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"new-agent">;
+        config: z.ZodObject<{
+            provider: z.ZodString;
+            cwd: z.ZodString;
+            personality: z.ZodOptional<z.ZodString>;
+            modeId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            thinkingOptionId: z.ZodOptional<z.ZodString>;
+            archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+            isolation: z.ZodOptional<z.ZodEnum<{
+                worktree: "worktree";
+                local: "local";
+            }>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            approvalPolicy: z.ZodOptional<z.ZodString>;
+            sandboxMode: z.ZodOptional<z.ZodString>;
+            networkAccess: z.ZodOptional<z.ZodBoolean>;
+            webSearch: z.ZodOptional<z.ZodBoolean>;
+            featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extra: z.ZodOptional<z.ZodObject<{
+                codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        paused: "paused";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastRunAt: z.ZodNullable<z.ZodString>;
+    lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>>>;
+    lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pausedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    maxRuns: z.ZodNullable<z.ZodNumber>;
+    runs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        scheduledFor: z.ZodString;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        agentId: z.ZodNullable<z.ZodGUID>;
+        workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        output: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoredSchedule = z.infer<typeof StoredScheduleSchema>;
+export declare const ScheduleSummarySchema: z.ZodObject<{
+    name: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        paused: "paused";
+    }>;
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"every">;
+        everyMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        agentId: z.ZodGUID;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"new-agent">;
+        config: z.ZodObject<{
+            provider: z.ZodString;
+            cwd: z.ZodString;
+            personality: z.ZodOptional<z.ZodString>;
+            modeId: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            thinkingOptionId: z.ZodOptional<z.ZodString>;
+            archiveOnFinish: z.ZodOptional<z.ZodBoolean>;
+            isolation: z.ZodOptional<z.ZodEnum<{
+                worktree: "worktree";
+                local: "local";
+            }>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            approvalPolicy: z.ZodOptional<z.ZodString>;
+            sandboxMode: z.ZodOptional<z.ZodString>;
+            networkAccess: z.ZodOptional<z.ZodBoolean>;
+            webSearch: z.ZodOptional<z.ZodBoolean>;
+            featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extra: z.ZodOptional<z.ZodObject<{
+                codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">;
+    prompt: z.ZodString;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastRunAt: z.ZodNullable<z.ZodString>;
+    lastRunStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>>>;
+    lastRunError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pausedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    maxRuns: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScheduleSummary = z.infer<typeof ScheduleSummarySchema>;
+export interface CreateScheduleInput {
+    name?: string | null;
+    prompt: string;
+    cadence: ScheduleCadence;
+    target: ScheduleTarget;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+    runOnCreate?: boolean | null;
+}
+export interface UpdateScheduleNewAgentConfig {
+    provider?: string;
+    personality?: string | null;
+    model?: string | null;
+    modeId?: string | null;
+    thinkingOptionId?: string | null;
+    archiveOnFinish?: boolean;
+    isolation?: "local" | "worktree";
+    cwd?: string;
+}
+export interface UpdateScheduleInput {
+    id: string;
+    name?: string | null;
+    prompt?: string;
+    cadence?: ScheduleCadence;
+    newAgentConfig?: UpdateScheduleNewAgentConfig;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+}
+export interface ScheduleExecutionResult {
+    agentId: string | null;
+    output: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/schedule/types.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { AgentProviderSchema } from "../provider-manifest.js";
+export const ScheduleStatusSchema = z.enum(["active", "paused", "completed"]);
+export const ScheduleCadenceSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("every"),
+        everyMs: z.number().int().positive(),
+    }),
+    z.object({
+        type: z.literal("cron"),
+        expression: z.string().trim().min(1),
+        timezone: z.string().trim().min(1).optional(),
+    }),
+]);
+export const ScheduleTargetSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("agent"),
+        agentId: z.guid(),
+    }),
+    z.object({
+        type: z.literal("new-agent"),
+        config: z.object({
+            provider: AgentProviderSchema,
+            cwd: z.string().trim().min(1),
+            // Optional Agent Personality binding (by name). When set, each run
+            // re-resolves the personality against the run cwd and hard-fails if it is
+            // unavailable — so schedule runs pick up personality edits between runs.
+            personality: z.string().trim().min(1).optional(),
+            modeId: z.string().trim().min(1).optional(),
+            model: z.string().trim().min(1).optional(),
+            thinkingOptionId: z.string().trim().min(1).optional(),
+            archiveOnFinish: z.boolean().optional(),
+            isolation: z.enum(["local", "worktree"]).optional(),
+            title: z.string().trim().min(1).nullable().optional(),
+            approvalPolicy: z.string().trim().min(1).optional(),
+            sandboxMode: z.string().trim().min(1).optional(),
+            networkAccess: z.boolean().optional(),
+            webSearch: z.boolean().optional(),
+            featureValues: z.record(z.string(), z.unknown()).optional(),
+            extra: z
+                .object({
+                codex: z.record(z.string(), z.unknown()).optional(),
+                claude: z.record(z.string(), z.unknown()).optional(),
+            })
+                .partial()
+                .optional(),
+            systemPrompt: z.string().optional(),
+            mcpServers: z.record(z.string(), z.unknown()).optional(),
+        }),
+    }),
+]);
+export const ScheduleRunSchema = z.object({
+    id: z.string(),
+    scheduledFor: z.string(),
+    startedAt: z.string(),
+    endedAt: z.string().nullable(),
+    status: z.enum(["running", "succeeded", "failed"]),
+    agentId: z.guid().nullable(),
+    workspaceId: z.string().nullable().optional(),
+    output: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const StoredScheduleSchema = z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+    prompt: z.string().min(1),
+    cadence: ScheduleCadenceSchema,
+    target: ScheduleTargetSchema,
+    status: ScheduleStatusSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    nextRunAt: z.string().nullable(),
+    lastRunAt: z.string().nullable(),
+    lastRunStatus: z.enum(["succeeded", "failed"]).nullable().optional(),
+    lastRunError: z.string().nullable().optional(),
+    pausedAt: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    maxRuns: z.number().int().positive().nullable(),
+    runs: z.array(ScheduleRunSchema),
+});
+export const ScheduleSummarySchema = StoredScheduleSchema.omit({
+    runs: true,
+});
+//# sourceMappingURL=types.js.map

package/dist/terminal-activity.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const TERMINAL_ACTIVITY_STATES: readonly ["idle", "working", "attention"];
+export declare const TERMINAL_ACTIVITY_ATTENTION_REASONS: readonly ["finished", "needs_input"];
+export type TerminalActivityState = (typeof TERMINAL_ACTIVITY_STATES)[number];
+export type TerminalActivityAttentionReason = (typeof TERMINAL_ACTIVITY_ATTENTION_REASONS)[number];
+export declare const TerminalActivitySchema: z.ZodObject<{
+    state: z.ZodCatch<z.ZodEnum<{
+        idle: "idle";
+        working: "working";
+        attention: "attention";
+    }>>;
+    attentionReason: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        finished: "finished";
+        needs_input: "needs_input";
+    }>>>>;
+    changedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type TerminalActivity = z.infer<typeof TerminalActivitySchema>;
+export type TerminalActivityStatusBucket = "running" | "needs_input" | "attention";
+export declare function deriveTerminalActivityStatusBucket(activity: TerminalActivity | null | undefined): TerminalActivityStatusBucket | null;
+//# sourceMappingURL=terminal-activity.d.ts.map

package/dist/terminal-activity.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const TERMINAL_ACTIVITY_STATES = ["idle", "working", "attention"];
+export const TERMINAL_ACTIVITY_ATTENTION_REASONS = ["finished", "needs_input"];
+export const TerminalActivitySchema = z.object({
+    // Forward-compat: a newer daemon may send a state this client doesn't know.
+    // Degrade unknown states to "idle" (no indicator, no notification) so the
+    // message still parses, instead of a strict enum rejecting the whole payload.
+    state: z.enum(TERMINAL_ACTIVITY_STATES).catch("idle"),
+    attentionReason: z.enum(TERMINAL_ACTIVITY_ATTENTION_REASONS).nullable().optional().catch(null),
+    changedAt: z.number(),
+});
+export function deriveTerminalActivityStatusBucket(activity) {
+    if (!activity)
+        return null;
+    if (activity.attentionReason === "needs_input")
+        return "needs_input";
+    if (activity.attentionReason === "finished")
+        return "attention";
+    if (activity.state === "working")
+        return "running";
+    if (activity.state === "attention")
+        return "needs_input";
+    return null;
+}
+//# sourceMappingURL=terminal-activity.js.map

package/dist/terminal-input-mode.d.ts

@@ -0,0 +1,26 @@
+export interface TerminalInputModeFeedResult {
+    changed: boolean;
+    responses: string[];
+}
+export interface TerminalInputModeState {
+    kittyKeyboardFlags: number;
+    win32InputMode: boolean;
+}
+export declare const DEFAULT_TERMINAL_INPUT_MODE_STATE: TerminalInputModeState;
+export declare function terminalInputModeSupportsModifiedEnter(state: TerminalInputModeState): boolean;
+export declare function terminalInputModeStatesEqual(left: TerminalInputModeState, right: TerminalInputModeState): boolean;
+export declare class TerminalInputModeTracker {
+    private kittyKeyboardFlags;
+    private win32InputMode;
+    private readonly kittyKeyboardStack;
+    private pending;
+    feed(data: string): TerminalInputModeFeedResult;
+    reset(): void;
+    getState(): TerminalInputModeState;
+    getKittyKeyboardFlags(): number;
+    supportsModifiedEnter(): boolean;
+    getPreamble(): string;
+    private applyKittyKeyboardSequence;
+    private applyPrivateModeSequence;
+}
+//# sourceMappingURL=terminal-input-mode.d.ts.map