dataiku-sdk 4.0.0 → 4.2.0

package/dist/src/cli/commands/code-env.js

@@ -79,13 +79,15 @@ export const codeEnvCommands = withUsage("code-env", {
         examples: ["dss code-env list", "dss code-env list --lang PYTHON",],
     },
     get: {
-        handler: (c, a) => {
+        handler: (c, a, f) => {
             const usage = commandUsage("code-env", "get");
             requireArgs(a, 2, usage);
             const envLang = requireEnvLang(a[0], usage);
-            return c.codeEnvs.get(envLang, a[1]);
+            return f["full"] === true
+                ? c.codeEnvs.getDefinition(envLang, a[1])
+                : c.codeEnvs.get(envLang, a[1]);
         },
-        description: "Get code environment details: requested vs installed packages, Python interpreter, deployment mode, and the stable definition hash (definitionHash) used by set-definition --expect-hash.",
+        description: "Get code environment details: requested vs installed packages, Python interpreter, deployment mode, and the stable definition hash (definitionHash) used by set-definition --expect-hash. --full returns the raw DSS definition (same as get-definition).",
         examples: ["dss code-env get PYTHON my_env",],
     },
     "get-definition": {

package/dist/src/cli/commands/dataset.js

@@ -225,11 +225,13 @@ export const datasetCommands = withUsage("dataset", {
         handler: async (c, a, f) => {
             const previewUsage = commandUsage("dataset", "preview");
             requireArgs(a, 1, previewUsage);
-            const maxRows = num(f["max-rows"], "--max-rows");
-            if (maxRows !== undefined && (!Number.isSafeInteger(maxRows) || maxRows <= 0 || maxRows > 500)) {
-                throw new UsageError(`--max-rows must be a positive integer no greater than 500 (got "${String(f["max-rows"])}"). `
-                    + `Usage: ${previewUsage}`, "validation_failed");
+            const requestedRows = num(f["max-rows"], "--max-rows");
+            if (requestedRows !== undefined && (!Number.isSafeInteger(requestedRows) || requestedRows <= 0)) {
+                throw new UsageError(`--max-rows must be a positive integer (got "${String(f["max-rows"])}"). Usage: ${previewUsage}`, "validation_failed");
             }
+            // Agents ask for "all rows" with a large number; serve the 500-row public
+            // maximum instead of failing, and let the truncation warning say if more exist.
+            const maxRows = requestedRows === undefined ? undefined : Math.min(requestedRows, 500);
             const result = await c.datasets.preview(a[0], {
                 maxRows,
                 projectKey: f["project-key"],

package/dist/src/cli/commands/future.js

@@ -8,9 +8,14 @@ export const futureCommands = withUsage("future", {
         handler: (c, _a, f) => c.futures.list({
             allUsers: f["all-users"] === true,
             withScenarios: f["with-scenarios"] === true,
+            scenariosOnly: f["scenarios-only"] === true,
         }),
-        description: "List long tasks in progress on the instance (DSS futures): your own, or every user's with --all-users; --with-scenarios adds running scenarios.",
-        examples: ["dss future list", "dss future list --all-users --with-scenarios",],
+        description: "List long tasks in progress on the instance (DSS futures): your own, or every user's with --all-users; --with-scenarios adds running scenarios, --scenarios-only lists only running scenarios.",
+        examples: [
+            "dss future list",
+            "dss future list --all-users --with-scenarios",
+            "dss future list --scenarios-only",
+        ],
     },
     get: {
         handler: (c, a) => {

package/dist/src/cli/commands/index.js

@@ -67,6 +67,10 @@ export const commands = {
     get "meaning"() {
         return require("./meaning.js").meaningCommands;
     },
+    get "messaging-channel"() {
+        return require("./messaging-channel.js")
+            .messagingChannelCommands;
+    },
     get "workspace"() {
         return require("./workspace.js").workspaceCommands;
     },

package/dist/src/cli/commands/job.js

@@ -1,5 +1,5 @@
 import { resolve, } from "node:path";
-import { ClientValidationError, DataikuError, dataikuErrorCode, } from "../../errors.js";
+import { ClientValidationError, DataikuError, dataikuErrorCode, RESPONSE_TOO_LARGE_STATUS_TEXT, } from "../../errors.js";
 import { asRecord, } from "../../utils/records.js";
 import { jobBuildTargetTypeFromFlags, jobLogFilterFromFlag, maxLogLinesFromFlags, num, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
@@ -34,23 +34,26 @@ function tailJobLogForStdout(log, limit) {
     const tail = lines.slice(-shown).join("\n");
     return hasTrailingLineBreak ? `${tail}\n` : tail;
 }
-const RESPONSE_TOO_LARGE_STATUS_TEXT = "Response Too Large";
-/** POSIX-shell quoting for a resume command argument. */
+/** POSIX-shell quoting for the display form of a resume command. */
 function shellArg(value) {
     return /^[\w.:@%+=,/-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
-/** Command that resumes waiting for a job whose wait timed out. */
-function jobWaitResumeCommand(jobId, projectKey) {
-    return `dss job wait ${shellArg(jobId)}${projectKey ? ` --project-key ${shellArg(projectKey)}` : ""}`;
-}
 /**
  * A wait that timed out only stopped polling: the job is still running in DSS.
- * Attach the command that resumes waiting; other results pass through.
+ * Attach the command that resumes waiting: `resumeArgv` (run it without a
+ * shell, on any OS) and `resume` (POSIX display form); other results pass through.
  */
 function withWaitResume(result, projectKey) {
     if (result.timedOut !== true)
         return result;
-    return { ...result, resume: jobWaitResumeCommand(result.jobId, projectKey), };
+    const resumeArgv = [
+        "dss",
+        "job",
+        "wait",
+        result.jobId,
+        ...(projectKey ? ["--project-key", projectKey,] : []),
+    ];
+    return { ...result, resume: resumeArgv.map(shellArg).join(" "), resumeArgv, };
 }
 /**
  * With an empty output schema DSS ends a dataset build DONE after writing no

package/dist/src/cli/commands/messaging-channel.d.ts

@@ -0,0 +1,17 @@
+import type { CommandMeta } from "../types.js";
+/** The offline request shape of a messaging-channel write; mirrors the fields `commandPlanShape` returns. */
+export interface MessagingChannelPlanShape {
+    endpoint?: string;
+    exact?: boolean;
+    identifiers?: Record<string, unknown>;
+    method?: string;
+    payload?: unknown;
+    reason?: string;
+    requests?: unknown;
+}
+/**
+ * Offline request shape of a messaging-channel write, shared by `--plan` and
+ * `--dry-run`. Credentials are redacted: a plan never carries a secret.
+ */
+export declare function messagingChannelPlanShape(action: string, args: string[], flags: Record<string, string | boolean>, projectKey: string | undefined): MessagingChannelPlanShape;
+export declare const messagingChannelCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/messaging-channel.js

@@ -0,0 +1,385 @@
+import { access, } from "node:fs/promises";
+import { basename, } from "node:path";
+import { ClientValidationError, } from "../../errors.js";
+import { mailMessagePayload, mailSendQuery, messagingChannelCreateBody, } from "../../resources/messaging-channels.js";
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { messagingChannelSecretsFromBody, messagingChannelSettingsHash, sanitizeMessagingChannelError, sanitizeMessagingChannelSecrets, } from "../../utils/messaging-channel-secrets.js";
+import { isRecord, } from "../../utils/records.js";
+import { SECRET_REDACTED, } from "../../utils/secret-sanitize.js";
+import { SHA256_HEX_PATTERN, stableJson, } from "../../utils/stable-hash.js";
+import { parseBooleanOption, parseJsonValue, readInputText, readStdinText, requiredJsonInput, requiredStringFlag, splitCsvFlag, unknownJsonInput, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { planResult, readIfExists, skipResult, } from "../output.js";
+import { commandUsage, withUsage, } from "../syntax.js";
+import { requireArgs, UsageError, } from "../usage.js";
+const RESOURCE = "messaging-channel";
+const PLAN_FAILURE_CODES = { usage: 1, error: 2, transient: 3, };
+function channelEndpoint(channelId) {
+    return `/public/api/messaging-channels/${encodeURIComponent(channelId)}`;
+}
+function channelIdArg(args, usage) {
+    requireArgs(args, 1, usage);
+    const channelId = args[0].trim();
+    if (channelId.length === 0) {
+        throw new UsageError(`channel id must be a non-empty string.\nUsage: ${usage}`, "validation_failed");
+    }
+    return channelId;
+}
+/**
+ * Read commands print `[redacted]` for credentials. Writing that placeholder
+ * back would overwrite the stored secret with the literal marker, so it is
+ * refused before any request.
+ */
+function rejectRedactedPlaceholder(value, source) {
+    if (value === SECRET_REDACTED) {
+        throw new UsageError(`${source} contains the ${SECRET_REDACTED} placeholder that read commands print instead of a credential.`, "validation_failed", "Omit unchanged credential fields (settings-set merges into the stored settings) or supply the real value.");
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            rejectRedactedPlaceholder(item, source);
+    }
+    else if (isRecord(value)) {
+        for (const item of Object.values(value))
+            rejectRedactedPlaceholder(item, source);
+    }
+}
+function permissionsFromValue(value, source) {
+    if (!Array.isArray(value) || !value.every(isRecord)) {
+        throw new UsageError(`${source} must be a JSON array of permission objects such as [{"group":"analysts","canUse":true},{"user":"jdoe","canUse":false}].`, "validation_failed");
+    }
+    return value;
+}
+function createInputFromFlags(flags, usage) {
+    const type = requiredStringFlag(flags, "type", usage);
+    const configuration = unknownJsonInput(flags) ?? {};
+    if (!isRecord(configuration)) {
+        throw new UsageError("The channel configuration must be a JSON object.", "validation_failed", `Usage: ${usage}`);
+    }
+    rejectRedactedPlaceholder(configuration, "The channel configuration");
+    const permissionsText = flags["permissions"];
+    const permissions = typeof permissionsText === "string"
+        ? permissionsFromValue(parseJsonValue(permissionsText, "--permissions"), "--permissions")
+        : undefined;
+    const id = typeof flags["id"] === "string" ? flags["id"].trim() : undefined;
+    const request = {
+        type,
+        ...(id ? { id, } : {}),
+        configuration,
+        permissions,
+    };
+    const body = messagingChannelCreateBody(request);
+    return { request, body, secrets: messagingChannelSecretsFromBody(body), };
+}
+function mailBodyFromFlags(flags, usage) {
+    const sources = ["body", "body-file", "stdin",].filter((name) => name === "stdin"
+        ? parseBooleanOption(flags[name], "--stdin") === true
+        : flags[name] !== undefined);
+    if (sources.length !== 1) {
+        throw new UsageError(sources.length === 0
+            ? `--body, --body-file, or --stdin is required (message body). Usage: ${usage}`
+            : `Conflicting input sources: ${sources.map((name) => `--${name}`).join(" or ")}. Provide exactly one.`, sources.length === 0 ? "missing_required_flag" : "conflicting_input_sources");
+    }
+    if (sources[0] === "stdin")
+        return readStdinText();
+    if (sources[0] === "body-file")
+        return readInputText(String(flags["body-file"]), "--body-file");
+    return String(flags["body"]);
+}
+function sendInputFromFlags(args, flags, usage) {
+    const channelId = channelIdArg(args, usage);
+    const to = splitCsvFlag(flags["to"]);
+    if (to.length === 0) {
+        throw new UsageError(`--to is required (comma-separated recipient addresses). Usage: ${usage}`, "missing_required_flag");
+    }
+    const subject = flags["subject"];
+    if (typeof subject !== "string") {
+        throw new UsageError(`--subject is required. Usage: ${usage}`, "missing_required_flag");
+    }
+    const cc = splitCsvFlag(flags["cc"]);
+    const bcc = splitCsvFlag(flags["bcc"]);
+    const from = flags["from"];
+    return {
+        channelId,
+        message: {
+            to,
+            subject,
+            body: mailBodyFromFlags(flags, usage),
+            ...(cc.length > 0 ? { cc, } : {}),
+            ...(bcc.length > 0 ? { bcc, } : {}),
+            ...(typeof from === "string" && from.trim() ? { from: from.trim(), } : {}),
+            plainText: flags["plain-text"] === true,
+        },
+        attachments: splitCsvFlag(flags["attachment"]).map((path) => ({ path, })),
+        sendAsSingleMessage: flags["single-message"] === true,
+    };
+}
+/** Dot paths whose value differs between two settings objects; values stay out of the result. */
+function changedPaths(before, after, prefix = "") {
+    if (isRecord(before) && isRecord(after)) {
+        return [...new Set([...Object.keys(before), ...Object.keys(after),]),].flatMap((key) => changedPaths(before[key], after[key], prefix ? `${prefix}.${key}` : key));
+    }
+    return stableJson(before) === stableJson(after) ? [] : [prefix,];
+}
+function validatedExpectHash(value, usage) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !SHA256_HEX_PATTERN.test(value)) {
+        throw new UsageError(`--expect-hash must be a 64-character SHA-256 hex digest (the settingsHash of settings-get). Usage: ${usage}`, "invalid_flag_value");
+    }
+    return value.toLowerCase();
+}
+/**
+ * Offline request shape of a messaging-channel write, shared by `--plan` and
+ * `--dry-run`. Credentials are redacted: a plan never carries a secret.
+ */
+export function messagingChannelPlanShape(action, args, flags, projectKey) {
+    const usage = commandUsage(RESOURCE, action);
+    switch (action) {
+        case "create": {
+            const { body, } = createInputFromFlags(flags, usage);
+            return {
+                method: "POST",
+                endpoint: "/public/api/messaging-channels/",
+                identifiers: typeof body["id"] === "string" && body["id"] !== "" ? { id: body["id"], } : {},
+                payload: sanitizeMessagingChannelSecrets(body),
+            };
+        }
+        case "settings-set": {
+            const channelId = channelIdArg(args, usage);
+            const patch = requiredJsonInput(flags, `--data, --data-file, or --stdin is required (settings to merge). Usage: ${usage}`);
+            rejectRedactedPlaceholder(patch, "The settings patch");
+            const expectHash = validatedExpectHash(flags["expect-hash"], usage);
+            const endpoint = `${channelEndpoint(channelId)}/settings`;
+            return {
+                exact: false,
+                reason: "A fresh GET supplies the current settings, the patch is merged into them, and the merged object is PUT back.",
+                endpoint,
+                identifiers: { id: channelId, ...(expectHash ? { expectHash, } : {}), },
+                requests: [
+                    { method: "GET", endpoint, purpose: "read current settings and check --expect-hash", },
+                    {
+                        method: "PUT",
+                        endpoint,
+                        payload: "<omitted; merged settings may include credentials>",
+                        redactedFields: ["payload",],
+                    },
+                ],
+            };
+        }
+        case "permissions-set": {
+            const channelId = channelIdArg(args, usage);
+            const permissions = permissionsFromValue(unknownJsonInput(flags), "The permissions input");
+            return {
+                method: "PUT",
+                endpoint: `${channelEndpoint(channelId)}/permissions`,
+                identifiers: { id: channelId, },
+                payload: permissions,
+            };
+        }
+        case "delete": {
+            const channelId = channelIdArg(args, usage);
+            return {
+                method: "DELETE",
+                endpoint: channelEndpoint(channelId),
+                identifiers: { id: channelId, },
+            };
+        }
+        case "send": {
+            const input = sendInputFromFlags(args, flags, usage);
+            if (!projectKey) {
+                throw new UsageError(`--project-key is required for send. Usage: ${usage}`, "missing_required_flag");
+            }
+            return {
+                method: "POST",
+                endpoint: `${channelEndpoint(input.channelId)}/actions/send?${mailSendQuery(projectKey, input.sendAsSingleMessage).toString()}`,
+                identifiers: { id: input.channelId, },
+                payload: {
+                    upload: "multipart",
+                    message: mailMessagePayload(input.message),
+                    attachments: input.attachments.map((attachment) => ({
+                        path: attachment.path,
+                        fileName: basename(attachment.path),
+                    })),
+                },
+            };
+        }
+        default:
+            return {
+                exact: false,
+                reason: `No offline request shape is defined for ${RESOURCE}.${action}.`,
+            };
+    }
+}
+/** `--dry-run` result: the redacted plan, flagged as also being a dry run. */
+function dryRunPlan(action, shape, idempotency) {
+    return planResult(RESOURCE, action, {
+        ...shape,
+        asyncKind: "none",
+        exitCodesOnFailure: PLAN_FAILURE_CODES,
+        idempotency,
+        plannedAndDryRun: true,
+    });
+}
+export const messagingChannelCommands = withUsage(RESOURCE, {
+    list: {
+        handler: async (c, _a, f) => sanitizeMessagingChannelSecrets(await c.messagingChannels.list({
+            channelType: f["type"],
+            channelFamily: f["family"],
+        })),
+        description: "List messaging channels visible to the caller (compact: id, type, family; --full returns the DSS objects). Filter with --type (e.g. smtp, aws-ses-mail, slack) or --family mail. Credentials are redacted in output.",
+        examples: ["dss messaging-channel list --family mail",],
+    },
+    get: {
+        handler: async (c, a) => sanitizeMessagingChannelSecrets(await c.messagingChannels.get(channelIdArg(a, commandUsage(RESOURCE, "get")))),
+        description: "Get one messaging channel (type, family, sender of a mail channel). Credentials are redacted in output.",
+        examples: ["dss messaging-channel get smtp-main",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const { request, secrets, } = createInputFromFlags(f, commandUsage(RESOURCE, "create"));
+            if (executionMode(f).dryRun) {
+                return dryRunPlan("create", messagingChannelPlanShape("create", [], f, undefined), "none");
+            }
+            try {
+                return sanitizeMessagingChannelSecrets(await c.messagingChannels.create(request), secrets);
+            }
+            catch (error) {
+                throw sanitizeMessagingChannelError(error, secrets);
+            }
+        },
+        description: "Create a messaging channel (admin). --type: smtp, aws-ses-mail, microsoft-graph-mail, slack, msteams, google-chat, twilio, shell; --data is its configuration; --id defaults to a DSS-allocated id; --permissions is a JSON array of {group|user, canUse} (all users when omitted). Credentials are never echoed.",
+        examples: [
+            `dss messaging-channel create --type shell --id ops-shell --data '{"type":"COMMAND","command":"echo hi"}' --dry-run`,
+        ],
+    },
+    "settings-get": {
+        handler: async (c, a) => {
+            const channelId = channelIdArg(a, commandUsage(RESOURCE, "settings-get"));
+            const settings = await c.messagingChannels.getSettings(channelId);
+            return {
+                id: channelId,
+                settings: sanitizeMessagingChannelSecrets(settings),
+                settingsHash: messagingChannelSettingsHash(settings),
+            };
+        },
+        description: "Get a messaging channel's settings, i.e. its configuration (admin). Credentials are redacted; settingsHash fingerprints the redacted settings for settings-set --expect-hash.",
+        examples: ["dss messaging-channel settings-get smtp-main",],
+    },
+    "settings-set": {
+        handler: async (c, a, f) => {
+            const usage = commandUsage(RESOURCE, "settings-set");
+            const channelId = channelIdArg(a, usage);
+            const patch = requiredJsonInput(f, `--data, --data-file, or --stdin is required (settings to merge). Usage: ${usage}`);
+            rejectRedactedPlaceholder(patch, "The settings patch");
+            const expectHash = validatedExpectHash(f["expect-hash"], usage);
+            const current = await c.messagingChannels.getSettings(channelId);
+            const currentHash = messagingChannelSettingsHash(current);
+            if (expectHash !== undefined && currentHash !== expectHash) {
+                throw new ClientValidationError(`The messaging channel ${JSON.stringify(channelId)} changed since it was read.`, "validation_failed", "Re-read the settings with `dss messaging-channel settings-get` and retry with the current settingsHash.", { id: channelId, expectedHash: expectHash, actualHash: currentHash, });
+            }
+            const next = deepMerge(current, patch);
+            const secrets = messagingChannelSecretsFromBody(next);
+            const changed = changedPaths(current, next);
+            const nextHash = messagingChannelSettingsHash(next);
+            if (executionMode(f).dryRun) {
+                return {
+                    dryRun: true,
+                    action: "settings-set",
+                    resource: RESOURCE,
+                    id: channelId,
+                    method: "PUT",
+                    endpoint: `${channelEndpoint(channelId)}/settings`,
+                    current: sanitizeMessagingChannelSecrets(current),
+                    next: sanitizeMessagingChannelSecrets(next),
+                    changed,
+                    currentHash,
+                    nextHash,
+                    ...(expectHash !== undefined ? { expectHash, provenanceVerified: true, } : {}),
+                };
+            }
+            try {
+                await c.messagingChannels.saveSettings(channelId, next);
+            }
+            catch (error) {
+                throw sanitizeMessagingChannelError(error, secrets);
+            }
+            return { updated: channelId, changed, previousHash: currentHash, settingsHash: nextHash, };
+        },
+        description: "Merge supplied fields into a messaging channel's settings (GET-merge-PUT, admin); other fields are kept. --expect-hash takes settingsHash from settings-get and refuses the write if the redacted settings changed since. --dry-run shows redacted current/next settings, changed paths, and hashes. Never paste a [redacted] placeholder back: omit unchanged credentials.",
+        examples: [
+            `dss messaging-channel settings-set smtp-main --data '{"sender":"noreply@example.com"}' --dry-run`,
+        ],
+    },
+    "permissions-get": {
+        handler: (c, a) => c.messagingChannels.getPermissions(channelIdArg(a, commandUsage(RESOURCE, "permissions-get"))),
+        description: 'Get the permission list of a messaging channel: [{"group":"analysts","canUse":true},{"user":"jdoe","canUse":true}].',
+        examples: ["dss messaging-channel permissions-get smtp-main",],
+    },
+    "permissions-set": {
+        handler: async (c, a, f) => {
+            const channelId = channelIdArg(a, commandUsage(RESOURCE, "permissions-set"));
+            const permissions = permissionsFromValue(unknownJsonInput(f), "The permissions input");
+            if (executionMode(f).dryRun) {
+                return dryRunPlan("permissions-set", messagingChannelPlanShape("permissions-set", a, f, undefined), "convergent");
+            }
+            await c.messagingChannels.setPermissions(channelId, permissions);
+            return { updated: channelId, permissions, };
+        },
+        description: "Replace a messaging channel's permission list with a JSON array of {group|user, canUse} entries; read the current list with permissions-get, edit it, and send it back.",
+        examples: [
+            `dss messaging-channel permissions-set smtp-main --data '[{"group":"analysts","canUse":true}]' --dry-run`,
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            const channelId = channelIdArg(a, commandUsage(RESOURCE, "delete"));
+            if (executionMode(f).dryRun || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.messagingChannels.get(channelId));
+                if (!current)
+                    return skipResult(RESOURCE, channelId, "missing");
+                if (executionMode(f).dryRun) {
+                    return dryRunPlan("delete", messagingChannelPlanShape("delete", a, f, undefined), "if-exists");
+                }
+            }
+            await c.messagingChannels.delete(channelId);
+            return { deleted: channelId, resource: RESOURCE, };
+        },
+        description: "Delete a messaging channel (admin). Scenario reporters that point at it stop delivering.",
+        examples: ["dss messaging-channel delete ops-shell --if-exists",],
+    },
+    send: {
+        handler: async (c, a, f) => {
+            const usage = commandUsage(RESOURCE, "send");
+            const input = sendInputFromFlags(a, f, usage);
+            const projectKey = c.resolveProjectKey(f["project-key"]);
+            if (executionMode(f).dryRun) {
+                // Attachments are the one input a dry run can still check without sending.
+                for (const attachment of input.attachments) {
+                    await access(attachment.path).catch(() => {
+                        throw new UsageError(`Attachment could not be read: ${attachment.path}`, "validation_failed", "Verify that the path names an existing, readable file.");
+                    });
+                }
+                return dryRunPlan("send", messagingChannelPlanShape("send", a, f, projectKey), "none");
+            }
+            await c.messagingChannels.send(input.channelId, input.message, {
+                projectKey,
+                sendAsSingleMessage: input.sendAsSingleMessage,
+                attachments: input.attachments,
+            });
+            return {
+                sent: input.channelId,
+                projectKey,
+                to: input.message.to,
+                cc: input.message.cc ?? [],
+                bcc: input.message.bcc ?? [],
+                subject: input.message.subject,
+                attachments: input.attachments.map((attachment) => basename(attachment.path)),
+                sendAsSingleMessage: input.sendAsSingleMessage,
+            };
+        },
+        description: "Send an email through a mail channel (`list --family mail`) for a project (needs Write content). Delivered mail cannot be recalled: preview with --dry-run or --plan. Body is HTML unless --plain-text; --attachment takes comma-separated or repeated paths; one message per --to address unless --single-message.",
+        examples: [
+            'dss messaging-channel send smtp-main --to a@example.com,b@example.com --subject "Nightly build" --body "<b>done</b>" --project-key MYPROJ --dry-run',
+        ],
+    },
+});

package/dist/src/cli/commands/project-deployer.js

@@ -1,4 +1,6 @@
 import { requiredJsonInput, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { planResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, } from "../usage.js";
 export const projectDeployerCommands = withUsage("project-deployer", {
@@ -61,6 +63,37 @@ export const projectDeployerCommands = withUsage("project-deployer", {
         description: "Get a Project Deployer deployment's full health/status.",
         examples: ["dss project-deployer deployment-status my-deployment",],
     },
+    "testing-status": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, commandUsage("project-deployer", "testing-status"));
+            return c.projectDeployer.getTestingStatus(a[0], {
+                bundleId: f["bundle-id"],
+                automationNodeId: f["automation-node-id"],
+            });
+        },
+        description: "Get a deployment's testing status: the combined last-run outcome of its test scenarios (worst outcome wins). --bundle-id filters the runs to one bundle; --automation-node-id is needed for multi-node deployments only.",
+        examples: ["dss project-deployer testing-status my-deployment",],
+    },
+    "run-test-scenarios": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, commandUsage("project-deployer", "run-test-scenarios"));
+            const automationNodeId = f["automation-node-id"];
+            if (executionMode(f).dryRun) {
+                return planResult("project-deployer", "run-test-scenarios", {
+                    asyncKind: "none",
+                    method: "POST",
+                    endpoint: `/public/api/project-deployer/deployments/${encodeURIComponent(a[0])}/run-test-scenarios${automationNodeId ? `?automationNodeId=${encodeURIComponent(automationNodeId)}` : ""}`,
+                    identifiers: { deploymentId: a[0], },
+                    idempotency: "none",
+                    exitCodesOnFailure: { usage: 1, error: 2, transient: 3, },
+                    plannedAndDryRun: true,
+                });
+            }
+            return c.projectDeployer.runTestScenarios(a[0], { automationNodeId, });
+        },
+        description: "Run every test scenario of a deployment on its Automation node and return the resulting testing status. The request stays open until the scenarios finish, so raise --request-timeout for long suites. --automation-node-id is needed for multi-node deployments only; --dry-run previews the request.",
+        examples: ["dss project-deployer run-test-scenarios my-deployment --dry-run",],
+    },
     "save-deployment-settings": {
         handler: async (c, a, f) => {
             requireArgs(a, 1, commandUsage("project-deployer", "save-deployment-settings"));

package/dist/src/cli/commands/project.js

@@ -184,6 +184,36 @@ export const projectCommands = withUsage("project", {
         description: "Export a project to a local archive (.zip). The written archive is inspected locally; credential-bearing structures (apikeys.json, secret-named variables, apiKey/token/password fields) raise an export_contains_credentials warning listing member paths and key names only, and the result reports credentialFindings. The archive is not redacted.",
         examples: ["dss project export MY_PROJ --output ./my_proj.zip",],
     },
+    "test-report": {
+        handler: async (c, _a, f) => {
+            const requested = f["format"] ?? "junit";
+            const format = ["junit", "html",].find((name) => name === requested);
+            if (format === undefined) {
+                throw new UsageError("--format must be junit or html.", "invalid_enum");
+            }
+            const options = { bundleId: f["bundle-id"], format, };
+            const projectKey = f["project-key"];
+            const out = f["output"];
+            if (out) {
+                const bytes = await c.projects.downloadTestScenarioRunsReport(out, projectKey, options);
+                return { path: out, bytes, format, };
+            }
+            if (format === "html") {
+                throw new UsageError("--output PATH is required for --format html (the page is not printed to stdout).", "missing_required_flag");
+            }
+            return { format, report: await c.projects.getTestScenarioRunsReport(projectKey, options), };
+        },
+        description: "Download the report of the latest test-scenario runs (scenarios marked as test): JUnit XML by default, an HTML page with --format html. Without --output the JUnit XML is returned in the `report` field; --output PATH writes the file instead (required for html). On an Automation node --bundle-id selects the bundle, otherwise the active bundle is reported.",
+        examples: [
+            "dss project test-report --project-key MYPROJ",
+            "dss project test-report --format html --output ./test-report.html --project-key MYPROJ",
+        ],
+    },
+    "testing-status": {
+        handler: (c, _a, f) => c.projects.getTestingStatus(f["project-key"], f["bundle-id"]),
+        description: "Get the testing status of a project: the worst outcome across the last runs of its test scenarios. On an Automation node --bundle-id restricts it to runs made while that bundle was active.",
+        examples: ["dss project testing-status --project-key MYPROJ",],
+    },
     import: {
         handler: async (c, a, f) => {
             const usage = commandUsage("project", "import");

package/dist/src/cli/commands/recipe.js

@@ -412,9 +412,30 @@ export const recipeCommands = withUsage("recipe", {
                     hint: `Fix the recipe settings, then run dss recipe update-schema ${createdName}.`,
                 });
             }
-            return { created: createdName, resource: "recipe", ...created, ...moved, };
+            // A visual recipe whose payload came from flags is ready to run: point at the build
+            // (recursive, so outputs of recipes created just before are built too).
+            const output = f["output"];
+            const next = typeof output === "string" && (created.payloadConfigured || created.joinConfigured)
+                ? [[
+                        "dss",
+                        "job",
+                        "build-and-wait",
+                        output,
+                        "--build-mode",
+                        "RECURSIVE_BUILD",
+                        "--summary",
+                        ...(pk ? ["--project-key", pk,] : []),
+                    ],]
+                : undefined;
+            return {
+                created: createdName,
+                resource: "recipe",
+                ...created,
+                ...moved,
+                ...(next ? { next, } : {}),
+            };
         },
-        description: "Create a recipe with optional inputs and a dataset or managed-folder output. Missing outputs are created on --output-connection as DSS managed datasets. Join, grouping (--group-by/--aggregate) and prepare (--rename/--formula/--filter/...) payloads come from flags. Visual recipe outputs get the DSS-computed schema (outputSchemaUpdated).",
+        description: "Create a recipe; missing outputs become managed datasets on --output-connection. Join, grouping (--group-by/--aggregate: keys plus those aggregates, no implicit count) and prepare (--rename/--formula/--filter/...) payloads come from flags, then `next` is the build. Visual outputs get the DSS-computed schema.",
         examples: [
             "dss recipe create --type python --input raw_orders,lookup --output orders_clean",
             "dss recipe create --type grouping --input orders --output orders_by_cat --group-by category --aggregate amount:sum+avg,name:first --order-by day",

package/dist/src/cli/commands/scenario.d.ts

@@ -1,2 +1,8 @@
 import type { CommandMeta } from "../types.js";
+/** Run parameters from `--params JSON` or `--params-file PATH` (the POST /run body). */
+export declare function scenarioRunParams(flags: Record<string, string | boolean>): Record<string, unknown> | undefined;
+/** The trigger `trigger-add` appends: a raw `--data` object, or a schedule built from the --frequency flags. */
+export declare function scenarioTriggerFromFlags(flags: Record<string, string | boolean>): Record<string, unknown>;
+/** The reporter `reporter-add` appends: a raw `--data` object, or a mail reporter built from the --channel flags. */
+export declare function scenarioReporterFromFlags(flags: Record<string, string | boolean>): Record<string, unknown>;
 export declare const scenarioCommands: Record<string, CommandMeta>;