@alwaysmeticulous/cli 2.329.0 → 2.331.0

package/dist/commands/agent/complete-base-run.command.d.ts

@@ -0,0 +1,27 @@
+import type { CommandModule } from "yargs";
+/**
+ * `STALL_GRACE_MS` (imported as `POLL_TIMEOUT_MS`) is how long
+ * `unexecutedSessionCount` must stay flat (no new sessions scheduled, count
+ * unchanged) before giving up early rather than waiting out the full timeout.
+ * A session pool has no status this command can wait on — see
+ * {@link waitForBaseRunCompletion} — so a stall is detected from the
+ * completeness count itself: sessions genuinely in flight keep moving as
+ * their chunk completes, while sessions `completeBaseRun` currently has
+ * nothing further to schedule for stay flat indefinitely. A chunk replays
+ * many sessions together and only reports once the whole chunk finishes, so a
+ * perfectly healthy chunk can show no progress at all for several minutes —
+ * this has to be sized in minutes, not seconds, or it reads normal replay
+ * time as a dead end. Kept well under `COMPLETION_TIMEOUT_MS` so a
+ * genuinely-stuck run is still reported long before the full timeout.
+ */
+interface Options {
+    apiToken?: string | null | undefined;
+    testRunId: string | undefined;
+    commitSha: string | undefined;
+    dontWaitForTestRunToComplete: boolean;
+    json: boolean;
+    project?: string | undefined;
+}
+export declare const completeBaseRunCommand: CommandModule<unknown, Options>;
+export {};
+//# sourceMappingURL=complete-base-run.command.d.ts.map

package/dist/commands/agent/complete-base-run.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-base-run.command.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/complete-base-run.command.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAkC3C;;;;;;;;;;;;;;GAcG;AAEH,UAAU,OAAO;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACrC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,4BAA4B,EAAE,OAAO,CAAC;IACtC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAmPD,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAkClE,CAAC"}

package/dist/commands/agent/complete-base-run.command.js

@@ -0,0 +1,255 @@
+"use strict";
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6ae8559d-2f56-59d9-bfee-229a83690c42")}catch(e){}}();
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeBaseRunCommand = void 0;
+const client_1 = require("@alwaysmeticulous/client");
+const common_1 = require("@alwaysmeticulous/common");
+const print_json_1 = require("../../command-utils/print-json");
+const sentry_utils_1 = require("../../command-utils/sentry.utils");
+const cli_user_error_1 = require("../../utils/cli-user-error");
+const error_response_body_1 = require("../../utils/error-response-body");
+const resolve_test_run_from_commit_1 = require("../../utils/resolve-test-run-from-commit");
+/**
+ * How long to wait for a completed base run to finish. Longer than the usual
+ * poll deadline: this waits out a full test run's replays (every selected
+ * session), not a run that was already most of the way through.
+ */
+const COMPLETION_TIMEOUT_MS = 45 * 60 * 1000;
+/** How often to re-check completion while waiting. */
+const POLL_INTERVAL_MS = 10_000;
+/**
+ * How often to re-invoke `complete-base-run` itself (the write that actually
+ * schedules/retries sessions) while waiting, rather than on every
+ * {@link POLL_INTERVAL_MS} tick. Most ticks only need a cheap read: a live
+ * chunk resolves on its own, and the read-only `getTestRun` poll already
+ * shows that. Re-running the write path is only useful for picking up a
+ * session that has newly become eligible again (e.g. a chunk that just
+ * reconciled to `ExecutionError` — see `computeCoveredSessionIds`), which
+ * happens on the timescale of a workflow concluding, not seconds — so a much
+ * coarser cadence still retries promptly without hitting the append-only
+ * transaction and its lock on every tick.
+ */
+const RESCHEDULE_INTERVAL_MS = 60_000;
+const handler = async ({ apiToken, testRunId, commitSha, dontWaitForTestRunToComplete, json, project, }) => {
+    if (testRunId != null && commitSha != null) {
+        throw new cli_user_error_1.CliUserError("Pass either --testRunId or --commitSha, not both: they name the run to complete two different ways.");
+    }
+    const client = await (0, client_1.createClientWithOAuth)({
+        apiToken,
+        enableOAuthLogin: true,
+    });
+    // `resolveTestRunForCommitOrThrow` defaults to the local HEAD and logs the
+    // resolved commit (warning if the tree is dirty), as the other commit-resolving
+    // agent commands do.
+    const resolvedTestRunId = testRunId ??
+        (await (0, resolve_test_run_from_commit_1.resolveTestRunForCommitOrThrow)(client, commitSha, project))
+            .testRunId;
+    const result = await requestCompletion(client, resolvedTestRunId);
+    // Summary on stderr regardless of --json (which only changes stdout).
+    // `sessionsScheduled === 0` alone doesn't mean "nothing to do" — it's also
+    // what a call sees while earlier-scheduled work is still in flight, so that
+    // case gets its own message rather than falsely claiming completion.
+    if (result.sessionsScheduled > 0) {
+        (0, common_1.logNotice)(`Scheduled ${result.sessionsScheduled} of test run ${resolvedTestRunId}'s ${result.configuredSessionCount} selected sessions for replay.`);
+    }
+    else if (result.unexecutedSessionCount === 0) {
+        (0, common_1.logNotice)(`Test run ${resolvedTestRunId} has already replayed all ${result.configuredSessionCount} of its selected sessions; nothing to do.`);
+    }
+    else {
+        (0, common_1.logNotice)(`Test run ${resolvedTestRunId} has nothing further to schedule right now, but ${result.unexecutedSessionCount} of its ${result.configuredSessionCount} selected sessions still lack a result — likely still in flight from an earlier call.`);
+    }
+    // Wait by default, so the run this returns is one whose coverage can be
+    // asked for straight away — the point of completing it. Nothing to wait for
+    // once coverage is already servable.
+    let { status, unexecutedSessionCount } = result;
+    if (!dontWaitForTestRunToComplete && !isCoverageServable(result)) {
+        ({ status, unexecutedSessionCount } = await waitForBaseRunCompletion(client, resolvedTestRunId, result));
+    }
+    if (json) {
+        (0, print_json_1.printJson)({ ...result, status, unexecutedSessionCount });
+    }
+    else {
+        printKeyValueLines({ ...result, status, unexecutedSessionCount });
+    }
+};
+/**
+ * Whether `js-coverage` will actually succeed for this run right now.
+ * `unexecutedSessionCount === 0` alone isn't enough: session results land
+ * per-chunk as soon as replays finish, but the coverage artifact `js-coverage`
+ * serves is only rewritten by a later, separate post-process step — which is
+ * also what settles a session pool's `status` into a genuinely completed one
+ * once *its* snapshot of the configured set is fully covered (mirrors the
+ * backend's own gate in `AgentApiService.assertBaseRunCoverageComplete`). So
+ * both conditions must hold: nothing left unexecuted, and `status` has
+ * settled rather than merely left `Partial` — appending chunks takes a pool
+ * through `Running`/`PostProcessing` first (`IN_PROGRESS_TEST_RUN_STATUS`),
+ * and the artifact isn't guaranteed to include the new results until
+ * post-process next runs.
+ */
+const isCoverageServable = ({ status, unexecutedSessionCount, }) => unexecutedSessionCount === 0 &&
+    status !== "Partial" &&
+    !client_1.IN_PROGRESS_TEST_RUN_STATUS.includes(status);
+/**
+ * The same session-completeness diff the backend's
+ * `TestRunChunkService.findBaseRunSessionCompleteness` computes, done
+ * client-side from a plain `getTestRun` read: `configData.testCases` is the
+ * configured set, `resultData.results` is folded live as chunks complete (see
+ * `TestRunService.getResults`), so diffing the two session-ID sets is exactly
+ * `unexecutedSessionCount` without needing the write endpoint at all.
+ */
+const countUnexecutedSessions = (testRun) => {
+    const resultSessionIds = new Set((testRun.resultData?.results ?? []).map((result) => result.sessionId));
+    const configuredSessionIds = new Set((testRun.configData.testCases ?? []).map((testCase) => testCase.sessionId));
+    let unexecutedSessionCount = 0;
+    for (const sessionId of configuredSessionIds) {
+        if (!resultSessionIds.has(sessionId)) {
+            unexecutedSessionCount++;
+        }
+    }
+    return unexecutedSessionCount;
+};
+/**
+ * Waits until `complete-base-run`'s coverage is servable (see
+ * {@link isCoverageServable}), polling the plain, read-only `getTestRun`
+ * every {@link POLL_INTERVAL_MS} rather than re-invoking `complete-base-run`
+ * itself (idempotent, but a write — see its own docstring) on every tick:
+ * `getTestRun` already carries everything needed (see
+ * {@link countUnexecutedSessions}), so most ticks need no write-path traffic
+ * at all. `complete-base-run` is still re-invoked, at the coarser
+ * {@link RESCHEDULE_INTERVAL_MS}, to actually pick up anything newly eligible
+ * to (re-)schedule (see `BaseRunCompletionService.completeBaseRun`) —
+ * `getTestRun` only observes progress, it can't cause it.
+ *
+ * A session pool's `status` by itself is not a wait-worthy signal: it can
+ * rest in `Partial` indefinitely between requests (not "still running"), and
+ * can equally sit in a stale `Success`/`Failure` from before this call's work
+ * even starts (scheduling doesn't itself move the status). Unexecuted
+ * sessions reaching `0` is the signal that scheduling is done; `status`
+ * leaving `Partial` is the signal that the coverage artifact has caught up
+ * with that.
+ *
+ * Gives up early — rather than waiting out the full timeout — once the
+ * unexecuted count has stayed flat for {@link STALL_GRACE_MS}. Sessions
+ * actually in flight (scheduled by this call or an earlier one) keep moving
+ * as their chunks complete, and a session whose chunk failed with
+ * `ExecutionError` (e.g. its pod never actually ran) gets rescheduled the
+ * next time this reaches {@link RESCHEDULE_INTERVAL_MS} — so a *sustained*
+ * flat count usually means the remainder is just taking longer than usual,
+ * not that it's permanently stuck. This can't be told apart from a genuinely
+ * wedged state with certainty, hence the hedged error message rather than a
+ * confident diagnosis.
+ */
+const waitForBaseRunCompletion = async (client, testRunId, initial) => {
+    (0, common_1.logProgress)(`Waiting for test run ${testRunId} to finish replaying...`);
+    let unexecutedSessionCount = initial.unexecutedSessionCount;
+    let status = initial.status;
+    let stalledSinceMs = null;
+    let lastRescheduledAtMs = performance.now();
+    const deadline = performance.now() + COMPLETION_TIMEOUT_MS;
+    while (!isCoverageServable({ status, unexecutedSessionCount })) {
+        if (performance.now() >= deadline) {
+            throw new cli_user_error_1.CliUserError(unexecutedSessionCount > 0
+                ? `Test run ${testRunId} still has ${unexecutedSessionCount} session(s) without a result after ${Math.round(COMPLETION_TIMEOUT_MS / 60_000)} minutes. It may still be running — check back later, or re-run with --dontWaitForTestRunToComplete to return immediately.`
+                : `Test run ${testRunId} has replayed all its selected sessions, but its coverage still hasn't finished being recomputed for the full set after ${Math.round(COMPLETION_TIMEOUT_MS / 60_000)} minutes (status: ${status}). Check back later, or re-run with --dontWaitForTestRunToComplete to return immediately.`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        const testRun = await (0, client_1.getTestRun)({ client, testRunId });
+        const newUnexecutedSessionCount = countUnexecutedSessions(testRun);
+        const noProgress = newUnexecutedSessionCount === unexecutedSessionCount;
+        unexecutedSessionCount = newUnexecutedSessionCount;
+        status = testRun.status;
+        if (isCoverageServable({ status, unexecutedSessionCount })) {
+            break;
+        }
+        const now = performance.now();
+        if (!noProgress) {
+            stalledSinceMs = null;
+        }
+        else if (stalledSinceMs == null) {
+            stalledSinceMs = now;
+        }
+        else if (now - stalledSinceMs >= resolve_test_run_from_commit_1.POLL_TIMEOUT_MS) {
+            throw new cli_user_error_1.CliUserError(unexecutedSessionCount > 0
+                ? `Test run ${testRunId} still has ${unexecutedSessionCount} session(s) without a result, and complete-base-run has had nothing further to schedule for them for over ${Math.round(resolve_test_run_from_commit_1.POLL_TIMEOUT_MS / 60_000)} minutes — this may just need more time. Check back later, re-run with --dontWaitForTestRunToComplete to return immediately, or ask for the project's overall coverage instead (js-coverage --latestForProject).`
+                : `Test run ${testRunId} has replayed all its selected sessions, but its coverage still hasn't finished being recomputed for the full set (status: ${status}) after over ${Math.round(resolve_test_run_from_commit_1.POLL_TIMEOUT_MS / 60_000)} minutes. This may just need more time — check back later, re-run with --dontWaitForTestRunToComplete to return immediately, or ask for the project's overall coverage instead (js-coverage --latestForProject).`);
+        }
+        if (now - lastRescheduledAtMs >= RESCHEDULE_INTERVAL_MS) {
+            lastRescheduledAtMs = now;
+            const rescheduled = await requestCompletion(client, testRunId);
+            unexecutedSessionCount = rescheduled.unexecutedSessionCount;
+            status = rescheduled.status;
+            // Picking up newly-eligible work here is real progress even though
+            // `unexecutedSessionCount` itself won't move until it lands a result —
+            // without this, the stall clock (armed on an earlier, unrelated tick)
+            // can still time out right after a reschedule found something to do.
+            if (rescheduled.sessionsScheduled > 0) {
+                stalledSinceMs = null;
+            }
+        }
+    }
+    return { status, unexecutedSessionCount };
+};
+/**
+ * The backend's response-body `reason`s marking a request it declines as a
+ * caller mistake rather than a fault — matched instead of the prose (the same
+ * convention `js-coverage` follows) so a genuine failure still reaches the
+ * generic error path and Sentry. Kept in step with
+ * `packages/webapp-backend/src/agent/complete-base-run.errors.ts`.
+ */
+const COMPLETION_REJECTION_REASONS = new Set([
+    "not-a-base-run",
+    "dead-end-status",
+    "ephemeral-deployment",
+]);
+const requestCompletion = async (client, testRunId) => {
+    try {
+        return await (0, client_1.completeBaseRun)(client, testRunId);
+    }
+    catch (error) {
+        const body = (0, error_response_body_1.errorResponseBody)(error);
+        if (body?.reason != null &&
+            COMPLETION_REJECTION_REASONS.has(body.reason) &&
+            body.message != null) {
+            throw new cli_user_error_1.CliUserError(body.message);
+        }
+        throw error;
+    }
+};
+const printKeyValueLines = (result) => {
+    for (const [key, value] of Object.entries(result)) {
+        console.log(`${key}:\t${value}`);
+    }
+};
+exports.completeBaseRunCommand = {
+    command: "complete-base-run",
+    describe: "Replay the selected sessions a base run has not run yet, so its coverage describes its commit. A base run (the usual outcome for a commit on your default branch) replays sessions on demand for whichever PRs compare against it, so it can sit at any fraction of the project's selected set, and agent js-coverage refuses it while any are missing or while its coverage hasn't finished being recomputed for the full set. This schedules the rest, then waits for its coverage to actually be servable (pass --dontWaitForTestRunToComplete to return as soon as the work is scheduled); a session pool's own status cannot be waited on directly, since it can rest indefinitely between requests. Outputs testRunId, status, unexecutedSessionCount, sessionsScheduled and configuredSessionCount, one per line; sessionsScheduled is 0 when the run had already replayed everything, or when everything left is already covered by a chunk from an earlier call (running this twice is a no-op, not an error), and unexecutedSessionCount is 0 once every selected session has a result — js-coverage additionally needs status to have settled into a completed status (not just left Partial: appending chunks passes through Running/PostProcessing first). Costs a full test run's replays, so ask for it when you want this commit's own coverage — for a rough project-level picture 'agent js-coverage --latestForProject' is free. Fails for a run that is not a base run, is itself a dead end at the whole-run level (status ExecutionError/Aborted — not a single chunk, which is retried automatically), or whose deployment was an ephemeral tunnel that is no longer reachable; if nothing has changed for a while, this command reports that rather than waiting out the full timeout.",
+    builder: {
+        apiToken: { string: true, description: "Meticulous API token." },
+        testRunId: {
+            string: true,
+            description: "The base run to complete. Cannot be combined with --commitSha.",
+        },
+        commitSha: {
+            string: true,
+            description: "A commit SHA, used as an alternative to --testRunId: completes the latest test run for the commit. Defaults to the current git HEAD when neither is given.",
+        },
+        project: {
+            string: true,
+            description: "The project to look up the commit in (id, 'org/proj', or simply 'proj'). One-off override, when omitted uses the user-configured default project.",
+        },
+        dontWaitForTestRunToComplete: {
+            boolean: true,
+            default: false,
+            description: "Return as soon as the replays are scheduled instead of the default of blocking until the run finishes; its coverage is only complete once it has.",
+        },
+        json: {
+            boolean: true,
+            default: false,
+            description: "Output the result as JSON instead of one field per line.",
+        },
+    },
+    handler: (0, sentry_utils_1.wrapHandler)(handler),
+};
+//# sourceMappingURL=complete-base-run.command.js.map
+//# debugId=6ae8559d-2f56-59d9-bfee-229a83690c42

package/dist/commands/agent/complete-base-run.command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-base-run.command.js","sources":["../../../src/commands/agent/complete-base-run.command.ts"],"sourceRoot":"","names":[],"mappings":";;;;;AACA,qDAQkC;AAClC,qDAAkE;AAElE,+DAA2D;AAC3D,mEAA+D;AAC/D,+DAA0D;AAC1D,yEAAoE;AACpE,2FAGkD;AAElD;;;;GAIG;AACH,MAAM,qBAAqB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE7C,sDAAsD;AACtD,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEhC;;;;;;;;;;;GAWG;AACH,MAAM,sBAAsB,GAAG,MAAM,CAAC;AA2BtC,MAAM,OAAO,GAAG,KAAK,EAAE,EACrB,QAAQ,EACR,SAAS,EACT,SAAS,EACT,4BAA4B,EAC5B,IAAI,EACJ,OAAO,GACC,EAAiB,EAAE;IAC3B,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;QAC3C,MAAM,IAAI,6BAAY,CACpB,qGAAqG,CACtG,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,IAAA,8BAAqB,EAAC;QACzC,QAAQ;QACR,gBAAgB,EAAE,IAAI;KACvB,CAAC,CAAC;IAEH,2EAA2E;IAC3E,gFAAgF;IAChF,qBAAqB;IACrB,MAAM,iBAAiB,GACrB,SAAS;QACT,CAAC,MAAM,IAAA,6DAA8B,EAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;aAC/D,SAAS,CAAC;IACf,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAElE,sEAAsE;IACtE,2EAA2E;IAC3E,4EAA4E;IAC5E,qEAAqE;IACrE,IAAI,MAAM,CAAC,iBAAiB,GAAG,CAAC,EAAE,CAAC;QACjC,IAAA,kBAAS,EACP,aAAa,MAAM,CAAC,iBAAiB,gBAAgB,iBAAiB,MAAM,MAAM,CAAC,sBAAsB,gCAAgC,CAC1I,CAAC;IACJ,CAAC;SAAM,IAAI,MAAM,CAAC,sBAAsB,KAAK,CAAC,EAAE,CAAC;QAC/C,IAAA,kBAAS,EACP,YAAY,iBAAiB,6BAA6B,MAAM,CAAC,sBAAsB,2CAA2C,CACnI,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,IAAA,kBAAS,EACP,YAAY,iBAAiB,mDAAmD,MAAM,CAAC,sBAAsB,WAAW,MAAM,CAAC,sBAAsB,uFAAuF,CAC7O,CAAC;IACJ,CAAC;IAED,wEAAwE;IACxE,4EAA4E;IAC5E,qCAAqC;IACrC,IAAI,EAAE,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,CAAC;IAChD,IAAI,CAAC,4BAA4B,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;QACjE,CAAC,EAAE,MAAM,EAAE,sBAAsB,EAAE,GAAG,MAAM,wBAAwB,CAClE,MAAM,EACN,iBAAiB,EACjB,MAAM,CACP,CAAC,CAAC;IACL,CAAC;IAED,IAAI,IAAI,EAAE,CAAC;QACT,IAAA,sBAAS,EAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;IAC3D,CAAC;SAAM,CAAC;QACN,kBAAkB,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;IACpE,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,kBAAkB,GAAG,CAAC,EAC1B,MAAM,EACN,sBAAsB,GAIvB,EAAW,EAAE,CACZ,sBAAsB,KAAK,CAAC;IAC5B,MAAM,KAAK,SAAS;IACpB,CAAC,oCAA2B,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,uBAAuB,GAAG,CAAC,OAAgB,EAAU,EAAE;IAC3D,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAC9B,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CACtE,CAAC;IACF,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAClC,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAC3E,CAAC;IACF,IAAI,sBAAsB,GAAG,CAAC,CAAC;IAC/B,KAAK,MAAM,SAAS,IAAI,oBAAoB,EAAE,CAAC;QAC7C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACrC,sBAAsB,EAAE,CAAC;QAC3B,CAAC;IACH,CAAC;IACD,OAAO,sBAAsB,CAAC;AAChC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,wBAAwB,GAAG,KAAK,EACpC,MAAwB,EACxB,SAAiB,EACjB,OAAgC,EAGhC,EAAE;IACF,IAAA,oBAAW,EAAC,wBAAwB,SAAS,yBAAyB,CAAC,CAAC;IACxE,IAAI,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAC5D,IAAI,MAAM,GAAkB,OAAO,CAAC,MAAM,CAAC;IAC3C,IAAI,cAAc,GAAkB,IAAI,CAAC;IACzC,IAAI,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAC5C,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,qBAAqB,CAAC;IAC3D,OAAO,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,EAAE,CAAC;QAC/D,IAAI,WAAW,CAAC,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC;YAClC,MAAM,IAAI,6BAAY,CACpB,sBAAsB,GAAG,CAAC;gBACxB,CAAC,CAAC,YAAY,SAAS,cAAc,sBAAsB,sCAAsC,IAAI,CAAC,KAAK,CAAC,qBAAqB,GAAG,MAAM,CAAC,4HAA4H;gBACvQ,CAAC,CAAC,YAAY,SAAS,2HAA2H,IAAI,CAAC,KAAK,CAAC,qBAAqB,GAAG,MAAM,CAAC,qBAAqB,MAAM,2FAA2F,CACrT,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC;QACtE,MAAM,OAAO,GAAG,MAAM,IAAA,mBAAU,EAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QACxD,MAAM,yBAAyB,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,yBAAyB,KAAK,sBAAsB,CAAC;QACxE,sBAAsB,GAAG,yBAAyB,CAAC;QACnD,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QACxB,IAAI,kBAAkB,CAAC,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,EAAE,CAAC;YAC3D,MAAM;QACR,CAAC;QACD,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,cAAc,GAAG,IAAI,CAAC;QACxB,CAAC;aAAM,IAAI,cAAc,IAAI,IAAI,EAAE,CAAC;YAClC,cAAc,GAAG,GAAG,CAAC;QACvB,CAAC;aAAM,IAAI,GAAG,GAAG,cAAc,IAAI,8CAAc,EAAE,CAAC;YAClD,MAAM,IAAI,6BAAY,CACpB,sBAAsB,GAAG,CAAC;gBACxB,CAAC,CAAC,YAAY,SAAS,cAAc,sBAAsB,6GAA6G,IAAI,CAAC,KAAK,CAAC,8CAAc,GAAG,MAAM,CAAC,kNAAkN;gBAC7Z,CAAC,CAAC,YAAY,SAAS,8HAA8H,MAAM,gBAAgB,IAAI,CAAC,KAAK,CAAC,8CAAc,GAAG,MAAM,CAAC,kNAAkN,CACna,CAAC;QACJ,CAAC;QACD,IAAI,GAAG,GAAG,mBAAmB,IAAI,sBAAsB,EAAE,CAAC;YACxD,mBAAmB,GAAG,GAAG,CAAC;YAC1B,MAAM,WAAW,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC/D,sBAAsB,GAAG,WAAW,CAAC,sBAAsB,CAAC;YAC5D,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;YAC5B,mEAAmE;YACnE,uEAAuE;YACvE,sEAAsE;YACtE,qEAAqE;YACrE,IAAI,WAAW,CAAC,iBAAiB,GAAG,CAAC,EAAE,CAAC;gBACtC,cAAc,GAAG,IAAI,CAAC;YACxB,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC;AAC5C,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,4BAA4B,GAAG,IAAI,GAAG,CAAC;IAC3C,gBAAgB;IAChB,iBAAiB;IACjB,sBAAsB;CACvB,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAG,KAAK,EAC7B,MAAwB,EACxB,SAAiB,EACiB,EAAE;IACpC,IAAI,CAAC;QACH,OAAO,MAAM,IAAA,wBAAe,EAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,GAAG,IAAA,uCAAiB,EAAC,KAAK,CAAC,CAAC;QACtC,IACE,IAAI,EAAE,MAAM,IAAI,IAAI;YACpB,4BAA4B,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;YAC7C,IAAI,CAAC,OAAO,IAAI,IAAI,EACpB,CAAC;YACD,MAAM,IAAI,6BAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvC,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,MAA+B,EAAQ,EAAE;IACnE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,MAAM,KAAK,EAAE,CAAC,CAAC;IACnC,CAAC;AACH,CAAC,CAAC;AAEW,QAAA,sBAAsB,GAAoC;IACrE,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,gtDAAgtD;IACltD,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,uBAAuB,EAAE;QAChE,SAAS,EAAE;YACT,MAAM,EAAE,IAAI;YACZ,WAAW,EACT,gEAAgE;SACnE;QACD,SAAS,EAAE;YACT,MAAM,EAAE,IAAI;YACZ,WAAW,EACT,4JAA4J;SAC/J;QACD,OAAO,EAAE;YACP,MAAM,EAAE,IAAI;YACZ,WAAW,EACT,mJAAmJ;SACtJ;QACD,4BAA4B,EAAE;YAC5B,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,KAAK;YACd,WAAW,EACT,mJAAmJ;SACtJ;QACD,IAAI,EAAE;YACJ,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,0DAA0D;SACxE;KACF;IACD,OAAO,EAAE,IAAA,0BAAW,EAAC,OAAO,CAAC;CAC9B,CAAC","debugId":"6ae8559d-2f56-59d9-bfee-229a83690c42"}

package/dist/commands/agent/complete-base-run.command.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=complete-base-run.command.spec.d.ts.map

package/dist/commands/agent/complete-base-run.command.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-base-run.command.spec.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/complete-base-run.command.spec.ts"],"names":[],"mappings":""}