@otto-code/protocol 0.5.0

package/dist/artifacts/types.d.ts

@@ -0,0 +1,166 @@
+import { z } from "zod";
+export declare const ArtifactKindSchema: z.ZodEnum<{
+    html: "html";
+}>;
+export type ArtifactKind = z.infer<typeof ArtifactKindSchema>;
+export declare const ArtifactStatusSchema: z.ZodEnum<{
+    error: "error";
+    generating: "generating";
+    ready: "ready";
+}>;
+export type ArtifactStatus = z.infer<typeof ArtifactStatusSchema>;
+export declare const ArtifactSpinnerSchema: z.ZodObject<{
+    glowA: z.ZodString;
+    glowB: z.ZodString;
+}, z.core.$loose>;
+export type ArtifactSpinner = z.infer<typeof ArtifactSpinnerSchema>;
+export declare const ArtifactMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    projectId: z.ZodString;
+    filePath: z.ZodString;
+    kind: z.ZodEnum<{
+        html: "html";
+    }>;
+    starred: z.ZodBoolean;
+    status: z.ZodEnum<{
+        error: "error";
+        generating: "generating";
+        ready: "ready";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    generationAgentId: z.ZodNullable<z.ZodString>;
+    generationProvider: z.ZodNullable<z.ZodString>;
+    generationModel: z.ZodNullable<z.ZodString>;
+    generationModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationThinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationSpinner: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        glowA: z.ZodString;
+        glowB: z.ZodString;
+    }, z.core.$loose>>>;
+    errorMessage: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArtifactMetadata = z.infer<typeof ArtifactMetadataSchema>;
+export declare const ArtifactSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    projectId: z.ZodString;
+    filePath: z.ZodString;
+    kind: z.ZodEnum<{
+        html: "html";
+    }>;
+    starred: z.ZodBoolean;
+    status: z.ZodEnum<{
+        error: "error";
+        generating: "generating";
+        ready: "ready";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    generationAgentId: z.ZodNullable<z.ZodString>;
+    generationProvider: z.ZodNullable<z.ZodString>;
+    generationModel: z.ZodNullable<z.ZodString>;
+    generationModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationThinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationSpinner: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        glowA: z.ZodString;
+        glowB: z.ZodString;
+    }, z.core.$loose>>>;
+    errorMessage: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArtifactSummary = z.infer<typeof ArtifactSummarySchema>;
+export declare const ArtifactRunTriggerSchema: z.ZodEnum<{
+    create: "create";
+    regenerate: "regenerate";
+}>;
+export type ArtifactRunTrigger = z.infer<typeof ArtifactRunTriggerSchema>;
+export declare const ArtifactRunStatusSchema: z.ZodEnum<{
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+}>;
+export type ArtifactRunStatus = z.infer<typeof ArtifactRunStatusSchema>;
+export declare const ArtifactRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    trigger: z.ZodEnum<{
+        create: "create";
+        regenerate: "regenerate";
+    }>;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodNullable<z.ZodString>;
+    agentId: z.ZodNullable<z.ZodString>;
+    provider: z.ZodNullable<z.ZodString>;
+    model: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ArtifactRun = z.infer<typeof ArtifactRunSchema>;
+export declare const StoredArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    projectId: z.ZodString;
+    filePath: z.ZodString;
+    kind: z.ZodEnum<{
+        html: "html";
+    }>;
+    starred: z.ZodBoolean;
+    status: z.ZodEnum<{
+        error: "error";
+        generating: "generating";
+        ready: "ready";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    generationAgentId: z.ZodNullable<z.ZodString>;
+    generationProvider: z.ZodNullable<z.ZodString>;
+    generationModel: z.ZodNullable<z.ZodString>;
+    generationModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationThinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generationSpinner: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        glowA: z.ZodString;
+        glowB: z.ZodString;
+    }, z.core.$loose>>>;
+    errorMessage: z.ZodNullable<z.ZodString>;
+    runs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        trigger: z.ZodEnum<{
+            create: "create";
+            regenerate: "regenerate";
+        }>;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        startedAt: z.ZodString;
+        endedAt: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type StoredArtifact = z.infer<typeof StoredArtifactSchema>;
+export declare const MAX_ARTIFACT_RUNS = 20;
+export interface CreateArtifactInput {
+    name: string;
+    description: string;
+    projectId: string;
+    provider: string;
+    model?: string;
+    modeId?: string;
+    thinkingOptionId?: string;
+    systemPrompt?: string;
+    /** Spinner colors of the chosen Agent Personality, snapshotted onto the
+     * artifact so its generating card renders in the personality's identity. */
+    spinner?: ArtifactSpinner;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/artifacts/types.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export const ArtifactKindSchema = z.enum(["html"]);
+export const ArtifactStatusSchema = z.enum(["generating", "ready", "error"]);
+// Two glow colors for the generating spinner, snapshotted from the Agent
+// Personality the artifact was generated under (BlobLoader glowA/glowB), so its
+// card spinner renders in the personality's identity. Passthrough for
+// forward-compat, mirroring AgentPersonalitySpinnerSchema in messages.ts.
+export const ArtifactSpinnerSchema = z
+    .object({
+    glowA: z.string().min(1),
+    glowB: z.string().min(1),
+})
+    .passthrough();
+export const ArtifactMetadataSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    projectId: z.string(),
+    filePath: z.string(),
+    kind: ArtifactKindSchema,
+    starred: z.boolean(),
+    status: ArtifactStatusSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    generationAgentId: z.string().nullable(),
+    generationProvider: z.string().nullable(),
+    generationModel: z.string().nullable(),
+    // Requested generation mode/effort, persisted so regeneration re-runs with
+    // the same settings. Optional: records written before these fields existed
+    // omit them (no migrations). The mode is a *request* — the artifact service
+    // only honors unattended modes and otherwise resolves the provider's
+    // unattended default, so generation never stalls on an approval prompt.
+    generationModeId: z.string().nullable().optional(),
+    generationThinkingOptionId: z.string().nullable().optional(),
+    // Spinner glow colors of the Agent Personality this artifact was generated
+    // under, snapshotted at create time like the provider/model above. Absent ⇒
+    // the card falls back to the theme's default spinner colors. Purely additive
+    // (no daemon floor needed). See projects/agent-personalities/.
+    generationSpinner: ArtifactSpinnerSchema.nullable().optional(),
+    errorMessage: z.string().nullable(),
+});
+export const ArtifactSummarySchema = ArtifactMetadataSchema;
+// What kicked off a generation attempt: the first-ever generation (create) or a
+// re-run of an existing artifact (regenerate).
+export const ArtifactRunTriggerSchema = z.enum(["create", "regenerate"]);
+export const ArtifactRunStatusSchema = z.enum(["running", "succeeded", "failed"]);
+// One generation attempt. Mirrors ScheduleRun: a persisted log entry per run so
+// inspect_artifact can show what happened across attempts (which provider/model,
+// whether it succeeded, and the failure/cancel/timeout message when it didn't),
+// rather than only the artifact's current status.
+export const ArtifactRunSchema = z.object({
+    id: z.string(),
+    trigger: ArtifactRunTriggerSchema,
+    status: ArtifactRunStatusSchema,
+    startedAt: z.string(),
+    endedAt: z.string().nullable(),
+    agentId: z.string().nullable(),
+    provider: z.string().nullable(),
+    model: z.string().nullable(),
+    error: z.string().nullable(),
+});
+// The full on-disk record: the lean metadata plus its generation run history.
+// `runs` defaults to [] so records written before run history existed parse
+// unchanged (no migrations — same approach the rest of the store takes).
+// list_artifacts / broadcasts keep sending ArtifactMetadata (runs stripped);
+// only inspect_artifact returns this fuller shape.
+export const StoredArtifactSchema = ArtifactMetadataSchema.extend({
+    runs: z.array(ArtifactRunSchema).default([]),
+});
+// Cap on retained run history per artifact. Keeps the on-disk JSON bounded while
+// still showing a useful recent window in inspect_artifact.
+export const MAX_ARTIFACT_RUNS = 20;
+//# sourceMappingURL=types.js.map

package/dist/binary-frames/demux.d.ts

@@ -0,0 +1,11 @@
+import { type FileTransferFrame } from "./file-transfer.js";
+import { type TerminalStreamFrame } from "./terminal.js";
+export type BinaryFrame = {
+    kind: "terminal";
+    frame: TerminalStreamFrame;
+} | {
+    kind: "file_transfer";
+    frame: FileTransferFrame;
+};
+export declare function decodeBinaryFrame(bytes: Uint8Array): BinaryFrame | null;
+//# sourceMappingURL=demux.d.ts.map

package/dist/binary-frames/demux.js

@@ -0,0 +1,23 @@
+import { decodeFileTransferFrame, FileTransferOpcode, } from "./file-transfer.js";
+import { decodeTerminalStreamFrame, TerminalStreamOpcode, } from "./terminal.js";
+export function decodeBinaryFrame(bytes) {
+    switch (bytes[0]) {
+        case TerminalStreamOpcode.Output:
+        case TerminalStreamOpcode.Input:
+        case TerminalStreamOpcode.Resize:
+        case TerminalStreamOpcode.Snapshot:
+        case TerminalStreamOpcode.Restore: {
+            const frame = decodeTerminalStreamFrame(bytes);
+            return frame ? { kind: "terminal", frame } : null;
+        }
+        case FileTransferOpcode.FileBegin:
+        case FileTransferOpcode.FileChunk:
+        case FileTransferOpcode.FileEnd: {
+            const frame = decodeFileTransferFrame(bytes);
+            return frame ? { kind: "file_transfer", frame } : null;
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=demux.js.map

package/dist/binary-frames/file-transfer.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const FileTransferOpcode: {
+    readonly FileBegin: 16;
+    readonly FileChunk: 17;
+    readonly FileEnd: 18;
+};
+export type FileTransferOpcode = (typeof FileTransferOpcode)[keyof typeof FileTransferOpcode];
+export declare const FileBeginMetadataSchema: z.ZodObject<{
+    mime: z.ZodString;
+    size: z.ZodNumber;
+    encoding: z.ZodEnum<{
+        binary: "binary";
+        "utf-8": "utf-8";
+    }>;
+    modifiedAt: z.ZodString;
+    fileName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface FileBegin {
+    opcode: typeof FileTransferOpcode.FileBegin;
+    requestId: string;
+    metadata: z.infer<typeof FileBeginMetadataSchema>;
+    payload: Uint8Array;
+}
+export interface FileChunk {
+    opcode: typeof FileTransferOpcode.FileChunk;
+    requestId: string;
+    payload: Uint8Array;
+}
+export interface FileEnd {
+    opcode: typeof FileTransferOpcode.FileEnd;
+    requestId: string;
+    payload: Uint8Array;
+}
+export type FileTransferFrame = FileBegin | FileChunk | FileEnd;
+type FileTransferFrameInput = {
+    opcode: typeof FileTransferOpcode.FileBegin;
+    requestId: string;
+    metadata: z.infer<typeof FileBeginMetadataSchema>;
+} | {
+    opcode: typeof FileTransferOpcode.FileChunk;
+    requestId: string;
+    payload?: Uint8Array | ArrayBuffer | string;
+} | {
+    opcode: typeof FileTransferOpcode.FileEnd;
+    requestId: string;
+};
+export declare function encodeFileTransferFrame(input: FileTransferFrameInput): Uint8Array;
+export declare function decodeFileTransferFrame(bytes: Uint8Array): FileTransferFrame | null;
+export {};
+//# sourceMappingURL=file-transfer.d.ts.map

package/dist/binary-frames/file-transfer.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { asUint8Array } from "./terminal.js";
+export const FileTransferOpcode = {
+    FileBegin: 0x10,
+    FileChunk: 0x11,
+    FileEnd: 0x12,
+};
+export const FileBeginMetadataSchema = z.object({
+    mime: z.string().min(1),
+    size: z.number().int().nonnegative(),
+    encoding: z.enum(["utf-8", "binary"]),
+    modifiedAt: z.string(),
+    fileName: z.string().optional(),
+});
+export function encodeFileTransferFrame(input) {
+    const requestId = encodeRequestId(input.requestId);
+    if (input.opcode === FileTransferOpcode.FileBegin) {
+        const metadata = encodeJsonPayload(input.metadata);
+        if (metadata.byteLength > 0xffff) {
+            throw new RangeError("FileBegin metadata is too long");
+        }
+        const bytes = new Uint8Array(4 + requestId.byteLength + metadata.byteLength);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        bytes[0] = input.opcode;
+        bytes[1] = requestId.byteLength;
+        bytes.set(requestId, 2);
+        view.setUint16(2 + requestId.byteLength, metadata.byteLength);
+        bytes.set(metadata, 4 + requestId.byteLength);
+        return bytes;
+    }
+    const payload = input.opcode === FileTransferOpcode.FileChunk
+        ? (asUint8Array(input.payload ?? new Uint8Array()) ?? new Uint8Array())
+        : new Uint8Array();
+    const bytes = new Uint8Array(2 + requestId.byteLength + payload.byteLength);
+    bytes[0] = input.opcode;
+    bytes[1] = requestId.byteLength;
+    bytes.set(requestId, 2);
+    bytes.set(payload, 2 + requestId.byteLength);
+    return bytes;
+}
+export function decodeFileTransferFrame(bytes) {
+    if (bytes.byteLength < 2) {
+        return null;
+    }
+    const opcode = bytes[0];
+    if (!isFileTransferOpcode(opcode)) {
+        return null;
+    }
+    const requestIdLength = bytes[1];
+    if (requestIdLength === 0 || requestIdLength > bytes.byteLength - 2) {
+        return null;
+    }
+    const requestId = decodeRequestId(bytes.subarray(2, 2 + requestIdLength));
+    const body = bytes.subarray(2 + requestIdLength);
+    if (opcode === FileTransferOpcode.FileBegin) {
+        if (body.byteLength < 2) {
+            return null;
+        }
+        const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+        const metadataLength = view.getUint16(0);
+        if (metadataLength !== body.byteLength - 2) {
+            return null;
+        }
+        const metadataBytes = body.subarray(2);
+        const result = FileBeginMetadataSchema.safeParse(decodeJsonPayload(metadataBytes));
+        return result.success
+            ? { opcode, requestId, metadata: result.data, payload: new Uint8Array() }
+            : null;
+    }
+    if (opcode === FileTransferOpcode.FileChunk) {
+        return { opcode, requestId, payload: body };
+    }
+    if (body.byteLength !== 0) {
+        return null;
+    }
+    return { opcode, requestId, payload: new Uint8Array() };
+}
+function isFileTransferOpcode(value) {
+    return (value === FileTransferOpcode.FileBegin ||
+        value === FileTransferOpcode.FileChunk ||
+        value === FileTransferOpcode.FileEnd);
+}
+function encodeJsonPayload(value) {
+    return new TextEncoder().encode(JSON.stringify(value));
+}
+function encodeRequestId(requestId) {
+    const bytes = new TextEncoder().encode(requestId);
+    if (bytes.byteLength === 0) {
+        throw new RangeError("File transfer requestId is required");
+    }
+    if (bytes.byteLength > 0xff) {
+        throw new RangeError("File transfer requestId is too long");
+    }
+    return bytes;
+}
+function decodeRequestId(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+function decodeJsonPayload(bytes) {
+    try {
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=file-transfer.js.map

package/dist/binary-frames/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./demux.js";
+export * from "./file-transfer.js";
+export * from "./terminal.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/binary-frames/index.js

@@ -0,0 +1,4 @@
+export * from "./demux.js";
+export * from "./file-transfer.js";
+export * from "./terminal.js";
+//# sourceMappingURL=index.js.map

package/dist/binary-frames/terminal.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export declare const TerminalStreamResizeSchema: z.ZodObject<{
+    rows: z.ZodNumber;
+    cols: z.ZodNumber;
+}, z.core.$strip>;
+export declare const TerminalStreamOpcode: {
+    readonly Output: 1;
+    readonly Input: 2;
+    readonly Resize: 3;
+    readonly Snapshot: 4;
+    readonly Restore: 5;
+};
+export type TerminalStreamOpcode = (typeof TerminalStreamOpcode)[keyof typeof TerminalStreamOpcode];
+export interface TerminalStreamFrame {
+    opcode: TerminalStreamOpcode;
+    slot: number;
+    payload: Uint8Array;
+}
+export declare function asUint8Array(data: unknown): Uint8Array | null;
+export declare function encodeTerminalStreamFrame(input: {
+    opcode: TerminalStreamOpcode;
+    slot: number;
+    payload?: Uint8Array | ArrayBuffer | string;
+}): Uint8Array;
+export declare function decodeTerminalStreamFrame(bytes: Uint8Array): TerminalStreamFrame | null;
+export declare function encodeTerminalSnapshotPayload(state: z.infer<typeof TerminalStateSchema>): Uint8Array;
+export declare function decodeTerminalSnapshotPayload(bytes: Uint8Array): z.infer<typeof TerminalStateSchema> | null;
+export declare function encodeTerminalResizePayload(input: z.infer<typeof TerminalStreamResizeSchema>): Uint8Array;
+export declare function decodeTerminalResizePayload(bytes: Uint8Array): z.infer<typeof TerminalStreamResizeSchema> | null;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/binary-frames/terminal.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export const TerminalStreamResizeSchema = z.object({
+    rows: z.number().int().positive(),
+    cols: z.number().int().positive(),
+});
+export const TerminalStreamOpcode = {
+    Output: 0x01,
+    Input: 0x02,
+    Resize: 0x03,
+    Snapshot: 0x04,
+    Restore: 0x05,
+};
+export function asUint8Array(data) {
+    if (typeof data === "string") {
+        if (typeof TextEncoder !== "undefined") {
+            return new TextEncoder().encode(data);
+        }
+        if (typeof Buffer !== "undefined") {
+            return new Uint8Array(Buffer.from(data, "utf8"));
+        }
+        const out = new Uint8Array(data.length);
+        for (let index = 0; index < data.length; index += 1) {
+            out[index] = data.charCodeAt(index) & 0xff;
+        }
+        return out;
+    }
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return null;
+}
+function isTerminalStreamOpcode(value) {
+    return (value === TerminalStreamOpcode.Output ||
+        value === TerminalStreamOpcode.Input ||
+        value === TerminalStreamOpcode.Resize ||
+        value === TerminalStreamOpcode.Snapshot ||
+        value === TerminalStreamOpcode.Restore);
+}
+export function encodeTerminalStreamFrame(input) {
+    const payload = asUint8Array(input.payload ?? new Uint8Array(0)) ?? new Uint8Array(0);
+    const bytes = new Uint8Array(2 + payload.byteLength);
+    bytes[0] = input.opcode;
+    bytes[1] = input.slot & 0xff;
+    bytes.set(payload, 2);
+    return bytes;
+}
+export function decodeTerminalStreamFrame(bytes) {
+    if (bytes.byteLength < 2) {
+        return null;
+    }
+    const opcode = bytes[0];
+    if (!isTerminalStreamOpcode(opcode)) {
+        return null;
+    }
+    return {
+        opcode,
+        slot: bytes[1],
+        payload: bytes.subarray(2),
+    };
+}
+export function encodeTerminalSnapshotPayload(state) {
+    return encodeJsonPayload(state);
+}
+export function decodeTerminalSnapshotPayload(bytes) {
+    const parsed = decodeJsonPayload(bytes);
+    const result = TerminalStateSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+export function encodeTerminalResizePayload(input) {
+    return encodeJsonPayload(input);
+}
+export function decodeTerminalResizePayload(bytes) {
+    const parsed = decodeJsonPayload(bytes);
+    const result = TerminalStreamResizeSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+}
+function encodeJsonPayload(value) {
+    return new TextEncoder().encode(JSON.stringify(value));
+}
+function decodeJsonPayload(bytes) {
+    try {
+        const text = new TextDecoder().decode(bytes);
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=terminal.js.map

package/dist/branch-slug.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validate that a string is a valid git branch name slug.
+ * Must be lowercase alphanumeric with hyphens and forward slashes only.
+ */
+export declare function validateBranchSlug(slug: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare const MAX_SLUG_LENGTH = 50;
+/**
+ * Convert a string to kebab-case for branch names.
+ */
+export declare function slugify(input: string): string;
+//# sourceMappingURL=branch-slug.d.ts.map

package/dist/branch-slug.js

@@ -0,0 +1,49 @@
+/**
+ * Validate that a string is a valid git branch name slug.
+ * Must be lowercase alphanumeric with hyphens and forward slashes only.
+ */
+export function validateBranchSlug(slug) {
+    if (!slug || slug.length === 0) {
+        return { valid: false, error: "Branch name cannot be empty" };
+    }
+    if (slug.length > 100) {
+        return { valid: false, error: "Branch name too long (max 100 characters)" };
+    }
+    const validPattern = /^[a-z0-9-/]+$/;
+    if (!validPattern.test(slug)) {
+        return {
+            valid: false,
+            error: "Branch name must contain only lowercase letters, numbers, hyphens, and forward slashes",
+        };
+    }
+    if (slug.startsWith("-") || slug.endsWith("-")) {
+        return {
+            valid: false,
+            error: "Branch name cannot start or end with a hyphen",
+        };
+    }
+    if (slug.includes("--")) {
+        return { valid: false, error: "Branch name cannot have consecutive hyphens" };
+    }
+    return { valid: true };
+}
+export const MAX_SLUG_LENGTH = 50;
+/**
+ * Convert a string to kebab-case for branch names.
+ */
+export function slugify(input) {
+    const slug = input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (slug.length <= MAX_SLUG_LENGTH) {
+        return slug;
+    }
+    const truncated = slug.slice(0, MAX_SLUG_LENGTH);
+    const lastHyphen = truncated.lastIndexOf("-");
+    if (lastHyphen > MAX_SLUG_LENGTH / 2) {
+        return truncated.slice(0, lastHyphen);
+    }
+    return truncated.replace(/-+$/, "");
+}
+//# sourceMappingURL=branch-slug.js.map

package/dist/browser-automation/capabilities.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const BrowserAutomationHostCapabilitySchema: z.ZodObject<{
+    supportedCommands: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<("type" | "select" | "fill" | "logs" | "list_tabs" | "new_tab" | "snapshot" | "click" | "wait" | "keypress" | "navigate" | "back" | "forward" | "reload" | "screenshot" | "upload" | "hover" | "drag" | "evaluate" | "inspect" | "network" | "scroll" | "resize" | "close_tab")[], string[]>>;
+    hostKind: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+export type BrowserAutomationHostCapability = z.infer<typeof BrowserAutomationHostCapabilitySchema>;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/browser-automation/capabilities.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { BROWSER_AUTOMATION_COMMAND_NAMES, } from "./rpc-schemas.js";
+const KNOWN_BROWSER_AUTOMATION_COMMAND_NAMES = new Set(BROWSER_AUTOMATION_COMMAND_NAMES);
+export const BrowserAutomationHostCapabilitySchema = z
+    .object({
+    supportedCommands: z.array(z.string().min(1)).transform((commands, context) => {
+        const supportedCommands = [];
+        const seen = new Set();
+        for (const command of commands) {
+            if (!isKnownBrowserAutomationCommandName(command) || seen.has(command)) {
+                continue;
+            }
+            seen.add(command);
+            supportedCommands.push(command);
+        }
+        if (supportedCommands.length === 0) {
+            context.addIssue({
+                code: "custom",
+                message: "supportedCommands must include at least one known browser automation command",
+            });
+            return z.NEVER;
+        }
+        return supportedCommands;
+    }),
+    hostKind: z.string().min(1).default("browser host"),
+})
+    .passthrough();
+function isKnownBrowserAutomationCommandName(value) {
+    return KNOWN_BROWSER_AUTOMATION_COMMAND_NAMES.has(value);
+}
+//# sourceMappingURL=capabilities.js.map