@qawolf/cli 1.7.0 → 1.7.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.js +349 -10
- package/package.json +2 -2
- package/skills/qawolf-cli/SKILL.md +70 -41
package/dist/cli.js
CHANGED
|
@@ -171314,16 +171314,149 @@ var makeCreateRunContract = (ids) => {
|
|
|
171314
171314
|
};
|
|
171315
171315
|
};
|
|
171316
171316
|
|
|
171317
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/environment.js
|
|
171318
|
+
var reservedRunEnvironmentVariablePrefix = "QAWOLF_";
|
|
171319
|
+
function refusalForRunEnvironmentVariableName(name) {
|
|
171320
|
+
if (name.length < 1 || name.length > 256)
|
|
171321
|
+
return "An environment variable name must be between 1 and 256 characters.";
|
|
171322
|
+
if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
|
|
171323
|
+
return "An environment variable name may contain only letters, digits and underscores, and must not start with a digit.";
|
|
171324
|
+
if (name.toUpperCase().startsWith(reservedRunEnvironmentVariablePrefix))
|
|
171325
|
+
return `Environment variable names beginning with ${reservedRunEnvironmentVariablePrefix} are reserved by QA Wolf and set for you.`;
|
|
171326
|
+
return;
|
|
171327
|
+
}
|
|
171328
|
+
var maxRunEnvironmentVariables = 100;
|
|
171329
|
+
var maxRunEnvironmentValueLength = 8 * 1024;
|
|
171330
|
+
var runEnvironmentSchema = exports_external.record(exports_external.string(), exports_external.string().max(maxRunEnvironmentValueLength)).superRefine((environment, refinementContext) => {
|
|
171331
|
+
for (const name of Object.keys(environment)) {
|
|
171332
|
+
const refusal = refusalForRunEnvironmentVariableName(name);
|
|
171333
|
+
if (refusal === undefined)
|
|
171334
|
+
continue;
|
|
171335
|
+
refinementContext.addIssue({
|
|
171336
|
+
code: "custom",
|
|
171337
|
+
message: refusal,
|
|
171338
|
+
path: [name]
|
|
171339
|
+
});
|
|
171340
|
+
}
|
|
171341
|
+
}).refine((environment) => Object.keys(environment).length <= maxRunEnvironmentVariables, {
|
|
171342
|
+
error: `At most ${maxRunEnvironmentVariables} environment variables may be supplied.`
|
|
171343
|
+
});
|
|
171344
|
+
|
|
171345
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/files.js
|
|
171346
|
+
var shippableRunFileExtensions = [
|
|
171347
|
+
".cjs",
|
|
171348
|
+
".js",
|
|
171349
|
+
".json",
|
|
171350
|
+
".mjs",
|
|
171351
|
+
".ts",
|
|
171352
|
+
".tsx"
|
|
171353
|
+
];
|
|
171354
|
+
var maxRunFilePathLength = 1024;
|
|
171355
|
+
function isShippableRunFilePathSegment(segment) {
|
|
171356
|
+
if (segment === "" || segment === "." || segment === "..")
|
|
171357
|
+
return false;
|
|
171358
|
+
if (segment.startsWith("."))
|
|
171359
|
+
return false;
|
|
171360
|
+
if (segment.includes("\\"))
|
|
171361
|
+
return false;
|
|
171362
|
+
return !/[\u0000-\u001f\u007f]/.test(segment);
|
|
171363
|
+
}
|
|
171364
|
+
var neverShippedPathSegments = new Set(["node_modules"]);
|
|
171365
|
+
function isShippableRunFilePath(path2) {
|
|
171366
|
+
if (path2.length < 1 || path2.length > maxRunFilePathLength)
|
|
171367
|
+
return false;
|
|
171368
|
+
if (!shippableRunFileExtensions.some((extension) => path2.endsWith(extension)))
|
|
171369
|
+
return false;
|
|
171370
|
+
return path2.split("/").every((segment) => isShippableRunFilePathSegment(segment) && !neverShippedPathSegments.has(segment));
|
|
171371
|
+
}
|
|
171372
|
+
var runFilePathRefusal = `A run file path must end in one of ${shippableRunFileExtensions.join(", ")}, be at most ${maxRunFilePathLength} characters, and be a relative path whose segments are none of: empty, "." or "..", dot-prefixed, "node_modules", or containing a backslash or a control character.`;
|
|
171373
|
+
var runFilePathSchema = exports_external.string().refine(isShippableRunFilePath, {
|
|
171374
|
+
error: runFilePathRefusal
|
|
171375
|
+
});
|
|
171376
|
+
var runPackageJsonPath = "package.json";
|
|
171377
|
+
|
|
171378
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/identity.js
|
|
171379
|
+
var runnerNameSchema = exports_external.enum([
|
|
171380
|
+
"node20Basic",
|
|
171381
|
+
"node20WithAndroid",
|
|
171382
|
+
"node20WithIos",
|
|
171383
|
+
"node20WithPlaywright"
|
|
171384
|
+
]);
|
|
171385
|
+
var runnerIdSchema = exports_external.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "A runner id may contain only lowercase letters, digits and dashes, and must start and end with a letter or digit.");
|
|
171386
|
+
var makeRunnerSchema = () => exports_external.object({
|
|
171387
|
+
gpuAccelerated: exports_external.boolean().describe("Whether the runner was placed on GPU hardware. Chosen by QA Wolf from the team's configuration and what the fleet can provide, not requested."),
|
|
171388
|
+
id: runnerIdSchema.describe("The runner's id, as supplied when launching it."),
|
|
171389
|
+
runnerName: runnerNameSchema.describe("The image requested when the runner was launched. QA Wolf may place it on faster hardware, reported in gpuAccelerated.")
|
|
171390
|
+
});
|
|
171391
|
+
|
|
171392
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/journal.js
|
|
171393
|
+
var journalEntrySchema = exports_external.object({
|
|
171394
|
+
payload: exports_external.unknown(),
|
|
171395
|
+
recordedAt: exports_external.iso.datetime(),
|
|
171396
|
+
sequence: exports_external.number().int().positive()
|
|
171397
|
+
}).refine((entry) => ("payload" in entry), {
|
|
171398
|
+
error: "A journal entry must carry a payload key.",
|
|
171399
|
+
path: ["payload"]
|
|
171400
|
+
}).transform((entry) => ({
|
|
171401
|
+
payload: entry.payload,
|
|
171402
|
+
recordedAt: entry.recordedAt,
|
|
171403
|
+
sequence: entry.sequence
|
|
171404
|
+
}));
|
|
171405
|
+
var knownJournalStreams = [
|
|
171406
|
+
"console",
|
|
171407
|
+
"recorder",
|
|
171408
|
+
"run-events",
|
|
171409
|
+
"run-logs",
|
|
171410
|
+
"run-status"
|
|
171411
|
+
];
|
|
171412
|
+
var maxJournalStreamNameLength = 64;
|
|
171413
|
+
var journalStreamSchema = exports_external.string().max(maxJournalStreamNameLength).regex(/^[a-z][a-z0-9-]{0,63}$/);
|
|
171414
|
+
var readJournalRequestSchema = exports_external.object({
|
|
171415
|
+
runId: exports_external.string().min(1).max(128).optional(),
|
|
171416
|
+
sinceSequence: exports_external.number().int().nonnegative().optional(),
|
|
171417
|
+
stream: journalStreamSchema,
|
|
171418
|
+
tail: exports_external.number().int().positive().optional()
|
|
171419
|
+
});
|
|
171420
|
+
var readJournalResponseSchema = exports_external.object({
|
|
171421
|
+
entries: exports_external.array(journalEntrySchema),
|
|
171422
|
+
hasUnsearchedHistory: exports_external.boolean(),
|
|
171423
|
+
nextSequence: exports_external.number().int().nonnegative(),
|
|
171424
|
+
oldestAvailableSequence: exports_external.number().int().nonnegative()
|
|
171425
|
+
});
|
|
171426
|
+
|
|
171427
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/payloadSize.js
|
|
171428
|
+
var maxRunFilesByteLength = 4 * 1024 * 1024;
|
|
171429
|
+
var maxRunnerRequestEncodedByteLength = 9 * 1024 * 1024;
|
|
171430
|
+
function runFilesByteLength(files) {
|
|
171431
|
+
return Object.entries(files).reduce((total, [path2, content]) => total + utf8ByteLength(content) + utf8ByteLength(path2), 0);
|
|
171432
|
+
}
|
|
171433
|
+
function utf8ByteLength(text) {
|
|
171434
|
+
return Buffer.byteLength(text, "utf8");
|
|
171435
|
+
}
|
|
171436
|
+
var runFilesSchema = exports_external.record(exports_external.string(), exports_external.string()).superRefine((files, refinementContext) => {
|
|
171437
|
+
for (const path2 of Object.keys(files)) {
|
|
171438
|
+
if (isShippableRunFilePath(path2))
|
|
171439
|
+
continue;
|
|
171440
|
+
refinementContext.addIssue({
|
|
171441
|
+
code: "custom",
|
|
171442
|
+
message: runFilePathRefusal,
|
|
171443
|
+
path: [path2]
|
|
171444
|
+
});
|
|
171445
|
+
}
|
|
171446
|
+
}).refine((files) => runFilesByteLength(files) <= maxRunFilesByteLength, {
|
|
171447
|
+
error: `The files in one request may carry at most ${maxRunFilesByteLength} bytes in total.`
|
|
171448
|
+
});
|
|
171449
|
+
|
|
171317
171450
|
// node_modules/@qawolf/api-contracts/dist/v1/automate/index.js
|
|
171318
171451
|
var makeAutomateContract = (ids) => {
|
|
171319
171452
|
const input = exports_external.object({
|
|
171320
171453
|
environmentId: ids.environmentRef,
|
|
171321
|
-
flowIds: exports_external.array(ids.flow).min(1).max(300).refine((flowIds) => new Set(flowIds).size === flowIds.length, "flowIds must be unique").describe("
|
|
171322
|
-
patch: exports_external.string().min(1).max(1e6).optional().describe("Unified diff applied to the automation's working branch before it runs.")
|
|
171454
|
+
flowIds: exports_external.array(ids.flow).min(1).max(300).refine((flowIds) => new Set(flowIds).size === flowIds.length, "flowIds must be unique").describe("IDs of every requested draft flow the automation builds. Reuse an existing draft only when its name matches the requested journey; a generic starter or placeholder is not a match. After publishing, resolve the IDs with `qawolf --json flows list --remote --env <environment-id-or-alias> --include-drafts`."),
|
|
171455
|
+
patch: exports_external.string().min(1).max(1e6).optional().describe("Unified diff applied to the automation's working branch before it runs. It cannot create or rename a selected flow; publish selected flows with Git first.")
|
|
171323
171456
|
});
|
|
171324
171457
|
const output = resource({ automationId: ids.automation }, { urlFieldDescription: "Absolute URL of the automation review page." });
|
|
171325
171458
|
return {
|
|
171326
|
-
description: "Request
|
|
171459
|
+
description: "Request automation for draft flows. First create a named local .flow.ts draft for every requested journey that does not already have a matching draft; never reuse a generic starter or placeholder. Each new draft must start with a JSDoc Goal: description, import flow from @qawolf/flows/web, and use export default flow(...); a comment-only file or direct test(...) call is not a valid draft. Commit and push all changes with Git to publish them, then list remote drafts to resolve every selected ID. Do not use patch to create or rename a selected flow. Finally make one automation request containing all requested flow IDs.",
|
|
171327
171460
|
input,
|
|
171328
171461
|
kind: "write",
|
|
171329
171462
|
name: "automate",
|
|
@@ -171373,6 +171506,7 @@ var makeEnvironmentResourceSchema = (ids) => resource({
|
|
|
171373
171506
|
id: ids.environment,
|
|
171374
171507
|
kind: exports_external.enum(["static", "preview"]).describe("Whether the environment is static or a preview."),
|
|
171375
171508
|
name: exports_external.string(),
|
|
171509
|
+
runConcurrencyLimit: exports_external.string().describe('Maximum number of concurrent runs: a whole number, "unlimited", or a concurrency expression.'),
|
|
171376
171510
|
status: exports_external.enum(["blocked", "needs-investigation", "ready", "running"]).describe("Standing health across the environment's runs: blocked (open blocking bugs), needs-investigation (failures awaiting triage), running (flows executing), ready (none of the above — the greenlit state)."),
|
|
171377
171511
|
terminatedAt: exports_external.iso.datetime().optional().describe("When the environment was terminated, if it has been.")
|
|
171378
171512
|
}, { urlFieldDescription: "Absolute URL of the environment page." });
|
|
@@ -171397,6 +171531,28 @@ var makeFindEnvironmentsContract = (ids) => {
|
|
|
171397
171531
|
};
|
|
171398
171532
|
};
|
|
171399
171533
|
|
|
171534
|
+
// node_modules/@qawolf/api-contracts/dist/v1/environment/getVariable.js
|
|
171535
|
+
var makeGetEnvironmentVariableContract = (ids) => {
|
|
171536
|
+
const input = exports_external.object({
|
|
171537
|
+
environmentId: ids.environmentRef,
|
|
171538
|
+
variableNames: exports_external.array(exports_external.string().min(1).max(255)).min(1).max(100).describe("Names of the environment variables to read. Names match exactly as environment.listVariableNames returns them. Request every name you need in a single call, up to 100 names per call.")
|
|
171539
|
+
});
|
|
171540
|
+
const output = exports_external.object({
|
|
171541
|
+
missingNames: exports_external.array(exports_external.string()).describe("Requested names the environment does not have, sorted alphabetically."),
|
|
171542
|
+
variables: exports_external.array(exports_external.object({
|
|
171543
|
+
name: exports_external.string().describe("The stored variable name."),
|
|
171544
|
+
value: exports_external.string().describe("The variable's secret value. Handle as a secret.")
|
|
171545
|
+
})).describe("The found variables, sorted by name.")
|
|
171546
|
+
});
|
|
171547
|
+
return {
|
|
171548
|
+
description: "Read the values of named environment variables in one call. Values are secrets. Names that do not exist go to missingNames and do not fail the call.",
|
|
171549
|
+
input,
|
|
171550
|
+
kind: "read",
|
|
171551
|
+
name: "environment.getVariable",
|
|
171552
|
+
output
|
|
171553
|
+
};
|
|
171554
|
+
};
|
|
171555
|
+
|
|
171400
171556
|
// node_modules/@qawolf/api-contracts/dist/v1/environment/index.js
|
|
171401
171557
|
var makeGetEnvironmentContract = (ids) => {
|
|
171402
171558
|
const input = exports_external.object({
|
|
@@ -171404,7 +171560,7 @@ var makeGetEnvironmentContract = (ids) => {
|
|
|
171404
171560
|
});
|
|
171405
171561
|
const output = makeEnvironmentResourceSchema(ids);
|
|
171406
171562
|
return {
|
|
171407
|
-
description: "Read a single environment's name, kind, health status, and termination state.",
|
|
171563
|
+
description: "Read a single environment's name, kind, health status, run concurrency limit, and termination state.",
|
|
171408
171564
|
input,
|
|
171409
171565
|
kind: "read",
|
|
171410
171566
|
name: "environment.get",
|
|
@@ -171458,6 +171614,27 @@ var makeCreateEnvironmentContract = (ids) => {
|
|
|
171458
171614
|
};
|
|
171459
171615
|
};
|
|
171460
171616
|
|
|
171617
|
+
// node_modules/@qawolf/api-contracts/dist/v1/environment/update.js
|
|
171618
|
+
var makeUpdateEnvironmentContract = (ids) => {
|
|
171619
|
+
const nameSchema = exports_external.string().trim().min(1).max(255).describe("New display name. Must be unique within the team.");
|
|
171620
|
+
const runConcurrencyLimitSchema = exports_external.string().trim().min(1).max(255).describe('New run concurrency limit: a whole number, "unlimited", or a concurrency expression. The server validates the expression.');
|
|
171621
|
+
const input = exports_external.object({
|
|
171622
|
+
environmentId: ids.environmentRef,
|
|
171623
|
+
name: nameSchema.optional(),
|
|
171624
|
+
runConcurrencyLimit: runConcurrencyLimitSchema.optional()
|
|
171625
|
+
}).refine((update) => update.name !== undefined || update.runConcurrencyLimit !== undefined, {
|
|
171626
|
+
message: "At least one of name or runConcurrencyLimit is required."
|
|
171627
|
+
});
|
|
171628
|
+
const output = makeEnvironmentResourceSchema(ids);
|
|
171629
|
+
return {
|
|
171630
|
+
description: "Update an environment owned by the caller's team and return it in the environment.get shape. Omitted fields remain unchanged.",
|
|
171631
|
+
input,
|
|
171632
|
+
kind: "write",
|
|
171633
|
+
name: "environment.update",
|
|
171634
|
+
output
|
|
171635
|
+
};
|
|
171636
|
+
};
|
|
171637
|
+
|
|
171461
171638
|
// node_modules/@qawolf/api-contracts/dist/v1/tag/index.js
|
|
171462
171639
|
var makeTagResourceSchema = () => resource({
|
|
171463
171640
|
color: exports_external.string().regex(/^#[0-9a-fA-F]{6}$/).describe("The tag's display color as a hex code, assigned by QA Wolf."),
|
|
@@ -171495,6 +171672,9 @@ var makeAddTagToFlowsContract = (ids) => {
|
|
|
171495
171672
|
};
|
|
171496
171673
|
};
|
|
171497
171674
|
|
|
171675
|
+
// node_modules/@qawolf/api-contracts/dist/v1/flow/readiness.js
|
|
171676
|
+
var flowReadinessSchema = exports_external.enum(["draft", "active"]);
|
|
171677
|
+
|
|
171498
171678
|
// node_modules/@qawolf/api-contracts/dist/v1/flow/index.js
|
|
171499
171679
|
var makeListFlowsContract = (ids) => {
|
|
171500
171680
|
const input = exports_external.object({
|
|
@@ -171508,6 +171688,7 @@ var makeListFlowsContract = (ids) => {
|
|
|
171508
171688
|
flowId: ids.flow,
|
|
171509
171689
|
name: exports_external.string(),
|
|
171510
171690
|
path: exports_external.string().describe("The flow file path, relative to the repo."),
|
|
171691
|
+
readiness: flowReadinessSchema.describe("Whether the flow is a draft. Set it with flow.update."),
|
|
171511
171692
|
tags: exports_external.array(exports_external.string())
|
|
171512
171693
|
}, {
|
|
171513
171694
|
urlFieldDescription: "Absolute URL of the flow page in its environment."
|
|
@@ -171522,6 +171703,30 @@ var makeListFlowsContract = (ids) => {
|
|
|
171522
171703
|
};
|
|
171523
171704
|
};
|
|
171524
171705
|
|
|
171706
|
+
// node_modules/@qawolf/api-contracts/dist/v1/flow/update.js
|
|
171707
|
+
var makeUpdateFlowContract = (ids) => {
|
|
171708
|
+
const input = exports_external.object({
|
|
171709
|
+
flowId: ids.flow,
|
|
171710
|
+
readiness: flowReadinessSchema.describe("The readiness to set. Draft flows do not run in triggered suites.")
|
|
171711
|
+
});
|
|
171712
|
+
const output = exports_external.object({
|
|
171713
|
+
flow: resource({
|
|
171714
|
+
flowId: ids.flow,
|
|
171715
|
+
name: exports_external.string(),
|
|
171716
|
+
readiness: flowReadinessSchema.describe("The flow readiness after the update.")
|
|
171717
|
+
}, {
|
|
171718
|
+
urlFieldDescription: "Absolute URL of the flow page."
|
|
171719
|
+
})
|
|
171720
|
+
});
|
|
171721
|
+
return {
|
|
171722
|
+
description: "Move a flow between draft and active readiness. The other statuses shown in the app are derived and cannot be set.",
|
|
171723
|
+
input,
|
|
171724
|
+
kind: "write",
|
|
171725
|
+
name: "flow.update",
|
|
171726
|
+
output
|
|
171727
|
+
};
|
|
171728
|
+
};
|
|
171729
|
+
|
|
171525
171730
|
// node_modules/@qawolf/api-contracts/dist/v1/issue/index.js
|
|
171526
171731
|
var issuePrioritySchema = exports_external.enum([
|
|
171527
171732
|
"unprioritized",
|
|
@@ -171705,7 +171910,8 @@ var makeGetRunContract = (ids) => {
|
|
|
171705
171910
|
const flows = exports_external.array(exports_external.discriminatedUnion("status", [failedFlow, nonFailedFlow])).describe("The run's flows, ordered alphabetically by name.");
|
|
171706
171911
|
const output = resource({
|
|
171707
171912
|
...makeRunSummaryFields(ids),
|
|
171708
|
-
flows
|
|
171913
|
+
flows,
|
|
171914
|
+
runId: ids.run.describe("The run this response describes. Treat it as canonical: it can differ from the id you asked for. A deploy notification returns a run id before the run exists, and if a second notification for the same commit is folded into an earlier run, that id resolves to the earlier run instead.")
|
|
171709
171915
|
}, { urlFieldDescription: "Absolute URL of the run page." });
|
|
171710
171916
|
return {
|
|
171711
171917
|
description: "Get a run's status, per-flow results, and links.",
|
|
@@ -171716,6 +171922,129 @@ var makeGetRunContract = (ids) => {
|
|
|
171716
171922
|
};
|
|
171717
171923
|
};
|
|
171718
171924
|
|
|
171925
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/unreachable.js
|
|
171926
|
+
var runnerUnreachableSchema = exports_external.object({
|
|
171927
|
+
outcome: exports_external.literal("runner-unreachable")
|
|
171928
|
+
});
|
|
171929
|
+
var retryableRunnerUnreachableDescription = "`runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again.";
|
|
171930
|
+
|
|
171931
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/evaluateSnippet.js
|
|
171932
|
+
var maxSnippetCodeLength = 64 * 1024;
|
|
171933
|
+
var makeEvaluateSnippetOnRunnerContract = () => {
|
|
171934
|
+
const input = exports_external.object({
|
|
171935
|
+
code: exports_external.string().min(1).max(maxSnippetCodeLength).describe("The code to evaluate against the runner's live page, in the scope of `filePath` when one is given."),
|
|
171936
|
+
filePath: runFilePathSchema.optional().describe("Path of the file the snippet is evaluated in the scope of. Omit to evaluate a snippet that imports nothing of yours."),
|
|
171937
|
+
files: runFilesSchema.optional().describe("The file named by `filePath` and everything it imports. A runner holds no copy of your project, so a snippet's scope has to travel with it."),
|
|
171938
|
+
id: runnerIdSchema.describe("Id of the runner to evaluate the snippet on.")
|
|
171939
|
+
}).refine((request) => request.filePath === undefined || Object.hasOwn(request.files ?? {}, request.filePath), {
|
|
171940
|
+
error: "A snippet naming a file must carry that file in files.",
|
|
171941
|
+
path: ["files"]
|
|
171942
|
+
});
|
|
171943
|
+
const output = exports_external.discriminatedUnion("outcome", [
|
|
171944
|
+
exports_external.object({
|
|
171945
|
+
errorMessage: exports_external.string().optional().describe("Present when `result` is `error`."),
|
|
171946
|
+
outcome: exports_external.literal("evaluated"),
|
|
171947
|
+
result: exports_external.enum(["success", "stopped", "error"]).describe("`success` if the snippet ran to completion, `stopped` if it was interrupted, `error` if it threw. Whether it ran, not what it evaluated to.")
|
|
171948
|
+
}),
|
|
171949
|
+
runnerUnreachableSchema
|
|
171950
|
+
]);
|
|
171951
|
+
return {
|
|
171952
|
+
description: "Evaluate a snippet against whatever the runner's browser is showing right now. Answers whether the snippet ran, and its error if it threw — not the value it evaluated to, so read anything you want back out of the runner's journal (a snippet's `console.log` lands in the `console` stream). A snippet starts no run and leaves no run-scoped journal entries of its own. `runner-unreachable` if the runner could not be reached or could not evaluate: as well as a runner that is still starting, has terminated after inactivity, or is busy, this covers a runner with no live page to evaluate against — which will never clear, so check that the runner you launched is one that runs a browser before retrying. It is NOT proof the snippet did not run: a snippet that outlives the answer window is still executing when you read this, so do not blindly resubmit one that mutates what the page is looking at.",
|
|
171953
|
+
input,
|
|
171954
|
+
kind: "write",
|
|
171955
|
+
name: "runner.evaluateSnippet",
|
|
171956
|
+
output
|
|
171957
|
+
};
|
|
171958
|
+
};
|
|
171959
|
+
|
|
171960
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/index.js
|
|
171961
|
+
var makeLaunchRunnerContract = () => {
|
|
171962
|
+
const input = exports_external.object({
|
|
171963
|
+
id: runnerIdSchema.describe("Id to launch the runner under, chosen by the caller. Launching the same id again returns the runner already running under it."),
|
|
171964
|
+
runnerName: runnerNameSchema.optional().describe("Image to run. Defaults to the standard web image, node20WithPlaywright.")
|
|
171965
|
+
});
|
|
171966
|
+
const output = makeRunnerSchema().extend({
|
|
171967
|
+
outcome: exports_external.enum(["launched", "already-running"]).describe("`launched` if this call started the runner. `already-running` if a runner was already running under this id and was returned unchanged — no second runner was started.")
|
|
171968
|
+
});
|
|
171969
|
+
return {
|
|
171970
|
+
description: "Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `outcome` to tell which happened.",
|
|
171971
|
+
input,
|
|
171972
|
+
kind: "write",
|
|
171973
|
+
name: "runner.launch",
|
|
171974
|
+
output
|
|
171975
|
+
};
|
|
171976
|
+
};
|
|
171977
|
+
var makeStopRunnerContract = () => {
|
|
171978
|
+
const input = exports_external.object({
|
|
171979
|
+
id: runnerIdSchema.describe("Id of the runner to stop.")
|
|
171980
|
+
});
|
|
171981
|
+
const output = exports_external.object({
|
|
171982
|
+
id: runnerIdSchema.describe("Id of the runner the call addressed."),
|
|
171983
|
+
outcome: exports_external.enum(["stopped", "not-running"]).describe("`stopped` if the runner was running and has been stopped. `not-running` if no running runner has this id — it was already stopped, was never launched, or terminated on its own after inactivity; these are not distinguished, because the run system keeps no record of a runner once it is gone.")
|
|
171984
|
+
});
|
|
171985
|
+
return {
|
|
171986
|
+
description: "Stop an interactive runner on the caller's team. Stopping a runner that is not running succeeds and reports `not-running`, so a retry needs no special handling.",
|
|
171987
|
+
input,
|
|
171988
|
+
kind: "write",
|
|
171989
|
+
name: "runner.stop",
|
|
171990
|
+
output
|
|
171991
|
+
};
|
|
171992
|
+
};
|
|
171993
|
+
|
|
171994
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/readJournal.js
|
|
171995
|
+
var makeReadRunnerJournalContract = () => {
|
|
171996
|
+
const input = readJournalRequestSchema.extend({
|
|
171997
|
+
id: runnerIdSchema.describe("Id of the runner to read the journal of."),
|
|
171998
|
+
stream: journalStreamSchema.describe(`The stream to read. QA Wolf writes ${knownJournalStreams.join(", ")}; an unwritten stream reads as empty rather than as an error.`)
|
|
171999
|
+
});
|
|
172000
|
+
const output = exports_external.discriminatedUnion("outcome", [
|
|
172001
|
+
readJournalResponseSchema.extend({ outcome: exports_external.literal("read") }),
|
|
172002
|
+
runnerUnreachableSchema
|
|
172003
|
+
]);
|
|
172004
|
+
return {
|
|
172005
|
+
description: `Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: \`run-status\` settles it, \`run-logs\` and \`run-events\` carry what it produced, and \`recorder\` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. ${retryableRunnerUnreachableDescription}`,
|
|
172006
|
+
input,
|
|
172007
|
+
kind: "read",
|
|
172008
|
+
name: "runner.readJournal",
|
|
172009
|
+
output
|
|
172010
|
+
};
|
|
172011
|
+
};
|
|
172012
|
+
|
|
172013
|
+
// node_modules/@qawolf/api-contracts/dist/v1/runner/runFlow.js
|
|
172014
|
+
var makeRunFlowOnRunnerContract = () => {
|
|
172015
|
+
const input = exports_external.object({
|
|
172016
|
+
entryPointPath: runFilePathSchema.describe("Path of the flow file to run, as it appears in `files`."),
|
|
172017
|
+
env: runEnvironmentSchema.optional().describe("Environment variables to make available to the run."),
|
|
172018
|
+
files: runFilesSchema.describe("Every file the run needs keyed by its path — the flow file, everything it imports, package.json and tsconfig.json. A runner holds no copy of your project, so what runs is exactly what is sent here."),
|
|
172019
|
+
id: runnerIdSchema.describe("Id of the runner to run the flow on.")
|
|
172020
|
+
}).refine((request) => Object.hasOwn(request.files, request.entryPointPath), {
|
|
172021
|
+
error: "The entry point must be one of the files.",
|
|
172022
|
+
path: ["files"]
|
|
172023
|
+
}).refine((request) => Object.hasOwn(request.files, runPackageJsonPath), {
|
|
172024
|
+
error: `The files must include ${runPackageJsonPath}; the run's npm dependencies are read from it.`,
|
|
172025
|
+
path: ["files"]
|
|
172026
|
+
});
|
|
172027
|
+
const output = exports_external.discriminatedUnion("outcome", [
|
|
172028
|
+
exports_external.object({
|
|
172029
|
+
outcome: exports_external.literal("submitted"),
|
|
172030
|
+
runId: exports_external.string().describe("Id of the run, to follow it by. Read the `run-status` stream of the runner's journal for its outcome, and `run-logs` and `run-events` for its output.")
|
|
172031
|
+
}),
|
|
172032
|
+
runnerUnreachableSchema,
|
|
172033
|
+
exports_external.object({
|
|
172034
|
+
outcome: exports_external.literal("runner-target-mismatch"),
|
|
172035
|
+
requiredRunnerName: runnerNameSchema.describe("The image this flow's execution target needs."),
|
|
172036
|
+
runnerName: runnerNameSchema.describe("The image the runner is actually running.")
|
|
172037
|
+
})
|
|
172038
|
+
]);
|
|
172039
|
+
return {
|
|
172040
|
+
description: "Run a flow on an interactive runner. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call answers `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared.",
|
|
172041
|
+
input,
|
|
172042
|
+
kind: "write",
|
|
172043
|
+
name: "runner.runFlow",
|
|
172044
|
+
output
|
|
172045
|
+
};
|
|
172046
|
+
};
|
|
172047
|
+
|
|
171719
172048
|
// node_modules/@qawolf/api-contracts/dist/v1/tag/list.js
|
|
171720
172049
|
var makeListTagsContract = (ids) => {
|
|
171721
172050
|
const input = exports_external.object({
|
|
@@ -171748,12 +172077,15 @@ var makeContractsV1 = (ids) => {
|
|
|
171748
172077
|
deleteVariable: makeDeleteEnvironmentVariableContract(resolvedIds),
|
|
171749
172078
|
find: makeFindEnvironmentsContract(resolvedIds),
|
|
171750
172079
|
get: makeGetEnvironmentContract(resolvedIds),
|
|
172080
|
+
getVariable: makeGetEnvironmentVariableContract(resolvedIds),
|
|
171751
172081
|
listVariableNames: makeListEnvironmentVariableNamesContract(resolvedIds),
|
|
171752
|
-
setVariable: makeSetEnvironmentVariableContract(resolvedIds)
|
|
172082
|
+
setVariable: makeSetEnvironmentVariableContract(resolvedIds),
|
|
172083
|
+
update: makeUpdateEnvironmentContract(resolvedIds)
|
|
171753
172084
|
},
|
|
171754
172085
|
flow: {
|
|
171755
172086
|
addTag: makeAddTagToFlowsContract(resolvedIds),
|
|
171756
|
-
list: makeListFlowsContract(resolvedIds)
|
|
172087
|
+
list: makeListFlowsContract(resolvedIds),
|
|
172088
|
+
update: makeUpdateFlowContract(resolvedIds)
|
|
171757
172089
|
},
|
|
171758
172090
|
issue: {
|
|
171759
172091
|
create: makeCreateIssueContract(resolvedIds),
|
|
@@ -171766,6 +172098,13 @@ var makeContractsV1 = (ids) => {
|
|
|
171766
172098
|
find: makeFindRunsContract(resolvedIds),
|
|
171767
172099
|
get: makeGetRunContract(resolvedIds)
|
|
171768
172100
|
},
|
|
172101
|
+
runner: {
|
|
172102
|
+
evaluateSnippet: makeEvaluateSnippetOnRunnerContract(),
|
|
172103
|
+
launch: makeLaunchRunnerContract(),
|
|
172104
|
+
readJournal: makeReadRunnerJournalContract(),
|
|
172105
|
+
runFlow: makeRunFlowOnRunnerContract(),
|
|
172106
|
+
stop: makeStopRunnerContract()
|
|
172107
|
+
},
|
|
171769
172108
|
tag: {
|
|
171770
172109
|
create: makeCreateTagContract(),
|
|
171771
172110
|
list: makeListTagsContract(resolvedIds)
|
|
@@ -174272,7 +174611,7 @@ function startUpdateCheck(deps) {
|
|
|
174272
174611
|
// package.json
|
|
174273
174612
|
var package_default = {
|
|
174274
174613
|
name: "@qawolf/cli",
|
|
174275
|
-
version: "1.7.
|
|
174614
|
+
version: "1.7.1",
|
|
174276
174615
|
description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
|
|
174277
174616
|
keywords: [
|
|
174278
174617
|
"automation",
|
|
@@ -174333,7 +174672,7 @@ var package_default = {
|
|
|
174333
174672
|
"@napi-rs/keyring": "1.3.0",
|
|
174334
174673
|
"@oxc-node/core": "0.1.0",
|
|
174335
174674
|
"@playwright/test": "1.62.0",
|
|
174336
|
-
"@qawolf/api-contracts": "0.
|
|
174675
|
+
"@qawolf/api-contracts": "0.22.0",
|
|
174337
174676
|
"@qawolf/emails": "1.1.1",
|
|
174338
174677
|
"@qawolf/flow-targets": "1.0.0",
|
|
174339
174678
|
"@qawolf/flows": "0.1.4",
|
|
@@ -184358,4 +184697,4 @@ createProgram({ signals }).parseAsync().catch(() => {
|
|
|
184358
184697
|
process.exitCode = 1;
|
|
184359
184698
|
}).finally(() => flushAndExit(typeof process.exitCode === "number" ? process.exitCode : 0));
|
|
184360
184699
|
|
|
184361
|
-
//# debugId=
|
|
184700
|
+
//# debugId=80FB9FE67B1F0A9564756E2164756E21
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@qawolf/cli",
|
|
3
|
-
"version": "1.7.
|
|
3
|
+
"version": "1.7.1",
|
|
4
4
|
"description": "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"automation",
|
|
@@ -61,7 +61,7 @@
|
|
|
61
61
|
"@napi-rs/keyring": "1.3.0",
|
|
62
62
|
"@oxc-node/core": "0.1.0",
|
|
63
63
|
"@playwright/test": "1.62.0",
|
|
64
|
-
"@qawolf/api-contracts": "0.
|
|
64
|
+
"@qawolf/api-contracts": "0.22.0",
|
|
65
65
|
"@qawolf/emails": "1.1.1",
|
|
66
66
|
"@qawolf/flow-targets": "1.0.0",
|
|
67
67
|
"@qawolf/flows": "0.1.4",
|
|
@@ -9,9 +9,10 @@ compatibility: Requires the qawolf CLI on PATH. Install it from @qawolf/cli or u
|
|
|
9
9
|
|
|
10
10
|
`qawolf` runs QA Wolf flows locally and calls the QA Wolf public API.
|
|
11
11
|
|
|
12
|
-
This file is an overview, not a reference. Before using
|
|
13
|
-
`qawolf <command> --help`
|
|
14
|
-
always matches its version
|
|
12
|
+
This file is an overview, not a reference. Before first using a command whose
|
|
13
|
+
flags are not shown here, run `qawolf <command> --help` once. The installed CLI
|
|
14
|
+
is authoritative for flags and always matches its version; reuse that syntax
|
|
15
|
+
for the rest of the task.
|
|
15
16
|
|
|
16
17
|
## Auth
|
|
17
18
|
|
|
@@ -26,57 +27,85 @@ target another deployment host, for example
|
|
|
26
27
|
`https://app.staging.example.com`. `QAWOLF_API_URL` is a separate API endpoint
|
|
27
28
|
and does not select the deployment host used by CLI commands.
|
|
28
29
|
|
|
29
|
-
|
|
30
|
-
is
|
|
31
|
-
|
|
32
|
-
|
|
30
|
+
Resolve the target environment once per task. Use `QAWOLF_ENVIRONMENT` when it
|
|
31
|
+
is set; otherwise select an id or alias from
|
|
32
|
+
`qawolf --json environment find` and reuse it. Shell invocations may not share
|
|
33
|
+
exported variables, so pass the selected environment explicitly instead of
|
|
34
|
+
rediscovering it. Check the command's help for its environment flag: variable
|
|
35
|
+
commands use `--environment-id`; `qawolf flows run` uses `--env`.
|
|
36
|
+
|
|
37
|
+
If multiple environments are returned and the task context does not identify
|
|
38
|
+
the target, ask instead of guessing. Do not default to the newest environment.
|
|
39
|
+
|
|
40
|
+
`qawolf environment listVariableNames` intentionally returns names only. A
|
|
41
|
+
listed name is enough to reference `process.env.NAME` in flow code; do not ask
|
|
42
|
+
for its value merely because the CLI does not return it.
|
|
33
43
|
|
|
34
44
|
## Output
|
|
35
45
|
|
|
36
46
|
When consuming output programmatically, always pass `--json` (or `--agent`).
|
|
37
47
|
Human-formatted output is not stable across versions. Errors go to stderr;
|
|
38
|
-
a non-zero exit code means the command failed.
|
|
48
|
+
a non-zero exit code means the command failed. Reuse successful read results
|
|
49
|
+
within a task unless a relevant write or target change could make them stale.
|
|
39
50
|
|
|
40
51
|
## Safety: reads vs writes
|
|
41
52
|
|
|
42
|
-
Read commands
|
|
43
|
-
|
|
44
|
-
|
|
53
|
+
Read commands do not change team data, but some have operational effects noted
|
|
54
|
+
in their command entry. Write commands act on the real team. Do not invent
|
|
55
|
+
configuration or write speculative values; write only when requested or when
|
|
56
|
+
the task requires missing configuration whose exact value is known. A
|
|
57
|
+
successful write response is confirmation, so do not read immediately only to
|
|
58
|
+
verify it. Never blind-retry a write on timeout: it may have reached the server
|
|
59
|
+
the first time.
|
|
60
|
+
|
|
61
|
+
## Git-backed workflows
|
|
62
|
+
|
|
63
|
+
Inspect `git status` before publishing. Stage and commit only files changed for
|
|
64
|
+
the current task, preserve unrelated worktree changes, then push the task's
|
|
65
|
+
current branch.
|
|
45
66
|
|
|
46
67
|
## Commands
|
|
47
68
|
|
|
48
69
|
<!-- commands-table:start — generated by `bun run generate`, do not edit -->
|
|
49
70
|
|
|
50
|
-
| Command | Kind | What it does
|
|
51
|
-
| -------------------------------------- | -------------------------- |
|
|
52
|
-
| `qawolf auth login` | local | Authenticate with your QA Wolf API key
|
|
53
|
-
| `qawolf auth logout` | local | Remove stored credentials
|
|
54
|
-
| `qawolf auth whoami` | read | Show authentication status
|
|
55
|
-
| `qawolf automate` | write | Request
|
|
56
|
-
| `qawolf doctor` | local | Diagnose problems running flows locally
|
|
57
|
-
| `qawolf environment create` | write | Create an environment on the caller's team and return it in the environment.get shape.
|
|
58
|
-
| `qawolf environment deleteVariable` | write | Remove one environment variable by name. Succeeds whether or not the variable existed.
|
|
59
|
-
| `qawolf environment find` | read | List the team's environments, newest first.
|
|
60
|
-
| `qawolf environment get` | read | Read a single environment's name, kind, health status, and termination state.
|
|
61
|
-
| `qawolf environment
|
|
62
|
-
| `qawolf environment
|
|
63
|
-
| `qawolf
|
|
64
|
-
| `qawolf
|
|
65
|
-
| `qawolf
|
|
66
|
-
| `qawolf
|
|
67
|
-
| `qawolf
|
|
68
|
-
| `qawolf
|
|
69
|
-
| `qawolf
|
|
70
|
-
| `qawolf
|
|
71
|
-
| `qawolf install
|
|
72
|
-
| `qawolf
|
|
73
|
-
| `qawolf
|
|
74
|
-
| `qawolf
|
|
75
|
-
| `qawolf
|
|
76
|
-
| `qawolf
|
|
77
|
-
| `qawolf
|
|
78
|
-
| `qawolf
|
|
79
|
-
| `qawolf
|
|
71
|
+
| Command | Kind | What it does |
|
|
72
|
+
| -------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
73
|
+
| `qawolf auth login` | local | Authenticate with your QA Wolf API key |
|
|
74
|
+
| `qawolf auth logout` | local | Remove stored credentials |
|
|
75
|
+
| `qawolf auth whoami` | read | Show authentication status |
|
|
76
|
+
| `qawolf automate` | write | Request automation for draft flows. First create a named local .flow.ts draft for every requested journey that does not already have a matching draft; never reuse a generic starter or placeholder. Each new draft must start with a JSDoc Goal: description, import flow from @qawolf/flows/web, and use export default flow(...); a comment-only file or direct test(...) call is not a valid draft. Commit and push all changes with Git to publish them, then list remote drafts to resolve every selected ID. Do not use patch to create or rename a selected flow. Finally make one automation request containing all requested flow IDs. |
|
|
77
|
+
| `qawolf doctor` | local | Diagnose problems running flows locally |
|
|
78
|
+
| `qawolf environment create` | write | Create an environment on the caller's team and return it in the environment.get shape. |
|
|
79
|
+
| `qawolf environment deleteVariable` | write | Remove one environment variable by name. Succeeds whether or not the variable existed. |
|
|
80
|
+
| `qawolf environment find` | read | List the team's environments, newest first. |
|
|
81
|
+
| `qawolf environment get` | read | Read a single environment's name, kind, health status, run concurrency limit, and termination state. |
|
|
82
|
+
| `qawolf environment getVariable` | read | Read the values of named environment variables in one call. Values are secrets. Names that do not exist go to missingNames and do not fail the call. |
|
|
83
|
+
| `qawolf environment listVariableNames` | read | Use this to answer which QA Wolf environment variables are available to test code. Returns names only; values never leave the server. |
|
|
84
|
+
| `qawolf environment setVariable` | write | Create or replace an environment variable. If the user asks to create one for "my email" without naming it, use DEFAULT_ENVIRONMENT_EMAIL. The value is never returned. |
|
|
85
|
+
| `qawolf environment update` | write | Update an environment owned by the caller's team and return it in the environment.get shape. Omitted fields remain unchanged. |
|
|
86
|
+
| `qawolf flow addTag` | write | Assign an existing tag to the selected flows. Create tags with tag.create. |
|
|
87
|
+
| `qawolf flow update` | write | Move a flow between draft and active readiness. The other statuses shown in the app are derived and cannot be set. |
|
|
88
|
+
| `qawolf flows list` | local (read with --remote) | List flows matching [pattern] from the local project, or from a QA Wolf environment with --remote |
|
|
89
|
+
| `qawolf flows pull` | read | Download an environment's flows into the local .qawolf/<env>/ cache |
|
|
90
|
+
| `qawolf flows run` | local (read with --env) | Run flows matching [pattern], or every flow when omitted; with --env, pull missing flows from that QA Wolf environment |
|
|
91
|
+
| `qawolf init` | local | Scaffold a QA Wolf project in the current directory |
|
|
92
|
+
| `qawolf install` | local | Install every runtime dependency the project's flows need |
|
|
93
|
+
| `qawolf install android` | local | Install Android system images, AVDs, and the Appium driver used by the project's Android flows |
|
|
94
|
+
| `qawolf install browsers` | local | Install Playwright browsers used by the project's web flows |
|
|
95
|
+
| `qawolf install clear` | local | Remove the managed runtime cache (all installed runtime versions) |
|
|
96
|
+
| `qawolf issue create` | write | Create a bug or coverage request issue for the caller's team. Maintenance issues cannot be created through the public API. |
|
|
97
|
+
| `qawolf issue find` | read | List the team's bug reports, maintenance reports, or coverage requests, newest first. |
|
|
98
|
+
| `qawolf issue get` | read | Get an issue by id. |
|
|
99
|
+
| `qawolf run create` | write | Create a run for the selected flows and/or tags in an environment. |
|
|
100
|
+
| `qawolf run find` | read | List an environment's recent runs, newest first. |
|
|
101
|
+
| `qawolf run get` | read | Get a run's status, per-flow results, and links. |
|
|
102
|
+
| `qawolf runner evaluateSnippet` | write | Evaluate a snippet against whatever the runner's browser is showing right now. Answers whether the snippet ran, and its error if it threw — not the value it evaluated to, so read anything you want back out of the runner's journal (a snippet's `console.log` lands in the `console` stream). A snippet starts no run and leaves no run-scoped journal entries of its own. `runner-unreachable` if the runner could not be reached or could not evaluate: as well as a runner that is still starting, has terminated after inactivity, or is busy, this covers a runner with no live page to evaluate against — which will never clear, so check that the runner you launched is one that runs a browser before retrying. It is NOT proof the snippet did not run: a snippet that outlives the answer window is still executing when you read this, so do not blindly resubmit one that mutates what the page is looking at. |
|
|
103
|
+
| `qawolf runner launch` | write | Launch an interactive runner on the caller's team under an id the caller chooses. Launching the same id again returns the runner already running rather than starting a second one, and the same id with a different runnerName is refused. A runner is not permanent: it terminates on its own after a period of inactivity, and launching the same id after that starts and bills a new runner — so read `outcome` to tell which happened. |
|
|
104
|
+
| `qawolf runner readJournal` | read | Read a window of one of an interactive runner's journal streams — the newest few, everything after a cursor, or everything belonging to one run. This is how a flow run's outcome and output are followed: `run-status` settles it, `run-logs` and `run-events` carry what it produced, and `recorder` carries the browser actions the runner recorded. A read counts as activity, so working through history does not get the runner reaped underneath you. `runner-unreachable` if the runner could not be reached: it may still be starting, it may have terminated after inactivity, or it may be too busy to answer. Nothing was changed, so retrying is safe; if it persists, launch the runner again. |
|
|
105
|
+
| `qawolf runner runFlow` | write | Run a flow on an interactive runner. Answers as soon as the run is accepted, with the id to follow it by — nothing waits for the run to finish. Which browser or device the run needs is read from the flow file's own execution target, so it is not supplied here; when it does not match what the runner is, the call answers `runner-target-mismatch` rather than failing partway through the run. `runner-unreachable` means the answer did not arrive, which is NOT the same as the run not having started: the runner may have accepted it and been too slow to say so, and resubmitting would start a second run that is billed and journalled alongside the first. Read the runner's `run-status` journal stream before resubmitting, and use the newest run id there if one appeared. |
|
|
106
|
+
| `qawolf runner stop` | write | Stop an interactive runner on the caller's team. Stopping a runner that is not running succeeds and reports `not-running`, so a retry needs no special handling. |
|
|
107
|
+
| `qawolf tag create` | write | Create a tag on the caller's team. Tags select flows in run.create. |
|
|
108
|
+
| `qawolf tag list` | read | List the team's tags, alphabetical by name. Tag names select flows in run.create. |
|
|
80
109
|
|
|
81
110
|
<!-- commands-table:end -->
|
|
82
111
|
|