@flowriki/agent 0.1.0-beta.43 → 0.1.0-beta.45

package/dist/{chunk-ZMHE47A5.js → chunk-JJB45ZTL.js}

@@ -6,7 +6,7 @@ import os from "os";
 import path from "path";
 import { createRequire } from "module";
 import { spawnSync } from "child_process";
-var AGENT_VERSION = "0.1.0-beta.43";
+var AGENT_VERSION = "0.1.0-beta.45";
 async function prepareBrowsers() {
   if (browsersReady()) {
     return { ok: true, already: true, message: "chromium is already installed" };
@@ -1009,6 +1009,7 @@ import { z as z5 } from "zod";
 import { z as z6 } from "zod";
 import { z as z7 } from "zod";
 import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var EngineSchema = z4.enum(["chromium", "firefox", "webkit"]);
 var CapabilitySchema = z4.object({
   id: z4.string(),
@@ -1201,6 +1202,10 @@ var TestCaseSchema = z32.object({
   businessSteps: z32.array(BusinessStepSchema).optional(),
   /** Where it came from, when not recorded here. */
   origin: TestCaseOriginSchema.optional(),
+  /** WHEN ITS STEPS CHANGED AFTER IT WAS AUTOMATED: the automation may no
+   *  longer check what the words now say. Cleared when its flows are saved
+   *  again, or somebody confirms the automation still matches. */
+  stepsChangedAt: z32.string().optional(),
   createdAt: z32.string(),
   createdBy: z32.string().default(""),
   updatedAt: z32.string(),
@@ -2046,6 +2051,50 @@ var ConversationSchema = z8.object({
   createdAt: z8.string(),
   updatedAt: z8.string()
 }).strict();
+var IMPORT_DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
+var ImportDraftCaseSchema = z9.object({
+  name: z9.string().min(1).max(120),
+  description: z9.string().max(4e3).default(""),
+  businessSteps: z9.array(BusinessStepSchema).max(200),
+  /** Its id or row in the file. */
+  row: z9.string().max(200).default("")
+}).strict();
+var ImportDraftSchema = z9.object({
+  id: z9.string().regex(/^imp_[A-Za-z0-9]+$/),
+  projectId: z9.string().min(1),
+  userId: z9.string().min(1),
+  file: z9.string().max(300),
+  /** Every sheet, every cell as text. */
+  sheets: z9.array(z9.object({ name: z9.string().max(200), rows: z9.array(z9.array(z9.string())) }).strict()).max(200),
+  status: z9.enum(["waiting", "converting", "done", "failed"]).default("waiting"),
+  /** What the assistant made of it: features, each with its cases. */
+  result: z9.array(z9.object({ feature: z9.string().min(1).max(120), cases: z9.array(ImportDraftCaseSchema) }).strict()).default([]),
+  /** The assistant's word on anything it could not convert. */
+  note: z9.string().max(4e3).default(""),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
+}).strict();
+var CaseUpdateRequestSchema = z9.object({
+  id: z9.string().regex(/^upd_[A-Za-z0-9]+$/),
+  projectId: z9.string().min(1),
+  userId: z9.string().min(1),
+  instruction: z9.string().min(1).max(4e3),
+  cases: z9.array(z9.object({
+    id: z9.string().min(1),
+    name: z9.string(),
+    feature: z9.string(),
+    businessSteps: z9.array(BusinessStepSchema)
+  }).strict()).min(1).max(500),
+  status: z9.enum(["waiting", "working", "done", "failed"]).default("waiting"),
+  proposals: z9.array(z9.object({
+    caseId: z9.string().min(1),
+    businessSteps: z9.array(BusinessStepSchema).max(200),
+    note: z9.string().max(2e3).default("")
+  }).strict()).default([]),
+  note: z9.string().max(4e3).default(""),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
+}).strict();
 
 // ../engine-playwright/dist/index.js
 import { createHmac, randomBytes as randomBytes2 } from "crypto";
@@ -6970,8 +7019,8 @@ async function fieldNames(page) {
 }
 
 // ../results/dist/chunk-LYCTVHPR.js
-import { z as z9 } from "zod";
-var RunStatusSchema = z9.enum([
+import { z as z10 } from "zod";
+var RunStatusSchema = z10.enum([
   "queued",
   "running",
   "passed",
@@ -6979,7 +7028,7 @@ var RunStatusSchema = z9.enum([
   "cancelled",
   "errored"
 ]);
-var TaskStatusSchema = z9.enum([
+var TaskStatusSchema = z10.enum([
   "queued",
   "running",
   "passed",
@@ -6988,7 +7037,7 @@ var TaskStatusSchema = z9.enum([
   "cancelled",
   "errored"
 ]);
-var FailureKindSchema = z9.enum([
+var FailureKindSchema = z10.enum([
   "not_found",
   "ambiguous",
   "timeout",
@@ -6997,30 +7046,30 @@ var FailureKindSchema = z9.enum([
   "crash",
   "unknown"
 ]);
-var RunCheckSchema = z9.object({
-  id: z9.string(),
-  assertionId: z9.string().nullable(),
-  kind: z9.string(),
-  expected: z9.string().nullable(),
-  actual: z9.string().nullable(),
-  ok: z9.boolean(),
+var RunCheckSchema = z10.object({
+  id: z10.string(),
+  assertionId: z10.string().nullable(),
+  kind: z10.string(),
+  expected: z10.string().nullable(),
+  actual: z10.string().nullable(),
+  ok: z10.boolean(),
   /** A failed soft check is reported but does not fail its step, so a run can
    *  be green and still carry findings. Stored per check rather than derived,
    *  because the flow it came from can be edited afterwards and history has to
    *  keep saying what actually happened. */
-  soft: z9.boolean().default(false),
-  detail: z9.string().nullable()
+  soft: z10.boolean().default(false),
+  detail: z10.string().nullable()
 });
-var RunStepSchema = z9.object({
-  id: z9.string(),
-  ordinal: z9.number().int().nonnegative(),
+var RunStepSchema = z10.object({
+  id: z10.string(),
+  ordinal: z10.number().int().nonnegative(),
   /** The STABLE document step id — this is what joins runs across time and
    * makes flake-rate a view over existing columns rather than a migration. */
-  stepId: z9.string(),
-  action: z9.string(),
-  targetRole: z9.string().nullable(),
-  targetName: z9.string().nullable(),
-  targetScope: z9.string().nullable(),
+  stepId: z10.string(),
+  action: z10.string(),
+  targetRole: z10.string().nullable(),
+  targetName: z10.string().nullable(),
+  targetScope: z10.string().nullable(),
   /** What the step typed, chose or pressed.
    *
    * A report that says `fill "Password"` and nothing else cannot tell you
@@ -7029,100 +7078,100 @@ var RunStepSchema = z9.object({
    *
    * NEVER set for a secret — see `secret` below. A run report is the thing
    * people paste into a ticket. */
-  value: z9.string().nullable().default(null),
+  value: z10.string().nullable().default(null),
   /** The step typed a secret, so `value` is deliberately absent rather than
    *  merely unknown. Stored, because "no value" and "a value withheld" render
    *  differently and history has to keep saying which it was. */
-  secret: z9.boolean().default(false),
-  status: z9.enum(["passed", "failed", "skipped"]),
+  secret: z10.boolean().default(false),
+  status: z10.enum(["passed", "failed", "skipped"]),
   failureKind: FailureKindSchema.nullable(),
-  detail: z9.string().nullable(),
+  detail: z10.string().nullable(),
   /** WHICH WAY FOUND IT, when the first way did not.
    *
    * A step carries several routes to its element and takes the first that
    * matches. Passing on a later one is not a failure, but it does mean the
    * page has moved under the step — and a suite that repairs itself quietly
    * drifts away from the application it tests. Null is the ordinary case. */
-  foundBy: z9.string().nullable().default(null),
-  durationMs: z9.number().int().nonnegative().nullable(),
+  foundBy: z10.string().nullable().default(null),
+  durationMs: z10.number().int().nonnegative().nullable(),
   /** Where the browser was when this step ran. Recorded on failure, and
    * frequently the whole answer — the element is missing because a step
    * before it navigated somewhere unexpected, not because it was renamed. */
-  pageUrl: z9.string().nullable().default(null),
-  pageTitle: z9.string().nullable().default(null),
-  checks: z9.array(RunCheckSchema).default([])
+  pageUrl: z10.string().nullable().default(null),
+  pageTitle: z10.string().nullable().default(null),
+  checks: z10.array(RunCheckSchema).default([])
 });
-var RunTaskSchema = z9.object({
-  id: z9.string(),
-  ordinal: z9.number().int().nonnegative(),
-  caseName: z9.string(),
-  rowId: z9.string().nullable(),
+var RunTaskSchema = z10.object({
+  id: z10.string(),
+  ordinal: z10.number().int().nonnegative(),
+  caseName: z10.string(),
+  rowId: z10.string().nullable(),
   capability: CapabilitySchema,
-  provider: z9.string(),
-  attempt: z9.number().int().positive().default(1),
-  maxAttempts: z9.number().int().positive().default(1),
+  provider: z10.string(),
+  attempt: z10.number().int().positive().default(1),
+  maxAttempts: z10.number().int().positive().default(1),
   status: TaskStatusSchema,
-  workerId: z9.string().nullable(),
+  workerId: z10.string().nullable(),
   /** Cloud provider's own session, so a failure is one click from their video. */
-  sessionId: z9.string().nullable(),
-  sessionUrl: z9.string().nullable(),
-  detail: z9.string().nullable(),
-  stepsRun: z9.number().int().nonnegative().default(0),
-  stepsTotal: z9.number().int().nonnegative().default(0),
-  durationMs: z9.number().int().nonnegative().nullable(),
-  steps: z9.array(RunStepSchema).default([])
+  sessionId: z10.string().nullable(),
+  sessionUrl: z10.string().nullable(),
+  detail: z10.string().nullable(),
+  stepsRun: z10.number().int().nonnegative().default(0),
+  stepsTotal: z10.number().int().nonnegative().default(0),
+  durationMs: z10.number().int().nonnegative().nullable(),
+  steps: z10.array(RunStepSchema).default([])
 });
-var ArtifactKindSchema = z9.enum(["screenshot", "video", "trace", "console", "har"]);
-var ArtifactSchema = z9.object({
-  id: z9.string(),
-  runId: z9.string(),
-  runStepId: z9.string().nullable(),
+var ArtifactKindSchema = z10.enum(["screenshot", "video", "trace", "console", "har"]);
+var ArtifactSchema = z10.object({
+  id: z10.string(),
+  runId: z10.string(),
+  runStepId: z10.string().nullable(),
   kind: ArtifactKindSchema,
-  relPath: z9.string(),
-  bytes: z9.number().int().nonnegative().nullable(),
-  masked: z9.boolean().default(false),
-  createdAt: z9.string()
+  relPath: z10.string(),
+  bytes: z10.number().int().nonnegative().nullable(),
+  masked: z10.boolean().default(false),
+  createdAt: z10.string()
 });
-var RunSummarySchema = z9.object({
-  id: z9.string(),
-  projectId: z9.string(),
+var RunSummarySchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
   /** What the run was FOR.
    *
    * `flake` is a deliberate repetition of one flow to measure how often it
    * passes. It is kept out of pass-rate statistics: a 98/100 flakiness check is
    * a useful finding, not a failing suite, and counting it as one would make
    * measuring reliability look like losing it. */
-  kind: z9.enum(["smoke", "test", "adhoc", "flake"]),
-  trigger: z9.enum(["ui", "cli", "ci"]),
+  kind: z10.enum(["smoke", "test", "adhoc", "flake"]),
+  trigger: z10.enum(["ui", "cli", "ci"]),
   status: RunStatusSchema,
-  flowId: z9.string().nullable(),
-  flowName: z9.string().nullable(),
-  gitSha: z9.string().nullable(),
-  gitBranch: z9.string().nullable(),
-  gitDirty: z9.boolean().default(false),
-  env: z9.string().nullable(),
-  concurrency: z9.number().int().positive().nullable(),
-  tasksTotal: z9.number().int().nonnegative().default(0),
-  tasksPassed: z9.number().int().nonnegative().default(0),
-  tasksFailed: z9.number().int().nonnegative().default(0),
+  flowId: z10.string().nullable(),
+  flowName: z10.string().nullable(),
+  gitSha: z10.string().nullable(),
+  gitBranch: z10.string().nullable(),
+  gitDirty: z10.boolean().default(false),
+  env: z10.string().nullable(),
+  concurrency: z10.number().int().positive().nullable(),
+  tasksTotal: z10.number().int().nonnegative().default(0),
+  tasksPassed: z10.number().int().nonnegative().default(0),
+  tasksFailed: z10.number().int().nonnegative().default(0),
   /** Rolled up from the run's tasks rather than stored on the run, so they
    * cannot drift from the step rows they describe. "9 of 12" in a list is
    * what tells a reader where a run died; "1 of 1 tasks" tells them nothing
    * until there is more than one browser in play. */
-  stepsRun: z9.number().int().nonnegative().default(0),
-  stepsTotal: z9.number().int().nonnegative().default(0),
-  queuedAt: z9.string(),
-  startedAt: z9.string().nullable(),
-  finishedAt: z9.string().nullable(),
-  durationMs: z9.number().int().nonnegative().nullable()
+  stepsRun: z10.number().int().nonnegative().default(0),
+  stepsTotal: z10.number().int().nonnegative().default(0),
+  queuedAt: z10.string(),
+  startedAt: z10.string().nullable(),
+  finishedAt: z10.string().nullable(),
+  durationMs: z10.number().int().nonnegative().nullable()
 });
 var RunDetailSchema = RunSummarySchema.extend({
-  errorMessage: z9.string().nullable(),
-  artifactsDir: z9.string().nullable(),
-  tasks: z9.array(RunTaskSchema).default([]),
+  errorMessage: z10.string().nullable(),
+  artifactsDir: z10.string().nullable(),
+  tasks: z10.array(RunTaskSchema).default([]),
   /** Screenshots and the like, addressed by `runStepId`. Kept flat rather than
    * nested inside each step: an artifact can belong to the run as a whole. */
-  artifacts: z9.array(ArtifactSchema).default([]),
+  artifacts: z10.array(ArtifactSchema).default([]),
   /** The document as it was executed — a flow, or a test case with the copies
    *  it held that day.
    *
@@ -7131,7 +7180,7 @@ var RunDetailSchema = RunSummarySchema.extend({
    * edited, and without surfacing it the promise was only half kept: the bytes
    * were there and nothing could reach them. Null for runs recorded before a
    * snapshot was taken. */
-  flowSnapshot: z9.unknown().nullable().default(null)
+  flowSnapshot: z10.unknown().nullable().default(null)
 });
 
 // ../results/dist/chunk-IW3PJWP6.js

package/dist/cli.js

@@ -23,7 +23,7 @@ import {
   runtimeValue,
   start,
   status
-} from "./chunk-ZMHE47A5.js";
+} from "./chunk-JJB45ZTL.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
@@ -219,6 +219,28 @@ var ServiceClient = class {
     return this.call(`/api/agent/library?${query}`);
   }
   /** Test cases written, edited or linked in one commit; duplicates skipped. */
+  importPart(projectId, draftId, part) {
+    return this.call(
+      `/api/agent/import-drafts/${encodeURIComponent(draftId)}?projectId=${encodeURIComponent(projectId)}&part=${part}`
+    );
+  }
+  saveImportCases(projectId, draftId, body) {
+    return this.call(
+      `/api/agent/import-drafts/${encodeURIComponent(draftId)}/cases?projectId=${encodeURIComponent(projectId)}`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+  }
+  updateRequest(projectId, id) {
+    return this.call(
+      `/api/agent/update-requests/${encodeURIComponent(id)}?projectId=${encodeURIComponent(projectId)}`
+    );
+  }
+  proposeUpdates(projectId, id, body) {
+    return this.call(
+      `/api/agent/update-requests/${encodeURIComponent(id)}/proposals?projectId=${encodeURIComponent(projectId)}`,
+      { method: "POST", body: JSON.stringify(body) }
+    );
+  }
   readCases(projectId, refs) {
     const ids = refs.filter((r) => /^tc_/.test(r.trim()));
     const names = refs.filter((r) => !/^tc_/.test(r.trim()));
@@ -894,6 +916,25 @@ as learned. Keep what you learn with write_knowledge (features/<name>.md,
 memory/decisions.md, a session summary), on Claude's branch for review \u2014
 never a password, key or token.
 
+UPDATING TEST CASES: when asked to update test cases (upd_\u2026), read the
+request with read_update_request, then propose_case_updates with each changed
+case's complete new steps \u2014 keep what the change does not touch word for
+word, so the person sees exactly what moved. Leave out cases that need no
+change. You never change a test case yourself; the person accepts.
+
+CONVERTING A SPREADSHEET: when asked to convert an import (imp_\u2026), read
+every part with read_import_file, then save_import_cases in batches. Group
+cases into features by product area (a sheet or section usually is one). Each
+case is one scenario: name it after what it proves. Steps: preconditions and
+setup as Given; ONE action per When / And \u2014 split steps that do several
+things; each expected result as Then / And, after the action it follows.
+Keep every case and every step's meaning, and its id from the file in row \u2014
+that id is how a later import of the same file knows the case is already
+there; never invent a step or drop one. A case found in several sheets is
+converted once. Use the project's existing feature names (project_catalog)
+when a case belongs in one, rather than a new look-alike. Rows that are not test cases (titles,
+notes, empty) are left out. Say in note what you could not convert.
+
 HOW TO WORK:
 1. Call project_catalog. Reuse what exists \u2014 published, and on Claude's working
    branch \u2014 rather than writing it again.
@@ -1313,6 +1354,120 @@ ${page}`);
         return text(out);
       }
     },
+    {
+      name: "read_import_file",
+      title: "Read a spreadsheet waiting to be converted",
+      description: "Read one part of a spreadsheet the person is importing (its id is imp_\u2026): every sheet's rows, each as a JSON array of its cells, numbered as the spreadsheet numbers them. Part 1 says how many parts there are; read every one.",
+      inputSchema: {
+        type: "object",
+        properties: { projectId: { type: "string" }, file: { type: "string", description: "The import's id, imp_\u2026" }, part: { type: "number", description: "Which part, from 1." } },
+        required: ["file", "part"],
+        additionalProperties: false
+      },
+      annotations: { readOnlyHint: true },
+      run: async (args) => {
+        const projectId = await projectFor(args["projectId"]);
+        const got = await service.importPart(projectId, str(args["file"]) ?? "", Number(args["part"] ?? 1));
+        return text(`${got.file} \u2014 part ${got.part} of ${got.of}${got.part < got.of ? " (read the rest too)" : " (the last)"}
+
+${got.text}`);
+      }
+    },
+    {
+      name: "save_import_cases",
+      title: "Save the test cases a spreadsheet becomes",
+      description: "Save test cases converted from a spreadsheet being imported (its id is imp_\u2026), in batches as you go: features, each with cases \u2014 name (the scenario it proves), steps as Given / When / Then / And lines, row (its id or row in the file), description (optional). They are shown to the person to import; nothing is written to the project until they do. done: true with the last batch; note: anything you could not convert, and why. restart: true replaces what was saved before.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          file: { type: "string", description: "The import's id, imp_\u2026" },
+          features: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                feature: { type: "string" },
+                cases: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: { name: { type: "string" }, description: { type: "string" }, steps: { type: "array", items: { type: "string" } }, row: { type: "string" } },
+                    required: ["name", "steps"],
+                    additionalProperties: false
+                  }
+                }
+              },
+              required: ["feature", "cases"],
+              additionalProperties: false
+            }
+          },
+          done: { type: "boolean" },
+          note: { type: "string" },
+          restart: { type: "boolean" }
+        },
+        required: ["file", "features"],
+        additionalProperties: false
+      },
+      run: async (args) => {
+        const projectId = await projectFor(args["projectId"]);
+        const features = Array.isArray(args["features"]) ? args["features"] : [];
+        const saved = await service.saveImportCases(projectId, str(args["file"]) ?? "", {
+          features,
+          ...args["done"] === true ? { done: true } : {},
+          ...typeof args["note"] === "string" ? { note: args["note"] } : {},
+          ...args["restart"] === true ? { restart: true } : {}
+        });
+        return text(`Saved ${saved.added} more \u2014 ${saved.total} test cases so far.${saved.done ? " Done: the person can now look them over and import them." : " Keep going, and pass done: true with the last batch."}`);
+      }
+    },
+    {
+      name: "read_update_request",
+      title: "Read what should change in some test cases",
+      description: "Read a request to update test cases (its id is upd_\u2026): what the person wants changed, and each test case as it is now \u2014 its id, feature, name and business steps.",
+      inputSchema: { type: "object", properties: { projectId: { type: "string" }, request: { type: "string", description: "upd_\u2026" } }, required: ["request"], additionalProperties: false },
+      annotations: { readOnlyHint: true },
+      run: async (args) => {
+        const projectId = await projectFor(args["projectId"]);
+        const r = await service.updateRequest(projectId, str(args["request"]) ?? "");
+        return text([
+          `What should change: ${r.instruction}`,
+          ...r.cases.map((c) => [`
+${c.feature} \u203A ${c.name} (${c.id})`, ...c.businessSteps.length ? c.businessSteps.map((s) => `  ${s.keyword} ${s.text}`) : ["  (no steps written)"]].join("\n"))
+        ].join("\n"));
+      }
+    },
+    {
+      name: "propose_case_updates",
+      title: "Propose new steps for test cases",
+      description: "Propose the new business steps for test cases in an update request (upd_\u2026): for each case changed, its id and ALL its steps as Given / When / Then / And lines (the whole case, not only what changed). Cases that need no change are left out. The person sees each before and after and accepts the ones they want; nothing changes until they do. done: true with the last batch; note: anything you could not do.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          projectId: { type: "string" },
+          request: { type: "string", description: "upd_\u2026" },
+          updates: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: { case: { type: "string", description: "The test case's id, tc_\u2026" }, steps: { type: "array", items: { type: "string" } }, note: { type: "string", description: "Why, in a few words." } },
+              required: ["case", "steps"],
+              additionalProperties: false
+            }
+          },
+          done: { type: "boolean" },
+          note: { type: "string" }
+        },
+        required: ["request", "updates"],
+        additionalProperties: false
+      },
+      run: async (args) => {
+        const projectId = await projectFor(args["projectId"]);
+        const updates = Array.isArray(args["updates"]) ? args["updates"] : [];
+        const r = await service.proposeUpdates(projectId, str(args["request"]) ?? "", { updates, ...args["done"] === true ? { done: true } : {}, ...typeof args["note"] === "string" ? { note: args["note"] } : {} });
+        return text(`Proposed new steps for ${r.proposed} of ${r.of} test cases.${r.done ? " Done: the person can now accept them." : " Pass done: true with the last batch."}`);
+      }
+    },
     {
       name: "read_test_cases",
       title: "Read test cases",

package/dist/engine.js

@@ -9,7 +9,7 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-ZMHE47A5.js";
+} from "./chunk-JJB45ZTL.js";
 export {
   AGENT_VERSION,
   browsersReady,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowriki/agent",
-  "version": "0.1.0-beta.43",
+  "version": "0.1.0-beta.45",
   "description": "Run Flowriki UI tests on your own computer. Connects this machine to your Flowriki account.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",