@agentstorm/platform-protocol 0.2.5

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export declare const TerminalStreamResizeSchema: z.ZodObject<{
+    rows: z.ZodNumber;
+    cols: z.ZodNumber;
+    intent: z.ZodOptional<z.ZodEnum<{
+        claim: "claim";
+        update: "update";
+    }>>;
+}, 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,100 @@
+import { z } from "zod";
+import { TerminalStateSchema } from "../messages.js";
+export const TerminalStreamResizeSchema = z.object({
+    rows: z.number().int().positive(),
+    cols: z.number().int().positive(),
+    intent: z.enum(["claim", "update"]).optional(),
+});
+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<("select" | "type" | "fill" | "logs" | "list_tabs" | "new_tab" | "snapshot" | "click" | "wait" | "keypress" | "navigate" | "back" | "forward" | "reload" | "screenshot" | "upload" | "hover" | "drag" | "evaluate" | "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