ptywright 0.1.0

package/src/script/schema.ts

@@ -0,0 +1,237 @@
+import { z } from "zod";
+
+export const textMaskRuleSchema = z.object({
+  regex: z.string().min(1),
+  flags: z.string().optional(),
+  replacement: z.string().optional(),
+  preserveLength: z.boolean().optional(),
+});
+
+export const launchConfigSchema = z.object({
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  cols: z.number().int().positive().optional(),
+  rows: z.number().int().positive().optional(),
+  name: z.string().optional(),
+});
+
+export const scriptTraceSchema = z.object({
+  saveCast: z.boolean().optional(),
+  saveReport: z.boolean().optional(),
+  castPath: z.string().optional(),
+  reportPath: z.string().optional(),
+  reportScope: z.enum(["visible", "buffer"]).optional(),
+  reportMaxFrames: z.number().int().positive().optional(),
+});
+
+const sendTextStepSchema = z.object({
+  type: z.literal("sendText"),
+  text: z.string(),
+  enter: z.boolean().optional(),
+});
+
+const pressKeyStepSchema = z.object({
+  type: z.literal("pressKey"),
+  key: z.string().min(1),
+});
+
+const sendMouseStepSchema = z.object({
+  type: z.literal("sendMouse"),
+  action: z.enum(["down", "up", "move", "click", "scroll_up", "scroll_down"]),
+  x: z.number().int(),
+  y: z.number().int(),
+  button: z.enum(["left", "middle", "right"]).optional(),
+  shift: z.boolean().optional(),
+  alt: z.boolean().optional(),
+  ctrl: z.boolean().optional(),
+});
+
+const resizeStepSchema = z.object({
+  type: z.literal("resize"),
+  cols: z.number().int().positive(),
+  rows: z.number().int().positive(),
+});
+
+const markStepSchema = z.object({
+  type: z.literal("mark"),
+  label: z.string().optional(),
+});
+
+const sleepStepSchema = z.object({
+  type: z.literal("sleep"),
+  ms: z.number().int().nonnegative(),
+});
+
+const waitForTextStepSchema = z
+  .object({
+    type: z.literal("waitForText"),
+    scope: z.enum(["visible", "buffer"]).optional(),
+    text: z.string().optional(),
+    regex: z.string().optional(),
+    timeoutMs: z.number().int().positive().optional(),
+    intervalMs: z.number().int().positive().optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.text && !value.regex) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "waitForText requires text or regex",
+      });
+    }
+  });
+
+const waitForStableScreenStepSchema = z.object({
+  type: z.literal("waitForStableScreen"),
+  timeoutMs: z.number().int().positive().optional(),
+  quietMs: z.number().int().positive().optional(),
+  intervalMs: z.number().int().positive().optional(),
+});
+
+const waitForExitStepSchema = z.object({
+  type: z.literal("waitForExit"),
+  timeoutMs: z.number().int().positive().optional(),
+  intervalMs: z.number().int().positive().optional(),
+  exitCode: z.number().int().optional(),
+  signal: z.union([z.number().int(), z.string()]).optional(),
+});
+
+const expectMetaStepSchema = z
+  .object({
+    type: z.literal("expectMeta"),
+    bufferType: z.enum(["normal", "alternate"]).optional(),
+    cols: z.number().int().positive().optional(),
+    rows: z.number().int().positive().optional(),
+    cursor: z
+      .object({
+        x: z.number().int().positive(),
+        y: z.number().int().positive(),
+      })
+      .optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (
+      value.bufferType === undefined &&
+      value.cols === undefined &&
+      value.rows === undefined &&
+      value.cursor === undefined
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "expectMeta requires at least one assertion (bufferType/cols/rows/cursor)",
+      });
+    }
+  });
+
+const snapshotStepSchema = z
+  .object({
+    type: z.literal("snapshot"),
+    kind: z.enum(["text", "view", "ansi", "view_ansi", "grid"]),
+    scope: z.enum(["visible", "buffer"]).optional(),
+    trimRight: z.boolean().optional(),
+    trimBottom: z.boolean().optional(),
+    maxLines: z.number().int().positive().optional(),
+    tailLines: z.number().int().positive().optional(),
+    lineNumbers: z.boolean().optional(),
+    includeStyles: z.boolean().optional(),
+    mask: z.array(textMaskRuleSchema).optional(),
+    saveAs: z.string().optional(),
+    saveTo: z.string().optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (value.maxLines !== undefined && value.tailLines !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "snapshot: maxLines and tailLines are mutually exclusive",
+      });
+    }
+  });
+
+const expectStepSchema = z
+  .object({
+    type: z.literal("expect"),
+    from: z.string().optional(),
+    equals: z.string().optional(),
+    contains: z.array(z.string()).optional(),
+    notContains: z.array(z.string()).optional(),
+    regex: z.string().optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (
+      value.equals === undefined &&
+      !value.contains?.length &&
+      !value.notContains?.length &&
+      !value.regex
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "expect requires at least one matcher (equals/contains/notContains/regex)",
+      });
+    }
+  });
+
+const expectGoldenStepSchema = z.object({
+  type: z.literal("expectGolden"),
+  from: z.string().optional(),
+  path: z.string().min(1),
+});
+
+const customStepSchema = z.object({
+  type: z.literal("custom"),
+  name: z.string().min(1),
+  payload: z.unknown().optional(),
+});
+
+const assertStepSchema = z
+  .object({
+    type: z.literal("assert"),
+    scope: z.enum(["visible", "buffer"]).optional(),
+    text: z.string().optional(),
+    regex: z.string().optional(),
+    description: z.string().optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.text && !value.regex) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "assert requires text or regex",
+      });
+    }
+  });
+
+const assertSemanticStepSchema = z.object({
+  type: z.literal("assertSemantic"),
+  prompt: z.string().min(1),
+  description: z.string().optional(),
+});
+
+export const scriptStepSchema = z.union([
+  sendTextStepSchema,
+  pressKeyStepSchema,
+  sendMouseStepSchema,
+  resizeStepSchema,
+  markStepSchema,
+  sleepStepSchema,
+  waitForTextStepSchema,
+  waitForStableScreenStepSchema,
+  waitForExitStepSchema,
+  expectMetaStepSchema,
+  snapshotStepSchema,
+  expectStepSchema,
+  expectGoldenStepSchema,
+  customStepSchema,
+  assertStepSchema,
+  assertSemanticStepSchema,
+]);
+
+export const scriptSchema = z.object({
+  name: z.string().optional(),
+  artifactsDir: z.string().optional(),
+  launch: launchConfigSchema,
+  trace: scriptTraceSchema.optional(),
+  steps: z.array(scriptStepSchema).min(1),
+});
+
+export type Script = z.infer<typeof scriptSchema>;
+export type ScriptStep = z.infer<typeof scriptStepSchema>;

package/src/script/steps/assert_snapshot_equals.ts

@@ -0,0 +1,21 @@
+import type { CustomStepHandler } from "../runner";
+
+export type AssertSnapshotEqualsPayload = {
+  expected: string;
+};
+
+export function createAssertSnapshotEqualsStep(
+  from: string,
+): CustomStepHandler<AssertSnapshotEqualsPayload> {
+  return (ctx, step) => {
+    const expected = step.payload?.expected;
+    if (typeof expected !== "string") {
+      throw new Error("assertSnapshotEquals: missing payload.expected");
+    }
+
+    const record = ctx.getSnapshot(from);
+    if (record.text.trimEnd() !== expected) {
+      throw new Error("assertSnapshotEquals failed");
+    }
+  };
+}

package/src/script/steps/index.ts

@@ -0,0 +1,2 @@
+export { createAssertSnapshotEqualsStep } from "./assert_snapshot_equals";
+export type { AssertSnapshotEqualsPayload } from "./assert_snapshot_equals";