@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/dist/schedule/types.d.ts

@@ -0,0 +1,222 @@
+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;
+        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<{
+            local: "local";
+            worktree: "worktree";
+        }>>;
+        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";
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    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;
+            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<{
+                local: "local";
+                worktree: "worktree";
+            }>>;
+            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>;
+    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";
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        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>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        paused: "paused";
+    }>;
+    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;
+            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<{
+                local: "local";
+                worktree: "worktree";
+            }>>;
+            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>;
+    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;
+    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/node_modules/@bytetrue/byspace-protocol/dist/schedule/types.js

@@ -0,0 +1,78 @@
+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),
+            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(),
+    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/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/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

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-input-mode.js

@@ -0,0 +1,151 @@
+export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
+    kittyKeyboardFlags: 0,
+    win32InputMode: false,
+};
+const ESC = String.fromCharCode(0x1b);
+const WIN32_INPUT_MODE = 9001;
+const CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[(?:([<>=?]?)([0-9;]*)u|\\?([0-9;]*)([hl]))`, "g");
+const INCOMPLETE_CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[[<>=?]?[0-9;]*$`);
+function parseFirstParam(params) {
+    const first = params.split(";")[0];
+    if (!first || !/^\d+$/.test(first)) {
+        return null;
+    }
+    return Number(first);
+}
+function parseSecondParam(params) {
+    const second = params.split(";")[1];
+    if (!second || !/^\d+$/.test(second)) {
+        return null;
+    }
+    return Number(second);
+}
+function parsePrivateModeParams(params) {
+    const modes = new Set();
+    for (const param of params.split(";")) {
+        if (/^\d+$/.test(param)) {
+            modes.add(Number(param));
+        }
+    }
+    return modes;
+}
+export function terminalInputModeSupportsModifiedEnter(state) {
+    return state.kittyKeyboardFlags > 0 || state.win32InputMode;
+}
+export function terminalInputModeStatesEqual(left, right) {
+    return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
+        left.win32InputMode === right.win32InputMode);
+}
+export class TerminalInputModeTracker {
+    constructor() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack = [];
+        this.pending = "";
+    }
+    feed(data) {
+        if (data.length === 0) {
+            return { changed: false, responses: [] };
+        }
+        const text = `${this.pending}${data}`;
+        this.pending = "";
+        let changed = false;
+        const responses = [];
+        let consumedUntil = 0;
+        CSI_INPUT_MODE_SEQUENCE.lastIndex = 0;
+        for (;;) {
+            const match = CSI_INPUT_MODE_SEQUENCE.exec(text);
+            if (!match) {
+                break;
+            }
+            consumedUntil = CSI_INPUT_MODE_SEQUENCE.lastIndex;
+            if (match[4]) {
+                changed = this.applyPrivateModeSequence(match[3] ?? "", match[4]) || changed;
+                continue;
+            }
+            const result = this.applyKittyKeyboardSequence(match[1] ?? "", match[2] ?? "");
+            changed = changed || result.changed;
+            responses.push(...result.responses);
+        }
+        const tail = text.slice(consumedUntil);
+        const pendingStart = tail.lastIndexOf(`${ESC}[`);
+        if (pendingStart >= 0) {
+            const pending = tail.slice(pendingStart);
+            if (INCOMPLETE_CSI_INPUT_MODE_SEQUENCE.test(pending)) {
+                this.pending = pending;
+            }
+        }
+        return { changed, responses };
+    }
+    reset() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack.length = 0;
+        this.pending = "";
+    }
+    getState() {
+        return {
+            kittyKeyboardFlags: this.kittyKeyboardFlags,
+            win32InputMode: this.win32InputMode,
+        };
+    }
+    getKittyKeyboardFlags() {
+        return this.kittyKeyboardFlags;
+    }
+    supportsModifiedEnter() {
+        return terminalInputModeSupportsModifiedEnter(this.getState());
+    }
+    getPreamble() {
+        const parts = [];
+        if (this.kittyKeyboardFlags > 0) {
+            parts.push(`\x1b[=${this.kittyKeyboardFlags};1u`);
+        }
+        if (this.win32InputMode) {
+            parts.push("\x1b[?9001h");
+        }
+        return parts.join("");
+    }
+    applyKittyKeyboardSequence(prefix, params) {
+        const previousFlags = this.kittyKeyboardFlags;
+        switch (prefix) {
+            case ">": {
+                this.kittyKeyboardStack.push(this.kittyKeyboardFlags);
+                this.kittyKeyboardFlags = parseFirstParam(params) ?? 1;
+                break;
+            }
+            case "=": {
+                const mode = parseSecondParam(params) ?? 1;
+                this.kittyKeyboardFlags = mode === 0 ? 0 : (parseFirstParam(params) ?? 0);
+                break;
+            }
+            case "<": {
+                const count = Math.max(1, parseFirstParam(params) ?? 1);
+                for (let index = 0; index < count; index += 1) {
+                    this.kittyKeyboardFlags = this.kittyKeyboardStack.pop() ?? 0;
+                }
+                break;
+            }
+            case "?":
+                return {
+                    changed: false,
+                    responses: [`\x1b[?${this.kittyKeyboardFlags}u`],
+                };
+            default:
+                return { changed: false, responses: [] };
+        }
+        return {
+            changed: this.kittyKeyboardFlags !== previousFlags,
+            responses: [],
+        };
+    }
+    applyPrivateModeSequence(params, final) {
+        const modes = parsePrivateModeParams(params);
+        if (!modes.has(WIN32_INPUT_MODE)) {
+            return false;
+        }
+        const previous = this.win32InputMode;
+        this.win32InputMode = final === "h";
+        return this.win32InputMode !== previous;
+    }
+}
+//# sourceMappingURL=terminal-input-mode.js.map