dataiku-sdk 3.6.0 → 3.7.0

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

@@ -0,0 +1,121 @@
+import { num, parseBooleanOption, splitCsvFlag, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { withUsage, } from "../syntax.js";
+import { UsageError, } from "../usage.js";
+/** `dss mlflow set-inference-info` flags → SDK inference info (shared with --plan). */
+export function inferenceInfoFromFlags(runId, f) {
+    const predictionType = f["prediction-type"];
+    if (typeof predictionType !== "string") {
+        throw new UsageError("--prediction-type is required.", "missing_required_flag");
+    }
+    const classes = splitCsvFlag(f["classes"]);
+    return {
+        runId,
+        predictionType: predictionType.toUpperCase(),
+        ...(classes.length > 0 ? { classes, } : {}),
+        ...(typeof f["code-env"] === "string" ? { codeEnvName: f["code-env"], } : {}),
+        ...(typeof f["target"] === "string" ? { target: f["target"], } : {}),
+    };
+}
+/** `dss mlflow deploy-run` flags → SDK deploy options (shared with --plan). */
+export function deployRunOptionsFromFlags(runId, savedModelId, f) {
+    const classLabels = splitCsvFlag(f["classes"]);
+    const setActive = f["set-active"];
+    const threshold = f["binary-classification-threshold"];
+    const optimal = f["use-optimal-threshold"];
+    const skipReports = f["skip-expensive-reports"];
+    return {
+        runId,
+        savedModelId,
+        ...(typeof f["version-id"] === "string" ? { versionId: f["version-id"], } : {}),
+        ...(typeof f["model-name"] === "string" ? { modelName: f["model-name"], } : {}),
+        ...(typeof f["evaluation-dataset"] === "string"
+            ? { evaluationDataset: f["evaluation-dataset"], }
+            : {}),
+        ...(typeof f["target"] === "string" ? { targetColumnName: f["target"], } : {}),
+        ...(classLabels.length > 0 ? { classLabels, } : {}),
+        ...(typeof f["code-env"] === "string" ? { codeEnvName: f["code-env"], } : {}),
+        ...(setActive !== undefined ? { activate: parseBooleanOption(setActive, "--set-active"), } : {}),
+        ...(threshold !== undefined
+            ? { binaryClassificationThreshold: num(threshold, "--binary-classification-threshold"), }
+            : {}),
+        ...(optimal !== undefined
+            ? { useOptimalThreshold: parseBooleanOption(optimal, "--use-optimal-threshold"), }
+            : {}),
+        ...(skipReports !== undefined
+            ? { skipExpensiveReports: parseBooleanOption(skipReports, "--skip-expensive-reports"), }
+            : {}),
+    };
+}
+/** `dss mlflow create-experiments-dataset` flags → SDK options (shared with --plan). */
+export function experimentsDatasetOptionsFromFlags(datasetName, f) {
+    const experimentIds = splitCsvFlag(f["experiments"]);
+    const viewType = f["view-type"];
+    const format = f["format"];
+    return {
+        datasetName,
+        ...(experimentIds.length > 0 ? { experimentIds, } : {}),
+        ...(typeof viewType === "string"
+            ? {
+                viewType: viewType.toUpperCase(),
+            }
+            : {}),
+        ...(typeof f["filter"] === "string" ? { filter: f["filter"], } : {}),
+        ...(typeof format === "string"
+            ? { format: format.toUpperCase(), }
+            : {}),
+    };
+}
+export const mlflowCommands = withUsage("mlflow", {
+    "list-models": {
+        handler: (c, a, f) => c.mlflowExtension.listModels(a[0], f["project-key"]),
+        description: "List the models an MLflow experiment-tracking run logged ({runId, artifactPath}).",
+        examples: ["dss mlflow list-models RUN_ID",],
+    },
+    "set-inference-info": {
+        handler: async (c, a, f) => {
+            await c.mlflowExtension.setRunInferenceInfo(inferenceInfoFromFlags(a[0], f), f["project-key"]);
+            return { updated: a[0], resource: "mlflow", };
+        },
+        description: "Record an MLflow run's prediction type, classes, code env, and target so deploy-run can use them.",
+        examples: [
+            "dss mlflow set-inference-info RUN_ID --prediction-type MULTICLASS --classes a,b,c --target species",
+        ],
+    },
+    "deploy-run": {
+        handler: (c, a, f) => c.mlflowExtension.deployRun(deployRunOptionsFromFlags(a[0], a[1], f), f["project-key"]),
+        description: "Deploy an MLflow run's model as a version of an existing saved model (default version id: timestamp); --evaluation-dataset evaluates it. Synchronous: DSS loads the model in its code env, often past 30 s, so raise --request-timeout.",
+        examples: [
+            "dss mlflow deploy-run RUN_ID SAVED_MODEL_ID --version-id v2 --code-env py311_mlflow --request-timeout 300000",
+        ],
+    },
+    "create-experiments-dataset": {
+        handler: async (c, a, f) => {
+            await c.mlflowExtension.createExperimentsDataset(experimentsDatasetOptionsFromFlags(a[0], f), f["project-key"]);
+            return { created: a[0], resource: "mlflow", };
+        },
+        description: "Create a virtual dataset exposing the project's MLflow experiment-tracking runs.",
+        examples: ["dss mlflow create-experiments-dataset mlflow_runs --experiments FGXlefMU",],
+    },
+    "garbage-collect": {
+        handler: async (c, _a, f) => {
+            if (executionMode(f).dryRun) {
+                return { dryRun: true, action: "garbage-collect", resource: "mlflow", };
+            }
+            await c.mlflowExtension.garbageCollect(f["project-key"]);
+            return { garbageCollected: true, resource: "mlflow", };
+        },
+        description: "Permanently delete the project's MLflow experiments and runs marked as deleted.",
+        examples: ["dss mlflow garbage-collect --dry-run",],
+    },
+    "clean-db": {
+        handler: async (c, _a, f) => {
+            if (executionMode(f).dryRun)
+                return { dryRun: true, action: "clean-db", resource: "mlflow", };
+            await c.mlflowExtension.cleanDb(f["project-key"]);
+            return { cleaned: true, resource: "mlflow", };
+        },
+        description: "Admin: delete ALL MLflow experiment-tracking data of the project (experiments, runs, params, metrics, tags). Irreversible.",
+        examples: ["dss mlflow clean-db --plan",],
+    },
+});

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

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import { validatedPluginGitUrl, validatePluginDestinationPath, validatePluginId, validatePluginName, validatePluginPath, } from "../../resources/plugins.js";
-import { num, readStdinText, } from "../coerce.js";
+import { writeResponseToFile, } from "../../utils/response-file.js";
+import { num, readStdinText, sha256Hex, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { planResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
@@ -188,7 +189,7 @@ export const pluginCommands = withUsage("plugin", {
             }
             const pluginId = validatePluginId(a[0]);
             const res = await c.plugins.download(pluginId);
-            const bytes = await writeResponseToFileForPlugin(out, res);
+            const bytes = await writeResponseToFile(out, res);
             return { path: out, bytes, };
         },
         description: "Download a development plugin as a zip archive to a local file.",
@@ -598,7 +599,7 @@ export const pluginCommands = withUsage("plugin", {
             const out = f["output"];
             if (typeof out === "string" && out.trim() !== "") {
                 const res = await c.plugins.downloadFile(pluginId, path);
-                const bytes = await writeResponseToFileForPlugin(out, res);
+                const bytes = await writeResponseToFile(out, res);
                 return { path: out, bytes, };
             }
             return { data: await c.plugins.getFile(pluginId, path), };
@@ -634,10 +635,7 @@ export const pluginCommands = withUsage("plugin", {
                     : await readStdinText();
             await c.plugins.putFile(pluginId, path, content);
             const bytes = typeof content === "string" ? Buffer.byteLength(content, "utf8") : content.length;
-            const hasher = new Bun.CryptoHasher("sha256");
-            hasher.update(typeof content === "string" ? content : new Uint8Array(content));
-            const sha256 = hasher.digest("hex");
-            return { written: path, pluginId, bytes, sha256, };
+            return { written: path, pluginId, bytes, sha256: sha256Hex(content), };
         },
         description: "Create or replace a development plugin file with text or binary content; reports the written byte count and sha256.",
         examples: [
@@ -760,7 +758,3 @@ function readSettingsInput(flags) {
     }
     return parsed;
 }
-async function writeResponseToFileForPlugin(path, res) {
-    const { writeResponseToFile, } = await import("../../utils/response-file.js");
-    return writeResponseToFile(path, res);
-}

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

@@ -103,4 +103,74 @@ export const projectDeployerCommands = withUsage("project-deployer", {
         description: "Create a Project Deployer infrastructure.",
         examples: ["dss project-deployer create-infra --data-file infra.json",],
     },
+    "list-stages": {
+        handler: (c) => c.projectDeployer.listStages(),
+        description: "List the Project Deployer stages (e.g. Development, Test, Production).",
+        examples: ["dss project-deployer list-stages",],
+    },
+    "get-infra": {
+        handler: (c, a) => c.projectDeployer.getInfra(a[0]),
+        description: "Get a Project Deployer infrastructure (stage, automation node, deployments).",
+        examples: ["dss project-deployer get-infra prod-infra",],
+    },
+    "infra-settings": {
+        handler: (c, a) => c.projectDeployer.getInfraSettings(a[0]),
+        description: "Get an infrastructure's settings (permissions, automation node URL, connection remappings).",
+        examples: ["dss project-deployer infra-settings prod-infra",],
+    },
+    "save-infra-settings": {
+        handler: async (c, a, f) => {
+            await c.projectDeployer.saveInfraSettings(a[0], requiredJsonInput(f, "--data, --data-file, or --stdin is required (settings from infra-settings)."));
+            return { updated: a[0], resource: "project-deployer", };
+        },
+        description: "Save infrastructure settings obtained from infra-settings, edited.",
+        examples: ["dss project-deployer save-infra-settings prod-infra --data-file infra.json",],
+    },
+    "delete-infra": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteInfra(a[0]);
+            return { deleted: a[0], resource: "project-deployer", };
+        },
+        description: "Delete an infrastructure that no deployment uses.",
+        examples: ["dss project-deployer delete-infra old-infra --plan",],
+    },
+    "deployment-settings": {
+        handler: (c, a) => c.projectDeployer.getDeploymentSettings(a[0]),
+        description: "Get a deployment's settings (infra, bundle, remappings); edit and send to save-deployment-settings.",
+        examples: ["dss project-deployer deployment-settings v1-on-prod",],
+    },
+    "governance-status": {
+        handler: (c, a, f) => c.projectDeployer.getGovernanceStatus(a[0], f["bundle-id"]),
+        description: "Governance status of a deployment's bundle (or --bundle-id): messages on whether it may be deployed.",
+        examples: ["dss project-deployer governance-status v1-on-prod",],
+    },
+    "delete-project": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteProject(a[0]);
+            return { deleted: a[0], resource: "project-deployer", };
+        },
+        description: "Delete a published project that no deployment uses.",
+        examples: ["dss project-deployer delete-project MYPROJECT --plan",],
+    },
+    "project-settings": {
+        handler: (c, a) => c.projectDeployer.getProjectSettings(a[0]),
+        description: "Get a published project's settings (owner, permissions).",
+        examples: ["dss project-deployer project-settings MYPROJECT",],
+    },
+    "save-project-settings": {
+        handler: async (c, a, f) => {
+            await c.projectDeployer.saveProjectSettings(a[0], requiredJsonInput(f, "--data, --data-file, or --stdin is required (settings from project-settings)."));
+            return { updated: a[0], resource: "project-deployer", };
+        },
+        description: "Save published project settings obtained from project-settings, edited.",
+        examples: ["dss project-deployer save-project-settings MYPROJECT --data-file published.json",],
+    },
+    "delete-bundle": {
+        handler: async (c, a) => {
+            await c.projectDeployer.deleteBundle(a[0], a[1]);
+            return { deleted: a[1], resource: "project-deployer", project: a[0], };
+        },
+        description: "Delete a bundle of a published project that no deployment uses.",
+        examples: ["dss project-deployer delete-bundle MYPROJECT v1 --plan",],
+    },
 });

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

@@ -8,9 +8,6 @@ import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 const PROJECT_LIBRARY_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
 const PUT_FLAG_ERROR_HINT = "Pass a 64-character SHA-256 hex digest (lowercase or uppercase).";
-function sha256BytesHex(bytes) {
-    return new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
-}
 function projectLibraryContentsEndpoint(client, projectKey, path) {
     return encodedProjectEndpoint(client, projectKey, `/libraries/contents/${encodeLibraryPath(path)}`);
 }
@@ -43,7 +40,7 @@ export function projectLibraryPutPayload(flags) {
             contentSource: "file",
             file: flags["file"],
             bytes: bytes.length,
-            sha256: sha256BytesHex(bytes),
+            sha256: sha256Hex(bytes),
             ...(expectSha256 ? { expectSha256, } : {}),
         };
     }
@@ -90,7 +87,7 @@ export const projectLibraryCommands = withUsage("project-library", {
                 throw new UsageError("--output PATH is required.", "missing_required_flag");
             const bytes = await c.projectLibrary.getFileBytes(a[0], f["project-key"]);
             const written = await Bun.write(out, bytes, { createPath: false, });
-            return { path: out, bytes: written, sha256: sha256BytesHex(bytes), };
+            return { path: out, bytes: written, sha256: sha256Hex(bytes), };
         },
         description: "Download a project library file's raw bytes to a local file.",
         examples: ["dss project-library get-bytes static/logo.png --output ./logo.png",],

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

@@ -278,4 +278,12 @@ export const projectCommands = withUsage("project", {
         description: "Update a project's settings via JSON merge.",
         examples: ["dss project settings-set --data-file settings.json --project-key MY_PROJ",],
     },
+    "push-to-git-remote": {
+        handler: async (c, a, f) => {
+            await c.projects.pushToGitRemote(a[0], f["project-key"]);
+            return { pushed: a[0], resource: "project", };
+        },
+        description: "Push the project to a Git remote already declared in DSS (per-project Git mode). Branches, commits, pulls, and remotes: dss project-git.",
+        examples: ["dss project push-to-git-remote origin --plan",],
+    },
 });

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

@@ -13,6 +13,15 @@ export declare function recipeCreateOptionsFromFlags(f: Record<string, string |
     fuzzyDistance?: string | undefined;
     fuzzyThreshold?: number | undefined;
     fuzzyNormalize: boolean;
+    orderBy?: string | undefined;
+    formula?: string | undefined;
+    filter?: string | undefined;
     projectKey: string | undefined;
+    aggregate?: string[] | undefined;
+    dropColumns?: string[] | undefined;
+    fillEmpty?: string[] | undefined;
+    groupBy?: string[] | undefined;
+    keepColumns?: string[] | undefined;
+    rename?: string[] | undefined;
 };
 export declare const recipeCommands: Record<string, CommandMeta>;

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

@@ -1,13 +1,14 @@
 import { readFileSync, } from "node:fs";
 import { writeFile, } from "node:fs/promises";
 import { join, } from "node:path";
-import { ClientValidationError, } from "../../errors.js";
+import { ClientValidationError, DataikuError, } from "../../errors.js";
+import { recipeOutputSchemaIsComputable, schemaUpdateComputableId, schemaUpdateIsPending, } from "../../resources/recipe-create.js";
 import { deepMerge, } from "../../utils/deep-merge.js";
 import { jobLogFilterFromFlag, jsonInput, maxLogLinesFromFlags, normalizeLineEndings, num, recipeInputDatasetsFromFlags, requiredJsonInput, requiredStringFlag, rewritePairsFromFlags, sha256Hex, splitCsvFlag, stableHash, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { moveCreatedItemsToZone, resolveFlowZoneIdFromFlags, } from "../helpers/flow-zone.js";
 import { ensureRecipeBackupDir, readRecipeBackup, recipeBackupDocument, recipeBackupPath, recipeCodeEnv, recipeGraph, recipeInputItemRef, recipeRoleInputItems, recipeRunShouldWait, writeRecipeBackup, } from "../helpers/recipe.js";
-import { encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
+import { encodedProjectEndpoint, enqueueCliWarning, readIfExists, skipResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 /** Read a local recipe file before any DSS request, mapping read failures to usage validation. */
@@ -30,6 +31,51 @@ function readRecipeBackupFile(backupPath) {
         throw new UsageError(`Could not read --backup ${backupPath}: ${reason}.`, "not_found", "Verify the backup file path and that it is readable.");
     }
 }
+/**
+ * DSS does not recompute visual-recipe output schemas when the recipe is
+ * saved, and a build against a stale or empty output schema "succeeds" with
+ * the wrong columns. Around a payload write: outputs whose schema matched the
+ * DSS-computed one before the write (DSS-derived) or is empty get the newly
+ * computed schema; outputs whose schema had been hand-edited are left alone
+ * and reported in a warning.
+ */
+async function writeKeepingDerivedOutputSchemas(c, recipeName, recipeType, projectKey, write) {
+    if (typeof recipeType !== "string" || !recipeOutputSchemaIsComputable(recipeType)) {
+        await write();
+        return {};
+    }
+    const derivedOutputs = await c.recipes.computeSchemaUpdates(recipeName, projectKey).then((before) => before.computables.filter((computable) => !schemaUpdateIsPending(computable)).map(schemaUpdateComputableId), 
+    // Unknown before-state: only empty schemas are safe to fill.
+    (error) => {
+        if (error instanceof DataikuError)
+            return [];
+        throw error;
+    });
+    await write();
+    try {
+        const result = await c.recipes.updateSchema(recipeName, { projectKey, derivedOutputs, });
+        if (result.pending.length > 0) {
+            enqueueCliWarning({
+                code: "recipe_output_schema_outdated",
+                recipe: recipeName,
+                outputs: result.pending,
+                hint: `These outputs have an edited schema that differs from the DSS-computed one. Run dss recipe update-schema ${recipeName} to replace it, or build with --auto-update-schema.`,
+            });
+        }
+        return result.updated.length > 0 ? { outputSchemaUpdated: result.updated, } : {};
+    }
+    catch (error) {
+        if (!(error instanceof DataikuError))
+            throw error;
+        enqueueCliWarning({
+            code: "recipe_output_schema_not_computed",
+            recipe: recipeName,
+            error: error.message.split("\n")[0],
+            hint: `Fix the recipe settings, then run dss recipe update-schema ${recipeName}.`,
+        });
+        return {};
+    }
+}
 function formatLineDiff(remoteName, localPath, remoteContent, localContent) {
     // Line-ending differences are not content differences: compare and split on
     // CRLF-normalized text, mirroring assert-unchanged's normalized payload hash.
@@ -112,10 +158,23 @@ export function recipeCreateOptionsFromFlags(f) {
         ...(fuzzyDistance ? { fuzzyDistance, } : {}),
         ...(fuzzyThreshold !== undefined ? { fuzzyThreshold, } : {}),
         fuzzyNormalize: f["normalize"] === true,
+        ...csvOption("groupBy", f["group-by"]),
+        ...csvOption("aggregate", f["aggregate"]),
+        ...(typeof f["order-by"] === "string" ? { orderBy: f["order-by"], } : {}),
+        ...csvOption("rename", f["rename"]),
+        ...csvOption("fillEmpty", f["fill-empty"]),
+        ...(typeof f["formula"] === "string" ? { formula: f["formula"], } : {}),
+        ...(typeof f["filter"] === "string" ? { filter: f["filter"], } : {}),
+        ...csvOption("dropColumns", f["drop-columns"]),
+        ...csvOption("keepColumns", f["keep-columns"]),
         projectKey: pk,
     };
     return payload;
 }
+function csvOption(key, value) {
+    const items = splitCsvFlag(value);
+    return items.length > 0 ? { [key]: items, } : {};
+}
 export const recipeCommands = withUsage("recipe", {
     list: {
         handler: (c, _a, f) => c.recipes.list(f["project-key"]),
@@ -310,13 +369,21 @@ export const recipeCommands = withUsage("recipe", {
                     objectId: createdName,
                     objectType: "RECIPE",
                 },], pk);
+            if (created.outputSchemaUpdateError) {
+                enqueueCliWarning({
+                    code: "recipe_output_schema_not_computed",
+                    recipe: createdName,
+                    error: created.outputSchemaUpdateError,
+                    hint: `Fix the recipe settings, then run dss recipe update-schema ${createdName}.`,
+                });
+            }
             return { created: createdName, resource: "recipe", ...created, ...moved, };
         },
-        description: "Create a recipe with optional inputs and a dataset or managed-folder output.",
+        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).",
         examples: [
             "dss recipe create --type python --input raw_orders,lookup --output orders_clean",
-            "dss recipe create --type python --input orders --input customers --output orders_clean --zone Experiments",
-            "dss recipe create --type python --input orders --output-folder LT7TUHJ8 --output-connection filesystem --dry-run",
+            "dss recipe create --type grouping --input orders --output orders_by_cat --group-by category --aggregate amount:sum+avg,name:first --order-by day",
+            "dss recipe create --type prepare --input orders --output orders_prep --rename name=label --formula 'total=amount * 2' --filter 'amount > 0'",
         ],
     },
     clone: {
@@ -586,22 +653,41 @@ export const recipeCommands = withUsage("recipe", {
                 ensureRecipeBackupDir(backupDir);
                 writeRecipeBackup(backupPath, `${JSON.stringify(recipeBackupDocument(a[0], pk, current), null, 2)}\n`);
             }
-            await c.recipes.replace(a[0], { ...current, payload: content, }, pk);
+            const schema = await writeKeepingDerivedOutputSchemas(c, a[0], current.recipe.type, pk, () => c.recipes.replace(a[0], { ...current, payload: content, }, pk));
             return {
                 updated: a[0],
                 resource: "recipe",
                 file: filePath,
                 backupCreated: backupPath !== undefined,
                 ...(backupPath ? { backupPath, } : {}),
+                ...schema,
             };
         },
-        description: "Upload recipe code from a local file, backing up payload, graph, settings, and version metadata by default.",
+        description: "Upload recipe code from a local file, backing up payload, graph, settings, and version metadata by default. For visual and SQL query recipes, outputs whose schema was empty or matched the DSS-computed one before the upload get the newly computed schema (outputSchemaUpdated); hand-edited output schemas are kept and reported in a recipe_output_schema_outdated warning.",
         examples: [
             "dss recipe set-payload compute_orders --file code.py --dry-run",
             "dss recipe set-payload compute_orders --file code.py --backup-dir ./backups",
             "dss recipe set-payload compute_orders --file code.py --no-backup",
         ],
     },
+    "update-schema": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, commandUsage("recipe", "update-schema"));
+            const dryRun = executionMode(f).dryRun;
+            const result = await c.recipes.updateSchema(a[0], {
+                projectKey: f["project-key"],
+                dryRun,
+            });
+            return dryRun
+                ? { dryRun: true, action: "update-schema", resource: "recipe", name: a[0], ...result, }
+                : result;
+        },
+        description: "Propagate schema changes: write the output schemas DSS computes from a visual or SQL query recipe (the UI's Update schema; dataikuapi compute_schema_updates().apply()) to every output whose schema differs. --dry-run lists them under pending. Code recipes are rejected: their code sets the schema when it runs.",
+        examples: [
+            "dss recipe update-schema compute_orders_joined --dry-run",
+            "dss recipe update-schema compute_orders_joined",
+        ],
+    },
     restore: {
         handler: async (c, a, f) => {
             const usage = commandUsage("recipe", "restore");

package/dist/src/cli/commands/saved-model.d.ts

@@ -1,6 +1,6 @@
 import type { CommandMeta } from "../types.js";
 /**
- * Mutating actions accept --plan (buildMutationPlan in contract.ts owns the
+ * Mutating actions accept --plan (buildMutationPlan in plans.ts owns the
  * --plan path centrally); the handlers below keep --dry-run support with a
  * zero-request planned payload, mirroring set-active/delete.
  */

package/dist/src/cli/commands/saved-model.js

@@ -1,12 +1,11 @@
-import { unexpectedResponseError, } from "../../errors.js";
-import { writeResponseToFile, } from "../../utils/response-file.js";
 import { json, jsonInput, parseBooleanOption, requiredJsonInput, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
+import { trainedModelCommands, } from "../helpers/trained-model.js";
 import { readIfExists, skipResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 /**
- * Mutating actions accept --plan (buildMutationPlan in contract.ts owns the
+ * Mutating actions accept --plan (buildMutationPlan in plans.ts owns the
  * --plan path centrally); the handlers below keep --dry-run support with a
  * zero-request planned payload, mirroring set-active/delete.
  */
@@ -361,79 +360,13 @@ export const savedModelCommands = withUsage("saved-model", {
             "dss saved-model evaluate-version MODEL_ID VERSION_ID --dataset ds --skip-expensive-reports true --project-key PROJECT",
         ],
     },
-    "download-scoring-jar": {
-        handler: async (c, a, f) => {
-            const usage = commandUsage("saved-model", "download-scoring-jar");
-            requireArgs(a, 2, usage);
-            const out = f["output"];
-            if (!out)
-                throw new UsageError("--output PATH is required.", "missing_required_flag");
-            const fullClassName = f["full-class-name"];
-            const jarOptions = {
-                ...(fullClassName !== undefined ? { fullClassName, } : {}),
-                ...(f["include-libs"] !== undefined
-                    ? { includeLibs: parseBooleanOption(f["include-libs"], "--include-libs"), }
-                    : {}),
-            };
-            const res = await c.savedModels.downloadScoringJar(jarOptions, a[0], a[1], f["project-key"]);
-            if (!res.body) {
-                throw unexpectedResponseError("savedModels.downloadScoringJar response did not include a body");
-            }
-            const bytes = await writeResponseToFile(out, res);
-            return { path: out, bytes, };
-        },
-        description: "Download the optimized scoring JAR of a version (license-gated server side). --full-class-name forwards the documented fullClassName query parameter; --include-libs toggles including scoring libraries.",
-        examples: [
-            "dss saved-model download-scoring-jar MODEL_ID VERSION_ID --output ./scoring.jar --project-key PROJECT",
-            "dss saved-model download-scoring-jar MODEL_ID VERSION_ID --output ./scoring.jar --full-class-name model.Model --include-libs false --project-key PROJECT",
-        ],
-    },
-    "download-scoring-pmml": {
-        handler: async (c, a, f) => {
-            requireArgs(a, 2, commandUsage("saved-model", "download-scoring-pmml"));
-            const out = f["output"];
-            if (!out)
-                throw new UsageError("--output PATH is required.", "missing_required_flag");
-            const res = await c.savedModels.downloadScoringPmml(a[0], a[1], f["project-key"]);
-            if (!res.body) {
-                throw unexpectedResponseError("savedModels.downloadScoringPmml response did not include a body");
-            }
-            const bytes = await writeResponseToFile(out, res);
-            return { path: out, bytes, };
-        },
-        description: "Download the PMML scoring file of a version (license-gated server side).",
-        examples: [
-            "dss saved-model download-scoring-pmml MODEL_ID VERSION_ID --output ./model.pmml --project-key PROJECT",
-        ],
-    },
-    "set-user-meta": {
-        handler: async (c, a, f) => {
-            const usage = commandUsage("saved-model", "set-user-meta");
-            requireArgs(a, 2, usage);
-            const userMeta = requiredJsonInput(f, "User-meta JSON is required via --data, --data-file, or --stdin.");
-            const projectKey = f["project-key"];
-            if (executionMode(f).dryRun) {
-                return {
-                    dryRun: true,
-                    action: "set-user-meta",
-                    resource: "saved-model",
-                    id: a[0],
-                    versionId: a[1],
-                    projectKey,
-                    payload: userMeta,
-                };
-            }
-            return c.savedModels.setUserMeta(a[0], a[1], userMeta, projectKey).then(() => ({
-                updated: a[0],
-                versionId: a[1],
-                resource: "saved-model",
-            }));
-        },
-        description: 'Update the user metadata of a model version. Send only the "userMeta" field of a previously-retrieved version-details object.',
-        examples: [
-            'dss saved-model set-user-meta MODEL_ID VERSION_ID --data \'{"name":"Churn model","description":"v2"}\' --project-key PROJECT',
-        ],
-    },
+    ...trainedModelCommands({
+        resource: "saved-model",
+        ids: "MODEL_ID VERSION_ID",
+        noun: "saved-model version",
+        model: (c, a, pk) => c.savedModels.version(a[0], a[1], pk),
+        downloadDocumentation: (c, exportId, pk) => c.savedModels.downloadDocumentation(exportId, pk),
+    }),
 });
 function mlflowImportOptions(f) {
     const codeEnvName = f["code-env"];

package/dist/src/cli/commands/streaming-endpoint.js

@@ -1,6 +1,6 @@
 import { jsonInput, requiredJsonInput, } from "../coerce.js";
 import { commandUsage, withUsage, } from "../syntax.js";
-import { requireArgs, } from "../usage.js";
+import { requireArgs, UsageError, } from "../usage.js";
 export const streamingEndpointCommands = withUsage("streaming-endpoint", {
     list: {
         handler: (c, _a, f) => c.streamingEndpoints.list(f["project-key"]),
@@ -43,4 +43,33 @@ export const streamingEndpointCommands = withUsage("streaming-endpoint", {
         description: "Delete a streaming endpoint.",
         examples: ["dss streaming-endpoint delete my-stream",],
     },
+    "create-managed": {
+        handler: async (c, a, f) => {
+            const connectionId = f["connection"];
+            if (typeof connectionId !== "string") {
+                throw new UsageError("--connection CONN is required.", "missing_required_flag");
+            }
+            const formatOptionId = f["format-option"];
+            await c.streamingEndpoints.createManaged(a[0], {
+                connectionId,
+                ...(typeof formatOptionId === "string" ? { formatOptionId, } : {}),
+            }, f["project-key"]);
+            return { created: a[0], resource: "streaming-endpoint", };
+        },
+        description: "Create a managed streaming endpoint on a connection; DSS picks type and params from the connection (--format-option for the message format).",
+        examples: ["dss streaming-endpoint create-managed orders_stream --connection kafka_main",],
+    },
+    schema: {
+        handler: (c, a, f) => c.streamingEndpoints.getSchema(a[0], f["project-key"]),
+        description: "Get a streaming endpoint's schema ({columns: [{name, type}]}).",
+        examples: ["dss streaming-endpoint schema orders_stream",],
+    },
+    "set-schema": {
+        handler: async (c, a, f) => {
+            await c.streamingEndpoints.setSchema(a[0], requiredJsonInput(f, '--data, --data-file, or --stdin is required ({"columns": [...]}).'), f["project-key"]);
+            return { updated: a[0], resource: "streaming-endpoint", };
+        },
+        description: "Replace a streaming endpoint's schema with an object from the schema action, edited.",
+        examples: ["dss streaming-endpoint set-schema orders_stream --data-file schema.json",],
+    },
 });

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

@@ -113,4 +113,12 @@ export const webappCommands = withUsage("webapp", {
         description: "Get a webapp backend's runtime state.",
         examples: ["dss webapp backend-state WEBAPP_ID",],
     },
+    trust: {
+        handler: (c, a, f) => c.webapps.trust(a[0], {
+            projectKey: f["project-key"],
+            ...(f["for-everybody"] === true ? { trustForEverybody: true, } : {}),
+        }),
+        description: "Trust a webapp's code so it can run for you, or for every user with --for-everybody (admin). Returns canAccess and trustedCodeStatus.",
+        examples: ["dss webapp trust VCMN2ra", "dss webapp trust VCMN2ra --for-everybody",],
+    },
 });