monday-cli 0.2.0

package/dist/api/response-root.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Response-root field assertion (R41 lift, v0.2-plan §22).
+ *
+ * Distinguishes "key absent" (response-shape drift →
+ * `internal_error`, whole-call) from "value null" (resource missing
+ * / can't be applied → `not_found`, per-record). Codex M14 round-2
+ * F1 + round-3 F1 pinned the contract; R41 lifts the inline helpers
+ * that workspace add-users / workspace remove-users / board add-
+ * users each ship verbatim.
+ *
+ * **Why distinct from `assertUpdateMutationPresent`**
+ * (`api/update-mutation-result.ts`). M13's helper handles null /
+ * undefined uniformly with `not_found` — pre-dating the M14
+ * missing-root-key vs null-value distinction. R42 (retroactive
+ * sweep across pre-M14 mutation verbs) handles unifying them; R41
+ * stays scoped to the M14 + M15 partial-success-fan-out family.
+ *
+ * **Used by:** `commands/workspace/add-users.ts` /
+ * `commands/workspace/remove-users.ts` / `commands/board/add-users.ts`.
+ *
+ * **Not used by:** single-target mutation verbs (board create /
+ * update / archive / delete / duplicate, workspace create / update /
+ * delete) — those carry their own per-verb missing-root-key checks
+ * because the contract is "every successful call returns the
+ * resource" rather than "value null is a per-record path"; the
+ * single-target verbs never throw `not_found` from the inline check
+ * (the per-verb projector does that on the unwrapped value).
+ */
+export interface AssertResponseFieldPresentInputs {
+    /** The parsed response data object (after the wire-shape parse). */
+    readonly data: Readonly<Record<string, unknown>>;
+    /** The mutation root key name (e.g. `'add_users_to_board'`). */
+    readonly key: string;
+    /** The operation label for `internal_error` messages
+     * (e.g. `'BoardAddUsers'`). Distinct from `key` because the
+     * GraphQL operation name is human-readable PascalCase whereas
+     * `key` is the snake_case mutation field. */
+    readonly operationLabel: string;
+    /** The scope-id detail key (`'workspace_id'` or `'board_id'`). */
+    readonly scopeKey: string;
+    /** The scope-id value (the workspace or board ID). */
+    readonly scopeId: string;
+    /** The target-id detail key (always `'user_id'` in M14/M15
+     * partial-success-fan-out verbs; future verbs may use other
+     * targets — keep this parameterised for forward-compat). */
+    readonly targetKey: string;
+    /** The target-id value (the user ID for the current dispatch
+     * iteration). */
+    readonly targetId: string;
+}
+/**
+ * Throws `ApiError('internal_error')` when `key` is absent from
+ * `data`; throws `ApiError('not_found')` when present but null.
+ * Returns void on success. The caller's downstream code can rely
+ * on `data[key]` being a non-null value after this call.
+ *
+ * Distinct error codes per the M14 round-2 F1 / round-3 F1
+ * contract — `dispatchSequential` re-throws `internal_error`
+ * (whole-call schema drift) but lets `not_found` land in the
+ * per-record slot. Without this distinction, a per-record
+ * not_found could be produced from a schema-drift response,
+ * masking the contract violation.
+ */
+export declare const assertResponseFieldPresent: (inputs: AssertResponseFieldPresentInputs) => void;
+//# sourceMappingURL=response-root.d.ts.map

package/dist/api/response-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-root.d.ts","sourceRoot":"","sources":["../../src/api/response-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,MAAM,WAAW,gCAAgC;IAC/C,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;iDAG6C;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;gEAE4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;qBACiB;IACjB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,GACrC,QAAQ,gCAAgC,KACvC,IA2BF,CAAC"}

package/dist/api/response-root.js

@@ -0,0 +1,61 @@
+/**
+ * Response-root field assertion (R41 lift, v0.2-plan §22).
+ *
+ * Distinguishes "key absent" (response-shape drift →
+ * `internal_error`, whole-call) from "value null" (resource missing
+ * / can't be applied → `not_found`, per-record). Codex M14 round-2
+ * F1 + round-3 F1 pinned the contract; R41 lifts the inline helpers
+ * that workspace add-users / workspace remove-users / board add-
+ * users each ship verbatim.
+ *
+ * **Why distinct from `assertUpdateMutationPresent`**
+ * (`api/update-mutation-result.ts`). M13's helper handles null /
+ * undefined uniformly with `not_found` — pre-dating the M14
+ * missing-root-key vs null-value distinction. R42 (retroactive
+ * sweep across pre-M14 mutation verbs) handles unifying them; R41
+ * stays scoped to the M14 + M15 partial-success-fan-out family.
+ *
+ * **Used by:** `commands/workspace/add-users.ts` /
+ * `commands/workspace/remove-users.ts` / `commands/board/add-users.ts`.
+ *
+ * **Not used by:** single-target mutation verbs (board create /
+ * update / archive / delete / duplicate, workspace create / update /
+ * delete) — those carry their own per-verb missing-root-key checks
+ * because the contract is "every successful call returns the
+ * resource" rather than "value null is a per-record path"; the
+ * single-target verbs never throw `not_found` from the inline check
+ * (the per-verb projector does that on the unwrapped value).
+ */
+import { ApiError } from '../utils/errors.js';
+/**
+ * Throws `ApiError('internal_error')` when `key` is absent from
+ * `data`; throws `ApiError('not_found')` when present but null.
+ * Returns void on success. The caller's downstream code can rely
+ * on `data[key]` being a non-null value after this call.
+ *
+ * Distinct error codes per the M14 round-2 F1 / round-3 F1
+ * contract — `dispatchSequential` re-throws `internal_error`
+ * (whole-call schema drift) but lets `not_found` land in the
+ * per-record slot. Without this distinction, a per-record
+ * not_found could be produced from a schema-drift response,
+ * masking the contract violation.
+ */
+export const assertResponseFieldPresent = (inputs) => {
+    const { data, key, operationLabel, scopeKey, scopeId, targetKey, targetId } = inputs;
+    if (!(key in data)) {
+        throw new ApiError('internal_error', `Monday's ${operationLabel} response is missing the ${key} root field`, {
+            details: {
+                [scopeKey]: scopeId,
+                [targetKey]: targetId,
+                hint: 'this is a schema-drift error in Monday\'s GraphQL response; ' +
+                    'verify the mutation declaration and update the response ' +
+                    'schema if Monday\'s contract has changed.',
+            },
+        });
+    }
+    const raw = data[key];
+    if (raw === null || raw === undefined) {
+        throw new ApiError('not_found', `Monday returned no payload from ${key} for ${targetKey.replace(/_id$/u, '')} ${targetId}`, { details: { [targetKey]: targetId } });
+    }
+};
+//# sourceMappingURL=response-root.js.map

package/dist/api/response-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-root.js","sourceRoot":"","sources":["../../src/api/response-root.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAyB9C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACxC,MAAwC,EAClC,EAAE;IACR,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,GACzE,MAAM,CAAC;IACT,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,QAAQ,CAChB,gBAAgB,EAChB,YAAY,cAAc,4BAA4B,GAAG,aAAa,EACtE;YACE,OAAO,EAAE;gBACP,CAAC,QAAQ,CAAC,EAAE,OAAO;gBACnB,CAAC,SAAS,CAAC,EAAE,QAAQ;gBACrB,IAAI,EACF,8DAA8D;oBAC9D,0DAA0D;oBAC1D,2CAA2C;aAC9C;SACF,CACF,CAAC;IACJ,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;IACtB,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtC,MAAM,IAAI,QAAQ,CAChB,WAAW,EACX,mCAAmC,GAAG,QAAQ,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,QAAQ,EAAE,EAC1F,EAAE,OAAO,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,EAAE,CACvC,CAAC;IACJ,CAAC;AACH,CAAC,CAAC"}

package/dist/api/retry.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Retry layer for the Monday API client (`v0.1-plan.md` §3 M2,
+ * `cli-design.md` §2.5 retry behaviour).
+ *
+ * `withRetry(thunk, options)` invokes `thunk` until it returns
+ * successfully, the abort signal fires, or the retry budget is
+ * exhausted. Failures are inspected via the typed `MondayCliError`
+ * shape:
+ *
+ *  - `error.retryable === false` → re-throw immediately.
+ *  - `error.retryAfterSeconds` set → sleep that long (clamped to
+ *    `maxBackoffMs`) before the next attempt.
+ *  - Otherwise → exponential backoff with jitter, doubling per
+ *    attempt up to `maxBackoffMs`.
+ *
+ * The retry count is exposed on `RetryStats` so the caller can
+ * surface attempt totals in `--verbose` output and so a regression
+ * test can assert "exactly N attempts for a `retryable: true`
+ * failure". The latter catches any future SDK update that
+ * re-introduces an internal retry layer (`v0.1-plan.md` risk
+ * register: "SDK retry double-counting"). Today's SDK
+ * (`graphql-request@6.1.0`) has no built-in retry — we still bake
+ * the assertion in so it stays true.
+ *
+ * The thunk receives the current `attempt` (0-indexed) so the API
+ * client can include it in debug logs / fixture matchers (e.g. a
+ * cassette can assert the second attempt sees the same headers).
+ */
+import { MondayCliError } from '../utils/errors.js';
+export interface RetryOptions {
+    /**
+     * Maximum number of *retries* — i.e. additional attempts after the
+     * first call. A value of `3` means up to 4 total transport calls.
+     * Comes from `--retry` (default 3).
+     */
+    readonly retries: number;
+    /**
+     * Caps the backoff we'll wait between attempts. Honoured even when
+     * `retry_after_seconds` requests longer; the design avoids a
+     * runaway 60s sleep on a single retry by clamping to the cap and
+     * returning the next failure faster.
+     */
+    readonly maxBackoffMs?: number;
+    /** Initial backoff — doubled per attempt, jittered. Default 200ms. */
+    readonly baseBackoffMs?: number;
+    /**
+     * Source of randomness for the jitter. Tests pass a deterministic
+     * value (`() => 0.5`) so the sleep schedule is reproducible.
+     */
+    readonly random?: () => number;
+    /**
+     * Sleep implementation. Tests pass a fast / instant impl
+     * (`(ms) => Promise.resolve()`) so the retry cycle doesn't spend
+     * real wall-clock seconds.
+     */
+    readonly sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    /**
+     * Cancellation source. When the signal fires mid-backoff, the
+     * outstanding sleep rejects and the retry loop bails — `withRetry`
+     * surfaces the underlying `MondayCliError` (or a synthetic abort
+     * one) without making another attempt.
+     */
+    readonly signal: AbortSignal;
+}
+export interface RetryStats {
+    /**
+     * Total number of times the thunk was invoked. `1` means the first
+     * call succeeded; `>= 2` means at least one retry was applied.
+     */
+    readonly attempts: number;
+    /**
+     * Cumulative milliseconds spent sleeping between attempts. Useful
+     * for the `--verbose` complexity hint and for diagnosing slow
+     * retries in production.
+     */
+    readonly totalBackoffMs: number;
+}
+export interface RetryResult<T> {
+    readonly value: T;
+    readonly stats: RetryStats;
+}
+/**
+ * Computes the delay before the next attempt. Honours
+ * `retry_after_seconds` when present (clamped to `maxBackoffMs`),
+ * otherwise grows exponentially: `baseBackoffMs * 2 ** attempt` with
+ * ±50% jitter.
+ *
+ * Exported so the unit suite can snapshot the curve and so a future
+ * caller-side decorator (e.g. a CI runner that wants to log "next
+ * attempt in N ms") can reuse the same algorithm.
+ */
+export declare const computeBackoffMs: (attempt: number, err: MondayCliError, opts: {
+    readonly baseBackoffMs: number;
+    readonly maxBackoffMs: number;
+    readonly random: () => number;
+}) => number;
+/**
+ * Calls `thunk` until it succeeds or the budget is exhausted.
+ *
+ * Throwing semantics:
+ *  - On final success: returns `{ value, stats }`.
+ *  - On a non-retryable error: rethrows the original error.
+ *  - On a retryable error after budget exhaustion: rethrows the
+ *    *last* error with `details.attempts` set to the total count, so
+ *    agents can see how many times the CLI tried.
+ *  - On abort (signal fired): rethrows an `ApiError(internal_error)`
+ *    tagged `aborted: true` (the runner inspects `signal.reason` and
+ *    decides 130 vs 2). Throwing here keeps the flow uniform — the
+ *    caller doesn't have to special-case mid-sleep cancellation.
+ */
+export declare const withRetry: <T>(thunk: (attempt: number) => Promise<T>, options: RetryOptions) => Promise<RetryResult<T>>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/api/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/api/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAY,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AAkCD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,KAAK,cAAc,EACnB,MAAM;IACJ,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;CAC/B,KACA,MASF,CAAC;AAyBF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GAAU,CAAC,EAC/B,OAAO,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACtC,SAAS,YAAY,KACpB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAsExB,CAAC"}

package/dist/api/retry.js

@@ -0,0 +1,181 @@
+/**
+ * Retry layer for the Monday API client (`v0.1-plan.md` §3 M2,
+ * `cli-design.md` §2.5 retry behaviour).
+ *
+ * `withRetry(thunk, options)` invokes `thunk` until it returns
+ * successfully, the abort signal fires, or the retry budget is
+ * exhausted. Failures are inspected via the typed `MondayCliError`
+ * shape:
+ *
+ *  - `error.retryable === false` → re-throw immediately.
+ *  - `error.retryAfterSeconds` set → sleep that long (clamped to
+ *    `maxBackoffMs`) before the next attempt.
+ *  - Otherwise → exponential backoff with jitter, doubling per
+ *    attempt up to `maxBackoffMs`.
+ *
+ * The retry count is exposed on `RetryStats` so the caller can
+ * surface attempt totals in `--verbose` output and so a regression
+ * test can assert "exactly N attempts for a `retryable: true`
+ * failure". The latter catches any future SDK update that
+ * re-introduces an internal retry layer (`v0.1-plan.md` risk
+ * register: "SDK retry double-counting"). Today's SDK
+ * (`graphql-request@6.1.0`) has no built-in retry — we still bake
+ * the assertion in so it stays true.
+ *
+ * The thunk receives the current `attempt` (0-indexed) so the API
+ * client can include it in debug logs / fixture matchers (e.g. a
+ * cassette can assert the second attempt sees the same headers).
+ */
+import { ApiError, MondayCliError } from '../utils/errors.js';
+const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal.aborted) {
+        reject(signalAbortError(signal));
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal.removeEventListener('abort', onAbort);
+        resolve();
+    }, ms);
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(signalAbortError(signal));
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+});
+const signalAbortError = (signal) => {
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        return reason;
+    }
+    // Match Web Platform behaviour: a DOMException-style AbortError
+    // surface so callers can `.name === 'AbortError'` if they want.
+    const err = new Error(typeof reason === 'string' ? reason : 'aborted');
+    err.name = 'AbortError';
+    return err;
+};
+const clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+/**
+ * Computes the delay before the next attempt. Honours
+ * `retry_after_seconds` when present (clamped to `maxBackoffMs`),
+ * otherwise grows exponentially: `baseBackoffMs * 2 ** attempt` with
+ * ±50% jitter.
+ *
+ * Exported so the unit suite can snapshot the curve and so a future
+ * caller-side decorator (e.g. a CI runner that wants to log "next
+ * attempt in N ms") can reuse the same algorithm.
+ */
+export const computeBackoffMs = (attempt, err, opts) => {
+    if (err.retryAfterSeconds !== undefined) {
+        return clamp(err.retryAfterSeconds * 1000, 0, opts.maxBackoffMs);
+    }
+    // Exponential backoff: base * 2^attempt, ±50% jitter so simultaneous
+    // clients don't synchronise.
+    const exp = opts.baseBackoffMs * 2 ** attempt;
+    const jitterFactor = 0.5 + opts.random(); // [0.5, 1.5)
+    return clamp(exp * jitterFactor, 0, opts.maxBackoffMs);
+};
+const isRetryable = (err) => err instanceof MondayCliError && err.retryable;
+const wrapAbortAsApiError = (signal, attempt) => {
+    // The runner attaches a tagged reason; preserve it so callers can
+    // distinguish SIGINT from timeout. We don't *map* SIGINT to a code
+    // here — the runner short-circuits before any envelope is emitted —
+    // but a test that drives an explicit cancel still gets a typed
+    // throwable.
+    const reason = signal.reason;
+    const cause = reason;
+    const message = reason instanceof Error
+        ? reason.message
+        : typeof reason === 'string'
+            ? reason
+            : `aborted after ${String(attempt)} attempt${attempt === 1 ? '' : 's'}`;
+    return new ApiError('internal_error', message, {
+        cause,
+        details: { aborted: true, attempts: attempt },
+    });
+};
+/**
+ * Calls `thunk` until it succeeds or the budget is exhausted.
+ *
+ * Throwing semantics:
+ *  - On final success: returns `{ value, stats }`.
+ *  - On a non-retryable error: rethrows the original error.
+ *  - On a retryable error after budget exhaustion: rethrows the
+ *    *last* error with `details.attempts` set to the total count, so
+ *    agents can see how many times the CLI tried.
+ *  - On abort (signal fired): rethrows an `ApiError(internal_error)`
+ *    tagged `aborted: true` (the runner inspects `signal.reason` and
+ *    decides 130 vs 2). Throwing here keeps the flow uniform — the
+ *    caller doesn't have to special-case mid-sleep cancellation.
+ */
+export const withRetry = async (thunk, options) => {
+    const baseBackoffMs = options.baseBackoffMs ?? 200;
+    const maxBackoffMs = options.maxBackoffMs ?? 30_000;
+    const random = options.random ?? Math.random;
+    const sleep = options.sleep ?? defaultSleep;
+    const { signal, retries } = options;
+    // Read `signal.aborted` via a helper so the TS narrowing on the
+    // initial check at top-of-loop doesn't lock the type into `false`
+    // — the runtime value can flip between attempts when the thunk's
+    // own abort fires the signal mid-call.
+    const isAborted = () => signal.aborted;
+    let totalBackoffMs = 0;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        if (isAborted()) {
+            throw wrapAbortAsApiError(signal, attempt);
+        }
+        try {
+            const value = await thunk(attempt);
+            return { value, stats: { attempts: attempt + 1, totalBackoffMs } };
+        }
+        catch (err) {
+            if (isAborted()) {
+                throw wrapAbortAsApiError(signal, attempt + 1);
+            }
+            if (!isRetryable(err)) {
+                throw err;
+            }
+            if (attempt === retries) {
+                // Decorate the final error with the attempt count so the
+                // envelope carries it without losing the original code.
+                const decorated = new ApiError(err.code, err.message, {
+                    cause: err.cause ?? err,
+                    ...(err.httpStatus === undefined ? {} : { httpStatus: err.httpStatus }),
+                    ...(err.mondayCode === undefined ? {} : { mondayCode: err.mondayCode }),
+                    ...(err.requestId === undefined ? {} : { requestId: err.requestId }),
+                    retryable: err.retryable,
+                    ...(err.retryAfterSeconds === undefined
+                        ? {}
+                        : { retryAfterSeconds: err.retryAfterSeconds }),
+                    details: {
+                        ...(err.details ?? {}),
+                        attempts: attempt + 1,
+                    },
+                });
+                throw decorated;
+            }
+            const backoffMs = computeBackoffMs(attempt, err, {
+                baseBackoffMs,
+                maxBackoffMs,
+                random,
+            });
+            totalBackoffMs += backoffMs;
+            try {
+                await sleep(backoffMs, signal);
+            }
+            catch (sleepErr) {
+                // Cancelled mid-backoff — the signal fired during the wait.
+                // Surface the abort so the runner / caller can decide on
+                // exit code rather than continuing the loop.
+                if (sleepErr instanceof MondayCliError) {
+                    throw sleepErr;
+                }
+                throw wrapAbortAsApiError(signal, attempt + 1);
+            }
+        }
+    }
+    // Unreachable — the loop returns or throws; the type checker still
+    // wants a guarantee.
+    /* c8 ignore next */
+    throw new ApiError('internal_error', 'retry loop fell through');
+};
+//# sourceMappingURL=retry.js.map

package/dist/api/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../src/api/retry.ts"],"names":[],"mappings":"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"}

package/dist/api/set-expression.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `--set <col>=<val>` argv splitter, shared by `item set` / `item update`
+ * (single + bulk) / `item create`.
+ *
+ * Per cli-design §5.3 lines 712-715: split on the FIRST `=`. Tokens with
+ * `=` in the title need shell quoting plus the explicit `id:` / `title:`
+ * prefix or `--filter-json`-style escape. An empty token raises
+ * `usage_error`; an empty value (`status=`) is accepted at this layer
+ * and propagated to the per-type translator which decides whether to
+ * accept (e.g. `status= ` becomes `{label: ""}`) or reject (dropdown
+ * empty-input rejects per `column-values.ts`).
+ *
+ * Lifted from three identical 12-line copies (`set.ts`, `update.ts`,
+ * `create.ts`) — see v0.2-plan §12 R22. The sibling `parseSetRawExpression`
+ * in `raw-write.ts` shares the same first-`=` rule but layers JSON-object
+ * parsing on top, so it stays where it is.
+ */
+export interface SetExpression {
+    readonly token: string;
+    readonly value: string;
+}
+export declare const splitSetExpression: (raw: string) => SetExpression;
+//# sourceMappingURL=set-expression.d.ts.map

package/dist/api/set-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-expression.d.ts","sourceRoot":"","sources":["../../src/api/set-expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,KAAG,aAchD,CAAC"}

package/dist/api/set-expression.js

@@ -0,0 +1,31 @@
+/**
+ * `--set <col>=<val>` argv splitter, shared by `item set` / `item update`
+ * (single + bulk) / `item create`.
+ *
+ * Per cli-design §5.3 lines 712-715: split on the FIRST `=`. Tokens with
+ * `=` in the title need shell quoting plus the explicit `id:` / `title:`
+ * prefix or `--filter-json`-style escape. An empty token raises
+ * `usage_error`; an empty value (`status=`) is accepted at this layer
+ * and propagated to the per-type translator which decides whether to
+ * accept (e.g. `status= ` becomes `{label: ""}`) or reject (dropdown
+ * empty-input rejects per `column-values.ts`).
+ *
+ * Lifted from three identical 12-line copies (`set.ts`, `update.ts`,
+ * `create.ts`) — see v0.2-plan §12 R22. The sibling `parseSetRawExpression`
+ * in `raw-write.ts` shares the same first-`=` rule but layers JSON-object
+ * parsing on top, so it stays where it is.
+ */
+import { UsageError } from '../utils/errors.js';
+export const splitSetExpression = (raw) => {
+    const idx = raw.indexOf('=');
+    if (idx <= 0) {
+        throw new UsageError(`--set: expected <col>=<val> (got ${JSON.stringify(raw)}); ` +
+            `use shell quoting and the id:/title: prefix when the column ` +
+            `token contains "="`, { details: { input: raw } });
+    }
+    return {
+        token: raw.slice(0, idx),
+        value: raw.slice(idx + 1),
+    };
+};
+//# sourceMappingURL=set-expression.js.map

package/dist/api/set-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-expression.js","sourceRoot":"","sources":["../../src/api/set-expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAOhD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAW,EAAiB,EAAE;IAC/D,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;QACb,MAAM,IAAI,UAAU,CAClB,oCAAoC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK;YAC1D,8DAA8D;YAC9D,oBAAoB,EACtB,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAC5B,CAAC;IACJ,CAAC;IACD,OAAO;QACL,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;QACxB,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC;KAC1B,CAAC;AACJ,CAAC,CAAC"}

package/dist/api/sort.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Per-page deterministic sort (`cli-design.md` §3.1 #8, `v0.1-plan.md`
+ * §3 M4).
+ *
+ * Lists default to "by ID, ascending" regardless of Monday's response
+ * order. The seam lives here so `item list` (cursor-paginated),
+ * `item search`, and `item subitems` all share a single
+ * implementation — and so the M5b dry-run engine can sort its
+ * `planned_changes` array against the same rule when bulk operations
+ * are involved.
+ *
+ * **Per-page only, by design.** Cursor pagination delivers a stable
+ * page-by-page walk but Monday doesn't promise the cross-page order
+ * is ID-ascending. Sorting *within* a page is cheap and gives agents
+ * a stable shape to assert against (snapshot tests, fixture diffs);
+ * trying to sort across pages would either require collecting every
+ * page in memory (defeats NDJSON streaming) or a server-side
+ * `order_by` clause the agent can already pass via `--filter-json`.
+ * The §5.6 caveat documents this; the helper keeps the per-page
+ * scope explicit.
+ *
+ * **Sort key: numeric ID.** Monday's item / board / user / workspace
+ * IDs are decimal strings that can exceed `Number.MAX_SAFE_INTEGER`
+ * for older accounts (`cli-design.md` §6.2 — "IDs are always
+ * strings"). Lex sort is wrong (`"9" > "10"` in JS string compare);
+ * `Number.parseInt` is wrong for IDs past 2^53. We compare on the
+ * tuple `(length, lexicographic)` — same-length decimal strings
+ * sort numerically by lex compare, and shorter strings always
+ * represent smaller numbers (no leading zeros on Monday IDs). That's
+ * the same trick `findOne`'s `--first` selector uses (see
+ * `src/api/resolvers.ts`); centralising here means a future ID-kind
+ * with leading-zero conventions surfaces as one bug, not many.
+ *
+ * Stable sort: `Array.prototype.sort` is stable in V8 / Node ≥ 12,
+ * so tied IDs keep arrival order. The helper doesn't fall back to a
+ * second key.
+ */
+/**
+ * Compares two decimal-string IDs as if they were numeric. Returns
+ * a negative / zero / positive number suitable for `Array#sort`.
+ * Exported for unit tests and for callers that want to thread the
+ * comparator into their own collection (e.g. `findOne`'s `--first`
+ * selector — see `resolvers.ts`).
+ */
+export declare const compareNumericId: (a: string, b: string) => number;
+/**
+ * Sorts a page of resources by their ID ascending. Pure — returns a
+ * new array, leaves the input untouched. Caller passes the projector
+ * because items / boards / etc. all expose `id` differently in
+ * fixture form (`{id}` vs `{node:{id}}` for paginated edges).
+ *
+ * Empty input is fine: returns `[]`. Single-element input is fine:
+ * returns a copy. Bypassing the sort entirely on small inputs is
+ * tempting but the cost is zero on the hot path and the regression
+ * surface is shorter when every shape goes through the same
+ * comparator.
+ */
+export declare const sortByIdAsc: <T>(items: readonly T[], getId: (t: T) => string) => readonly T[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/api/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/api/sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAUvD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,OAAO,SAAS,CAAC,EAAE,EACnB,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,KACtB,SAAS,CAAC,EAEZ,CAAC"}

package/dist/api/sort.js

@@ -0,0 +1,73 @@
+/**
+ * Per-page deterministic sort (`cli-design.md` §3.1 #8, `v0.1-plan.md`
+ * §3 M4).
+ *
+ * Lists default to "by ID, ascending" regardless of Monday's response
+ * order. The seam lives here so `item list` (cursor-paginated),
+ * `item search`, and `item subitems` all share a single
+ * implementation — and so the M5b dry-run engine can sort its
+ * `planned_changes` array against the same rule when bulk operations
+ * are involved.
+ *
+ * **Per-page only, by design.** Cursor pagination delivers a stable
+ * page-by-page walk but Monday doesn't promise the cross-page order
+ * is ID-ascending. Sorting *within* a page is cheap and gives agents
+ * a stable shape to assert against (snapshot tests, fixture diffs);
+ * trying to sort across pages would either require collecting every
+ * page in memory (defeats NDJSON streaming) or a server-side
+ * `order_by` clause the agent can already pass via `--filter-json`.
+ * The §5.6 caveat documents this; the helper keeps the per-page
+ * scope explicit.
+ *
+ * **Sort key: numeric ID.** Monday's item / board / user / workspace
+ * IDs are decimal strings that can exceed `Number.MAX_SAFE_INTEGER`
+ * for older accounts (`cli-design.md` §6.2 — "IDs are always
+ * strings"). Lex sort is wrong (`"9" > "10"` in JS string compare);
+ * `Number.parseInt` is wrong for IDs past 2^53. We compare on the
+ * tuple `(length, lexicographic)` — same-length decimal strings
+ * sort numerically by lex compare, and shorter strings always
+ * represent smaller numbers (no leading zeros on Monday IDs). That's
+ * the same trick `findOne`'s `--first` selector uses (see
+ * `src/api/resolvers.ts`); centralising here means a future ID-kind
+ * with leading-zero conventions surfaces as one bug, not many.
+ *
+ * Stable sort: `Array.prototype.sort` is stable in V8 / Node ≥ 12,
+ * so tied IDs keep arrival order. The helper doesn't fall back to a
+ * second key.
+ */
+/**
+ * Compares two decimal-string IDs as if they were numeric. Returns
+ * a negative / zero / positive number suitable for `Array#sort`.
+ * Exported for unit tests and for callers that want to thread the
+ * comparator into their own collection (e.g. `findOne`'s `--first`
+ * selector — see `resolvers.ts`).
+ */
+export const compareNumericId = (a, b) => {
+    if (a.length !== b.length) {
+        return a.length - b.length;
+    }
+    // Same-length decimal strings → lex order matches numeric order.
+    // localeCompare is overkill here (and locale-dependent); a direct
+    // < / > compare is what we want.
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+/**
+ * Sorts a page of resources by their ID ascending. Pure — returns a
+ * new array, leaves the input untouched. Caller passes the projector
+ * because items / boards / etc. all expose `id` differently in
+ * fixture form (`{id}` vs `{node:{id}}` for paginated edges).
+ *
+ * Empty input is fine: returns `[]`. Single-element input is fine:
+ * returns a copy. Bypassing the sort entirely on small inputs is
+ * tempting but the cost is zero on the hot path and the regression
+ * surface is shorter when every shape goes through the same
+ * comparator.
+ */
+export const sortByIdAsc = (items, getId) => {
+    return [...items].sort((a, b) => compareNumericId(getId(a), getId(b)));
+};
+//# sourceMappingURL=sort.js.map

package/dist/api/sort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../src/api/sort.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAS,EAAE,CAAS,EAAU,EAAE;IAC/D,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAC1B,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7B,CAAC;IACD,iEAAiE;IACjE,kEAAkE;IAClE,iCAAiC;IACjC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC;IACrB,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC;IACpB,OAAO,CAAC,CAAC;AACX,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,KAAmB,EACnB,KAAuB,EACT,EAAE;IAChB,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,CAAC,CAAC"}