monday-cli 0.2.0

package/dist/api/update-mutation-result.js

@@ -0,0 +1,145 @@
+/**
+ * Update-mutation projection + GraphQL field-fragment, lifted from
+ * five M13 mutation verbs and two M3 / M5b read-or-write call sites
+ * (v0.2-plan §20 R37 + R38).
+ *
+ * **R37 — `projectMutationUpdate`.** Every M13 mutation verb (`update
+ * reply` / `edit` / `delete` plus the four toggle verbs `like` /
+ * `unlike` / `pin` / `unpin`) returns the post-mutation `Update` and
+ * guards a null payload with the same shape: a typed throw carrying
+ * `details.update_id` (or `parent_id` for reply, which keys errors
+ * off the parent the agent passed on argv), then a strict zod parse
+ * to surface the §6.4 mutation envelope's `data: <projected
+ * snapshot>`. Mirrors R28's `projectMutationItem` exactly with
+ * `Update` substituted for `Item`.
+ *
+ * Lifted from five sites — see v0.2-plan §20 R37:
+ *   - `commands/update/reply.ts` (M13 — local `projectReply`,
+ *     `idKey: 'parent_id'` because the argv input is the parent,
+ *     not the new update).
+ *   - `commands/update/edit.ts` (M13 — local `projectEdited`).
+ *   - `commands/update/delete.ts` (M13 — local `projectDeleted`).
+ *   - `commands/update/toggle.ts` (M13 — local `projectToggle`,
+ *     consumed by four toggle verbs via per-verb `mutationName`).
+ *   - `commands/update/clear-all.ts` (M13 — uses the null-check-only
+ *     variant; see "Why two exports" below).
+ *
+ * **Why two exports.** Four of the five lift sites parse the wire
+ * payload against the full `updateProjectionSchema`. Clear-all's
+ * `DELETE_UPDATE_MUTATION` deliberately selects only `{ id }` (per-
+ * target round-trip; no projection is emitted in `data.results[i]`),
+ * so the strict schema would fail on every successful delete. The
+ * lift therefore exposes two seams:
+ *
+ *   - `projectMutationUpdate({raw, updateId, mutationName, idKey?})`
+ *     — null-check + strict parse + projection. Used by reply / edit
+ *     / delete / toggle.
+ *   - `assertUpdateMutationPresent({raw, updateId, mutationName,
+ *     idKey?})` — null-check + typed throw, no projection. Used by
+ *     clear-all's per-target dispatch.
+ *
+ * Both share `buildNotFoundError` so the typed throw's shape (code,
+ * message format, `details.<idKey>`) is identical across all five
+ * sites — agents key off `error.code` + `error.details.update_id`
+ * (or `parent_id`) without caring which verb threw.
+ *
+ * **R38 — `UPDATE_FIELDS_FRAGMENT`.** The GraphQL selection set every
+ * Update-shape mutation + the M3 `update get` read share. Mirrors
+ * `ITEM_FIELDS_FRAGMENT` (M5b lift in `item-helpers.ts`); a future
+ * §6.4 wire-shape addition is a one-touch fragment edit instead of
+ * a six-touch sweep across `update create` / `reply` / `edit` /
+ * `delete` / `toggle` / `get`. Indentation matches the 6-space
+ * continuation each consumer interpolates at, so rendered query
+ * bytes are unchanged post-lift.
+ *
+ * **What stays at the call site.** Reply's `parent_id` echo from
+ * argv (`{...projected, parent_id: parentId}`) is a caller-side
+ * extension — the helper returns the base `UpdateProjection` and
+ * reply spreads onto it before emit. Mirrors R28's handling of
+ * `item duplicate`'s `duplicated_from_id` extension. `update get`'s
+ * extra `edited_at` + `replies` slots are likewise composed at the
+ * call site (`${UPDATE_FIELDS_FRAGMENT}\n  edited_at\n  replies
+ * {...}`); the fragment is the shared subset, callers compose extras
+ * on top — same shape `item subitems` uses against
+ * `ITEM_FIELDS_FRAGMENT`.
+ */
+import { z } from 'zod';
+import { ApiError } from '../utils/errors.js';
+import { unwrapOrThrow } from '../utils/parse-boundary.js';
+import { ItemIdSchema, UpdateIdSchema } from '../types/ids.js';
+/**
+ * Shared GraphQL selection set for the Update shape — every M13
+ * mutation verb plus M5b's `update create` and M3's `update get`
+ * select these fields. 6-space continuation indent matches the
+ * column every consumer interpolates `${UPDATE_FIELDS_FRAGMENT}` at,
+ * so rendered query bytes are unchanged post-lift.
+ */
+export const UPDATE_FIELDS_FRAGMENT = `id
+      body
+      text_body
+      creator_id
+      creator { id name email }
+      item_id
+      created_at
+      updated_at`;
+const creatorSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string(),
+    email: z.string(),
+})
+    .strict();
+/**
+ * Strict zod schema for the post-mutation `Update` projection — the
+ * exact shape `UPDATE_FIELDS_FRAGMENT` selects from the wire. Reply's
+ * output extends this with `parent_id` at the call site.
+ */
+export const updateProjectionSchema = z
+    .object({
+    id: UpdateIdSchema,
+    body: z.string(),
+    text_body: z.string().nullable(),
+    creator_id: z.string().nullable(),
+    creator: creatorSchema.nullable(),
+    item_id: ItemIdSchema.nullable(),
+    created_at: z.string().nullable(),
+    updated_at: z.string().nullable(),
+})
+    .strict();
+const buildNotFoundError = (mutationName, updateId, idKey) => new ApiError('not_found', `Monday returned no update from ${mutationName} for id ${updateId}`, { details: { [idKey]: updateId } });
+/**
+ * Null-check-only variant for sites whose GraphQL selection is too
+ * narrow to parse against `updateProjectionSchema` (currently just
+ * `update clear-all`'s per-target `delete_update` round-trip, which
+ * selects only `{ id }`). Throws the same typed `not_found` shape
+ * the projecting helper does so agents see one error contract across
+ * every M13 mutation verb.
+ */
+export const assertUpdateMutationPresent = (raw, ctx) => {
+    if (raw === null || raw === undefined) {
+        throw buildNotFoundError(ctx.mutationName, ctx.updateId, ctx.idKey ?? 'update_id');
+    }
+};
+/**
+ * Parses + projects a post-mutation `Update` payload, throwing the
+ * typed `not_found` on null/undefined and `internal_error` (via the
+ * R18 parse-boundary wrap) on a malformed shape. The helper owns
+ * both error envelopes; callers compose post-projection extras
+ * (reply's `parent_id` echo) at the call site.
+ *
+ * `details: { <idKey>: updateId }` is supplied by the helper so
+ * every consumer carries the same envelope shape — agents key off
+ * `details.update_id` (or `details.parent_id` for reply's not_found
+ * path) regardless of which mutation verb threw.
+ */
+export const projectMutationUpdate = (inputs) => {
+    const idKey = inputs.idKey ?? 'update_id';
+    if (inputs.raw === null || inputs.raw === undefined) {
+        throw buildNotFoundError(inputs.mutationName, inputs.updateId, idKey);
+    }
+    return unwrapOrThrow(updateProjectionSchema.safeParse(inputs.raw), {
+        context: `Monday returned a malformed update payload for id ${inputs.updateId}`,
+        details: { [idKey]: inputs.updateId },
+    });
+};
+//# sourceMappingURL=update-mutation-result.js.map

package/dist/api/update-mutation-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-mutation-result.js","sourceRoot":"","sources":["../../src/api/update-mutation-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;iBAOrB,CAAC;AAElB,MAAM,aAAa,GAAG,CAAC;KACpB,MAAM,CAAC;IACN,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;CAClB,CAAC;KACD,MAAM,EAAE,CAAC;AAEZ;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,EAAE,EAAE,cAAc;IAClB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,OAAO,EAAE,aAAa,CAAC,QAAQ,EAAE;IACjC,OAAO,EAAE,YAAY,CAAC,QAAQ,EAAE;IAChC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC;KACD,MAAM,EAAE,CAAC;AAuBZ,MAAM,kBAAkB,GAAG,CACzB,YAAoB,EACpB,QAAgB,EAChB,KAA0B,EAChB,EAAE,CACZ,IAAI,QAAQ,CACV,WAAW,EACX,kCAAkC,YAAY,WAAW,QAAQ,EAAE,EACnE,EAAE,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,CACnC,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,GAAY,EACZ,GAA0B,EACpB,EAAE;IACR,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtC,MAAM,kBAAkB,CAAC,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC;IACrF,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,MAAmC,EACjB,EAAE;IACpB,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,WAAW,CAAC;IAC1C,IAAI,MAAM,CAAC,GAAG,KAAK,IAAI,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QACpD,MAAM,kBAAkB,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,aAAa,CAAC,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;QACjE,OAAO,EAAE,qDAAqD,MAAM,CAAC,QAAQ,EAAE;QAC/E,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,QAAQ,EAAE;KACtC,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/api/users-fan-out-mutation.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Resolver-fronted partial-success fan-out for the `--users <list>`
+ * family — three M14 / M15 verbs share ~250 LOC of action body
+ * (`v0.2-plan.md` §22 R40 lift).
+ *
+ * **Used by:**
+ *   - `commands/workspace/add-users.ts` → `add_users_to_workspace`
+ *   - `commands/workspace/remove-users.ts` → `delete_users_from_workspace`
+ *   - `commands/board/add-users.ts` → `add_users_to_board`
+ *
+ * **What's lifted.** The token parser (`parseUsersArg`), the
+ * resolver loop (`resolveTokens`), the per-target dispatch loop
+ * (`dispatchSequential` callback wrapping
+ * `assertResponseFieldPresent`), the dry-run path, the live-path
+ * envelope assembly, and the partial-success / whole-call boundary
+ * all live here. Each call site collapses from ~200 LOC of action
+ * body to a single `await dispatchUsersFanOut({...})` call plus the
+ * surrounding `parseArgv` + `parseUsersArg` + `resolveClient`
+ * plumbing the caller already needs for error-precedence reasons
+ * (a malformed `--users` must surface as `usage_error` BEFORE
+ * `resolveClient`'s missing-token check fires its `config_error`).
+ *
+ * **Per-verb divergence — six parameters:**
+ *   - `mutation.{query, operationName, rootKey}` — the GraphQL
+ *     string, the PascalCase operationName for `client.raw`, and
+ *     the snake_case mutation root field.
+ *   - `dataOperation` — the literal echoed in `data.operation`
+ *     (matches `mutation.rootKey` in the M14 / M15 family but
+ *     stays a separate parameter for forward-compat).
+ *   - `scope.{id, key, variableKey}` — `'workspace_id'` /
+ *     `'board_id'` / actual id / `'workspaceId'` / `'boardId'`.
+ *   - `verbDescription` — for the whole-call `user_not_found`
+ *     message (`'workspace add-users'` etc.).
+ *
+ * Everything else is identical: the partial-success envelope,
+ * `meta.source` aggregation rule (cli-design §6.4 — dry-run only
+ * sees resolver legs; live folds in dispatch legs), the per-record
+ * `{user_id, ok, error?}` shape, and the whole-call boundary
+ * (`user_not_found` exit 2 when no dispatchable id remains).
+ *
+ * **Why the caller pre-parses tokens via `parseUsersArg` first.**
+ * The original three call sites enforce a `parseArgv` →
+ * `parseUsersArg` → `resolveClient` order so a malformed `--users`
+ * token surfaces as `usage_error` (exit 1) BEFORE `resolveClient`'s
+ * missing-token check fires `config_error` (exit 3). The helper
+ * preserves that precedence by taking already-parsed tokens — the
+ * caller runs `parseArgv` then `parseUsersArg` (both pure, both
+ * throw `UsageError` on bad input) then `resolveClient`, then this
+ * helper. Mirrors M5b's pattern: argv-shape validation runs first,
+ * then config validation, then network.
+ *
+ * **`internal_error` re-throw escape hatch.** `dispatchSequential`
+ * re-throws `internal_error` (M14 round-2 F1 / round-3 F1) so
+ * schema-drift in the response surfaces as whole-call rather than
+ * per-record. This helper inherits that behaviour by calling
+ * `assertResponseFieldPresent` (R41 helper) inside the dispatch
+ * callback — missing-root-key throws `internal_error` (re-thrown
+ * by `dispatchSequential`), null-value throws `not_found` (lands
+ * in `results[i].error`).
+ */
+import { z } from 'zod';
+import type { MondayClient, MondayResponse } from './client.js';
+import type { RunContext } from '../cli/run.js';
+import type { GlobalFlags } from '../types/global-flags.js';
+import type { EmitFromNetworkResult } from './resolve-client.js';
+export interface UsersFanOutToken {
+    readonly raw: string;
+    readonly kind: 'numeric' | 'email';
+}
+export interface UsersFanOutResultRecord {
+    /** Branded numeric Monday user id when resolution succeeded; the
+     * input token verbatim (numeric string OR email) when it failed.
+     * Always non-empty. */
+    readonly user_id: string;
+    readonly ok: boolean;
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    } | undefined;
+}
+export interface UsersFanOutEnvelope<Op extends string = string> {
+    readonly operation: Op;
+    readonly results: readonly UsersFanOutResultRecord[];
+}
+/**
+ * Parses a comma-separated `--users` argument into typed tokens.
+ * Throws `UsageError` (exit 1) on malformed input — the caller
+ * runs this BEFORE `resolveClient` so a malformed `--users`
+ * surfaces ahead of `config_error` (see file-comment rationale).
+ */
+export declare const parseUsersArg: (raw: string) => readonly UsersFanOutToken[];
+export interface UsersFanOutScope {
+    readonly id: string;
+    readonly key: 'workspace_id' | 'board_id';
+    readonly variableKey: 'workspaceId' | 'boardId';
+}
+export interface UsersFanOutMutation {
+    readonly query: string;
+    readonly operationName: string;
+    readonly rootKey: string;
+}
+export interface DispatchUsersFanOutInputs<Output extends UsersFanOutEnvelope<Op>, Op extends string = Output['operation']> {
+    readonly client: MondayClient;
+    readonly ctx: RunContext;
+    readonly programOpts: unknown;
+    readonly globalFlags: GlobalFlags;
+    readonly apiVersion: string;
+    readonly toEmit: <T>(response: MondayResponse<T>) => EmitFromNetworkResult;
+    readonly tokens: readonly UsersFanOutToken[];
+    readonly scope: UsersFanOutScope;
+    readonly mutation: UsersFanOutMutation;
+    readonly dataOperation: Op;
+    readonly verbDescription: string;
+    readonly outputSchema: z.ZodType<Output>;
+}
+/**
+ * Drives the resolver → dispatch → emit pipeline shared by the
+ * three `--users <list>` partial-success verbs. Returns void —
+ * the helper owns emit (both dry-run and live envelopes) so the
+ * call site collapses to argv-parse + scope/mutation config + this
+ * call.
+ */
+export declare const dispatchUsersFanOut: <Output extends UsersFanOutEnvelope<Op>, Op extends string = Output["operation"]>(inputs: DispatchUsersFanOutInputs<Output, Op>) => Promise<void>;
+//# sourceMappingURL=users-fan-out-mutation.d.ts.map

package/dist/api/users-fan-out-mutation.d.ts.map

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

package/dist/api/users-fan-out-mutation.js

@@ -0,0 +1,331 @@
+/**
+ * Resolver-fronted partial-success fan-out for the `--users <list>`
+ * family — three M14 / M15 verbs share ~250 LOC of action body
+ * (`v0.2-plan.md` §22 R40 lift).
+ *
+ * **Used by:**
+ *   - `commands/workspace/add-users.ts` → `add_users_to_workspace`
+ *   - `commands/workspace/remove-users.ts` → `delete_users_from_workspace`
+ *   - `commands/board/add-users.ts` → `add_users_to_board`
+ *
+ * **What's lifted.** The token parser (`parseUsersArg`), the
+ * resolver loop (`resolveTokens`), the per-target dispatch loop
+ * (`dispatchSequential` callback wrapping
+ * `assertResponseFieldPresent`), the dry-run path, the live-path
+ * envelope assembly, and the partial-success / whole-call boundary
+ * all live here. Each call site collapses from ~200 LOC of action
+ * body to a single `await dispatchUsersFanOut({...})` call plus the
+ * surrounding `parseArgv` + `parseUsersArg` + `resolveClient`
+ * plumbing the caller already needs for error-precedence reasons
+ * (a malformed `--users` must surface as `usage_error` BEFORE
+ * `resolveClient`'s missing-token check fires its `config_error`).
+ *
+ * **Per-verb divergence — six parameters:**
+ *   - `mutation.{query, operationName, rootKey}` — the GraphQL
+ *     string, the PascalCase operationName for `client.raw`, and
+ *     the snake_case mutation root field.
+ *   - `dataOperation` — the literal echoed in `data.operation`
+ *     (matches `mutation.rootKey` in the M14 / M15 family but
+ *     stays a separate parameter for forward-compat).
+ *   - `scope.{id, key, variableKey}` — `'workspace_id'` /
+ *     `'board_id'` / actual id / `'workspaceId'` / `'boardId'`.
+ *   - `verbDescription` — for the whole-call `user_not_found`
+ *     message (`'workspace add-users'` etc.).
+ *
+ * Everything else is identical: the partial-success envelope,
+ * `meta.source` aggregation rule (cli-design §6.4 — dry-run only
+ * sees resolver legs; live folds in dispatch legs), the per-record
+ * `{user_id, ok, error?}` shape, and the whole-call boundary
+ * (`user_not_found` exit 2 when no dispatchable id remains).
+ *
+ * **Why the caller pre-parses tokens via `parseUsersArg` first.**
+ * The original three call sites enforce a `parseArgv` →
+ * `parseUsersArg` → `resolveClient` order so a malformed `--users`
+ * token surfaces as `usage_error` (exit 1) BEFORE `resolveClient`'s
+ * missing-token check fires `config_error` (exit 3). The helper
+ * preserves that precedence by taking already-parsed tokens — the
+ * caller runs `parseArgv` then `parseUsersArg` (both pure, both
+ * throw `UsageError` on bad input) then `resolveClient`, then this
+ * helper. Mirrors M5b's pattern: argv-shape validation runs first,
+ * then config validation, then network.
+ *
+ * **`internal_error` re-throw escape hatch.** `dispatchSequential`
+ * re-throws `internal_error` (M14 round-2 F1 / round-3 F1) so
+ * schema-drift in the response surfaces as whole-call rather than
+ * per-record. This helper inherits that behaviour by calling
+ * `assertResponseFieldPresent` (R41 helper) inside the dispatch
+ * callback — missing-root-key throws `internal_error` (re-thrown
+ * by `dispatchSequential`), null-value throws `not_found` (lands
+ * in `results[i].error`).
+ */
+import { z } from 'zod';
+import { ApiError, UsageError } from '../utils/errors.js';
+import { unwrapOrThrow } from '../utils/parse-boundary.js';
+import { dispatchSequential } from './partial-success-mutation.js';
+import { assertResponseFieldPresent } from './response-root.js';
+import { SourceAggregator } from './source-aggregator.js';
+import { userByEmail } from './resolvers.js';
+import { emitDryRun, emitMutation } from '../commands/emit.js';
+// `--users` token validation. Numeric matches the same regex the
+// branded `UserId` schema uses (`/^\d+$/`); email is a deliberately
+// permissive shape (presence of `@` after a non-empty local-part —
+// Monday's `users(emails:)` will reject anything malformed at the
+// directory level, and we only need to distinguish "lookup this"
+// from "send this id verbatim").
+const NUMERIC_TOKEN_PATTERN = /^\d+$/u;
+const EMAIL_TOKEN_PATTERN = /^[^@\s]+@[^@\s]+$/u;
+/**
+ * Parses a comma-separated `--users` argument into typed tokens.
+ * Throws `UsageError` (exit 1) on malformed input — the caller
+ * runs this BEFORE `resolveClient` so a malformed `--users`
+ * surfaces ahead of `config_error` (see file-comment rationale).
+ */
+export const parseUsersArg = (raw) => {
+    const split = raw.split(',').map((t) => t.trim());
+    const malformed = [];
+    const tokens = [];
+    for (const token of split) {
+        if (token.length === 0) {
+            malformed.push(token);
+            continue;
+        }
+        if (NUMERIC_TOKEN_PATTERN.test(token)) {
+            tokens.push({ raw: token, kind: 'numeric' });
+            continue;
+        }
+        if (EMAIL_TOKEN_PATTERN.test(token)) {
+            tokens.push({ raw: token, kind: 'email' });
+            continue;
+        }
+        malformed.push(token);
+    }
+    if (malformed.length > 0) {
+        throw new UsageError(`--users contains malformed tokens: ${malformed.map((t) => JSON.stringify(t)).join(', ')}. Each token must be a numeric Monday user id or an email.`, { details: { malformed_tokens: malformed } });
+    }
+    // Defensive: unreachable in practice. Per-command
+    // `inputSchema.users.min(1)` rejects empty `--users` strings,
+    // and any all-empty split (e.g. ",,,") fills `malformed[]`
+    // first which throws above.
+    /* c8 ignore next 3 */
+    if (tokens.length === 0) {
+        throw new UsageError('--users must contain at least one numeric id or email');
+    }
+    return tokens;
+};
+const resolveTokens = async (client, tokens, env, noCache) => {
+    const records = [];
+    const dispatchableIds = [];
+    const dispatchableIndices = [];
+    const failedTokens = [];
+    const aggregator = new SourceAggregator();
+    let anyResolverLegFired = false;
+    for (const token of tokens) {
+        if (token.kind === 'numeric') {
+            const idx = records.length;
+            records.push({ user_id: token.raw, ok: true });
+            dispatchableIds.push(token.raw);
+            dispatchableIndices.push(idx);
+            continue;
+        }
+        // Email — flows through userByEmail. Catch resolution failure
+        // per-token rather than aborting (partial-success contract).
+        try {
+            const resolved = await userByEmail({
+                client,
+                email: token.raw,
+                env,
+                noCache,
+            });
+            anyResolverLegFired = true;
+            aggregator.record(resolved.source, resolved.cacheAgeSeconds);
+            const idx = records.length;
+            records.push({ user_id: resolved.user.id, ok: true });
+            dispatchableIds.push(resolved.user.id);
+            dispatchableIndices.push(idx);
+        }
+        catch (err) {
+            anyResolverLegFired = true;
+            // userByEmail records the live `users(emails:)` lookup as
+            // 'live' — we lost the source signal in the throw path, but
+            // a resolver leg DID fire, so reflect it in the aggregate.
+            aggregator.record('live', null);
+            if (err instanceof ApiError && err.code === 'user_not_found') {
+                records.push({
+                    user_id: token.raw,
+                    ok: false,
+                    error: { code: err.code, message: err.message },
+                });
+                failedTokens.push(token.raw);
+                continue;
+            }
+            // Non-`user_not_found` ApiError (e.g. `internal_error` on a
+            // malformed Monday response) is a whole-call failure that
+            // shouldn't be swallowed into a per-record slot — re-throw.
+            /* c8 ignore next */
+            throw err;
+        }
+    }
+    return {
+        records,
+        dispatchableIds,
+        dispatchableIndices,
+        failedTokens,
+        resolverAggregator: aggregator,
+        anyResolverLegFired,
+    };
+};
+// Schema for the wire response shape. Keys aren't required at the
+// schema level — `assertResponseFieldPresent` enforces the per-verb
+// `mutation.rootKey` check downstream. Equivalent at runtime to the
+// per-verb `z.object({ <rootKey>: z.unknown() }).loose()` shape each
+// pre-lift call site used (zod treats `z.unknown()` keys as
+// runtime-optional, so both schemas accept the same inputs).
+const wireResponseSchema = z.object({}).loose();
+/**
+ * Drives the resolver → dispatch → emit pipeline shared by the
+ * three `--users <list>` partial-success verbs. Returns void —
+ * the helper owns emit (both dry-run and live envelopes) so the
+ * call site collapses to argv-parse + scope/mutation config + this
+ * call.
+ */
+export const dispatchUsersFanOut = async (inputs) => {
+    const { client, ctx, programOpts, globalFlags, apiVersion, toEmit, tokens, scope, mutation, dataOperation, verbDescription, outputSchema, } = inputs;
+    // Phase 1: per-token resolution (numeric IDs are argv-derived;
+    // emails flow through `userByEmail`). Failures land per-record
+    // rather than aborting the loop. `--no-cache` plumbs through so
+    // the directory cache is bypassed when the agent asked.
+    const resolution = await resolveTokens(client, tokens, ctx.env, globalFlags.noCache);
+    // Whole-call boundary — no dispatchable user_id remains.
+    // Per cli-design §6.4 partial-success per-token-resolution-
+    // failures: surface as top-level `user_not_found` (NOT
+    // `usage_error` — directory miss is actionable distinct from
+    // malformed argv) carrying `details.failed_tokens`.
+    if (resolution.dispatchableIds.length === 0) {
+        throw new ApiError('user_not_found', `No dispatchable user_id remains for ${verbDescription} — every --users token failed lookup.`, {
+            details: {
+                [scope.key]: scope.id,
+                failed_tokens: resolution.failedTokens,
+            },
+        });
+    }
+    if (globalFlags.dryRun) {
+        // Dry-run: only resolver legs count toward `meta.source`.
+        // Numeric-only `--users` fires zero resolver legs → 'none'.
+        const source = resolution.anyResolverLegFired
+            ? resolution.resolverAggregator.result().source
+            : 'none';
+        const cacheAgeSeconds = resolution.anyResolverLegFired
+            ? resolution.resolverAggregator.result().cacheAgeSeconds
+            : null;
+        // Per-record dry-run shape: `{user_id, would_apply, error?}`.
+        // Mirrors the live record shape minus the `ok` rename.
+        const dryResults = resolution.records.map((r) => ({
+            user_id: r.user_id,
+            would_apply: r.ok,
+            ...(r.error === undefined ? {} : { error: r.error }),
+        }));
+        emitDryRun({
+            ctx,
+            programOpts,
+            plannedChanges: [
+                {
+                    operation: dataOperation,
+                    [scope.key]: scope.id,
+                    results: dryResults,
+                },
+            ],
+            source,
+            cacheAgeSeconds,
+            warnings: [],
+            apiVersion,
+        });
+        return;
+    }
+    // Phase 2: live dispatch — one wire call per dispatchable user.
+    // Per-target failures captured into `results[i].error` by
+    // `dispatchSequential`. Aggregator folds in dispatch legs
+    // (always live) on top of resolver legs.
+    const liveAggregator = resolution.resolverAggregator;
+    let lastResponse;
+    const dispatchResults = await dispatchSequential(resolution.dispatchableIds, 'user_id', async ({ targetId }) => {
+        // Record the dispatch leg as 'live' BEFORE the wire call —
+        // M14 round-1 F1: per-target dispatch failures must still
+        // count toward `meta.source` because the call DID fire.
+        // Without this, an all-email cache + dispatch-fails scenario
+        // would emit `source: "cache"` even though a live mutation
+        // was attempted.
+        liveAggregator.record('live', null);
+        const response = await client.raw(mutation.query, {
+            [scope.variableKey]: scope.id,
+            userIds: [targetId],
+        }, { operationName: mutation.operationName });
+        lastResponse = response;
+        // M14 round-1 F2: a 200 with `data.<rootKey>: null` and no
+        // `errors[]` is NOT a per-target success — it's a null
+        // payload Monday returns when the membership can't be
+        // applied (rare server-side path). Throw a typed ApiError
+        // so dispatchSequential lands it in `results[i].error`
+        // rather than reporting an illusory ok: true.
+        const data = unwrapOrThrow(wireResponseSchema.safeParse(response.data), {
+            context: `Monday returned a malformed ${mutation.operationName} response`,
+            details: {
+                [scope.key]: scope.id,
+                user_id: targetId,
+            },
+        });
+        // R41 lift (api/response-root.ts): distinguishes missing-
+        // root-key (internal_error, whole-call re-thrown by
+        // dispatchSequential) from null payload (not_found, per-
+        // record).
+        assertResponseFieldPresent({
+            data,
+            key: mutation.rootKey,
+            operationLabel: mutation.operationName,
+            scopeKey: scope.key,
+            scopeId: scope.id,
+            targetKey: 'user_id',
+            targetId,
+        });
+    });
+    // Merge dispatch outcomes back into the resolution records.
+    // Pre-loop resolution failures stay as-is; dispatchable records
+    // pick up the dispatch result (which may have flipped
+    // `ok: true` → `ok: false` on a Monday-side error).
+    const finalResults = [...resolution.records];
+    for (let i = 0; i < resolution.dispatchableIndices.length; i++) {
+        const idx = resolution.dispatchableIndices[i];
+        const dispatchResult = dispatchResults[i];
+        if (idx === undefined || dispatchResult === undefined)
+            continue;
+        // dispatchSequential builds a record with our id-field
+        // (`user_id`) plus `ok` + optional `error`. Lift the
+        // success/error info onto the resolution slot.
+        finalResults[idx] = {
+            user_id: resolution.records[idx]?.user_id ?? '',
+            ok: dispatchResult.ok,
+            ...(dispatchResult.error === undefined
+                ? {}
+                : { error: dispatchResult.error }),
+        };
+    }
+    emitMutation({
+        ctx,
+        // The cast widens through `unknown` because Output is a
+        // subtype-bounded generic (`Output extends UsersFanOutEnvelope
+        // <Op>`) — TS can't prove the literal matches an unknown
+        // subtype, but the schema's runtime parse inside emitMutation
+        // is the authoritative check.
+        data: {
+            operation: dataOperation,
+            results: finalResults,
+        },
+        schema: outputSchema,
+        programOpts,
+        warnings: [],
+        ...(lastResponse === undefined
+            ? { apiVersion }
+            : toEmit(lastResponse)),
+        ...liveAggregator.result(),
+    });
+};
+//# sourceMappingURL=users-fan-out-mutation.js.map

package/dist/api/users-fan-out-mutation.js.map

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