dataiku-sdk 3.9.0 → 4.1.0

package/dist/src/cli/env.js

@@ -1,6 +1,5 @@
 import { readFileSync, } from "node:fs";
-import { dirname, resolve, } from "node:path";
-import { fileURLToPath, } from "node:url";
+import { resolve, } from "node:path";
 const projectEnvVars = new Set();
 const installEnvVars = new Set();
 /**
@@ -24,6 +23,14 @@ export function dataikuEnvironmentEnabled() {
 export function ambientProjectKey() {
     return dataikuEnvironmentEnabled() ? process.env.DATAIKU_PROJECT_KEY : undefined;
 }
+/**
+ * `DSS_PRETTY=1` indents stdout JSON. Agent shells that cut long lines (omp at
+ * 768 bytes) truncate a one-line result; indented output keeps each line short.
+ * Read from the process environment only, never from a `.env` file.
+ */
+export function prettyOutputEnabled() {
+    return process.env.DSS_PRETTY === "1";
+}
 const allowedEnvKeys = new Set(["NODE_EXTRA_CA_CERTS", "NODE_TLS_REJECT_UNAUTHORIZED",]);
 /**
  * `.env` files are untrusted input: only the CLI's own `DATAIKU_*` variables and
@@ -42,7 +49,7 @@ export function loadEnvFile() {
     // CLI. First writer wins below, so cwd must be listed first.
     const dirs = [
         process.cwd(),
-        resolve(dirname(fileURLToPath(import.meta.url)), "..", ".."),
+        resolve(import.meta.dir, "..", ".."),
     ];
     for (const [index, dir,] of dirs.entries()) {
         try {

package/dist/src/cli/helpers/app-permissions.d.ts

@@ -43,7 +43,7 @@ export declare function buildAppPermissionsSnapshot(projectKey: string, dssUrl:
 export declare function writeAppPermissionsSnapshot(filePath: string, snapshot: AppPermissionsSnapshot): void;
 /** Validate envelope shape, version, and hash integrity. Never echoes permission payloads. */
 export declare function parseAppPermissionsSnapshot(text: string, source: string): AppPermissionsSnapshot;
-export declare function readAppPermissionsSnapshot(filePath: string): AppPermissionsSnapshot;
+export declare function readAppPermissionsSnapshot(filePath: string): Promise<AppPermissionsSnapshot>;
 /**
  * Refuse to use a snapshot outside the exact project *and* DSS server it was captured
  * from. Access-control rules are server-scoped: the same project key, users, and groups

package/dist/src/cli/helpers/app-permissions.js

@@ -153,10 +153,10 @@ export function parseAppPermissionsSnapshot(text, source) {
         permissions,
     };
 }
-export function readAppPermissionsSnapshot(filePath) {
+export async function readAppPermissionsSnapshot(filePath) {
     let text;
     try {
-        text = fs.readFileSync(filePath, "utf-8");
+        text = await fs.promises.readFile(filePath, "utf-8");
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/src/cli/helpers/cleanup.d.ts

@@ -1,3 +1,5 @@
 import type { CleanupLedgerEntry } from "../../utils/cleanup-ledger.js";
 export declare function projectArg(projectKey: string | undefined): string[];
+/** Input field that identifies the created object, when the result does not. */
+export declare function cleanupInputIdentifierField(resource: string, action: string): string | undefined;
 export declare function cleanupLedgerEntry(resource: string, action: string, args: string[], flags: Record<string, string | boolean>, result: unknown, projectKey: string | undefined): CleanupLedgerEntry | undefined;

package/dist/src/cli/helpers/cleanup.js

@@ -35,6 +35,30 @@ function createInputFromFlags(flags) {
         return undefined;
     }
 }
+/**
+ * Creates whose DSS response carries no identifier: the cleanup ledger pins the
+ * created object from this field of the `--data`/`--data-file` input instead.
+ * `--stdin` cannot be replayed, so the CLI rejects it with `--record-cleanup`
+ * before mutating.
+ */
+const CLEANUP_INPUT_IDENTIFIER_FIELDS = {
+    "workspace.create": "workspaceKey",
+    "connection.create": "name",
+    "user.create": "login",
+    "group.create": "name",
+};
+/** Input field that identifies the created object, when the result does not. */
+export function cleanupInputIdentifierField(resource, action) {
+    return CLEANUP_INPUT_IDENTIFIER_FIELDS[`${resource}.${action}`];
+}
+function inputIdentifier(resource, action, flags) {
+    const field = cleanupInputIdentifierField(resource, action);
+    if (!field)
+        return undefined;
+    const input = resultRecord(createInputFromFlags(flags));
+    const identifier = stringField(input, [field,]);
+    return identifier ? { identifier, input, } : undefined;
+}
 export function cleanupLedgerEntry(resource, action, args, flags, result, projectKey) {
     const record = resultRecord(result);
     // A notebook save is ledger-eligible only when it created the notebook:
@@ -77,6 +101,22 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["dataset", "delete", name, "--if-exists", ...withProject,], },
             };
         }
+        case "dataset.create-managed": {
+            // The handler returns `created` as the dataset name and the project
+            // DSS created it in, which wins over the requested project key.
+            const name = stringField(record, ["created", "name",]) ?? flags["name"];
+            if (!name)
+                return undefined;
+            const landedProject = stringField(record, ["projectKey",]) ?? project;
+            return {
+                ...base,
+                ...(landedProject ? { projectKey: landedProject, } : {}),
+                name,
+                cleanup: {
+                    argv: ["dataset", "delete", name, "--if-exists", ...projectArg(landedProject),],
+                },
+            };
+        }
         case "recipe.create": {
             const name = stringField(record, ["created", "recipeName", "name",])
                 ?? flags["name"];
@@ -199,6 +239,78 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["ml-task", "delete", analysisId, taskId, ...withProject,], },
             };
         }
+        case "ml-task.create-for-dataset": {
+            // This create opens a new visual analysis around the task, so cleanup
+            // removes the whole analysis rather than leaving an empty one behind.
+            const analysisId = stringField(record, ["analysisId",]);
+            if (!analysisId)
+                return undefined;
+            return {
+                ...base,
+                id: analysisId,
+                cleanup: { argv: ["analysis", "delete", analysisId, "--if-exists", ...withProject,], },
+            };
+        }
+        case "saved-model.create-external": {
+            const id = stringField(record, ["id",]);
+            if (!id)
+                return undefined;
+            const landedProject = stringField(record, ["projectKey",]) ?? project;
+            return {
+                ...base,
+                ...(landedProject ? { projectKey: landedProject, } : {}),
+                id,
+                name: args[0],
+                cleanup: {
+                    argv: ["saved-model", "delete", id, "--if-exists", ...projectArg(landedProject),],
+                },
+            };
+        }
+        case "project-folder.create-child": {
+            // `created` falls back to the requested name when DSS omits the id,
+            // and a name cannot address a folder delete: only `id` pins it.
+            const id = stringField(record, ["id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["project-folder", "delete", id, "--if-exists",], },
+            };
+        }
+        case "data-collection.create": {
+            const id = stringField(record, ["id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                cleanup: { argv: ["data-collection", "delete", id,], },
+            };
+        }
+        case "plugin.create-dev": {
+            const id = stringField(record, ["created",]) ?? args[0];
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                cleanup: { argv: ["plugin", "delete", id,], },
+            };
+        }
+        case "connection.create":
+        case "user.create":
+        case "group.create": {
+            const pinned = inputIdentifier(resource, action, flags);
+            if (!pinned)
+                return undefined;
+            return {
+                ...base,
+                name: pinned.identifier,
+                cleanup: { argv: [resource, "delete", pinned.identifier, "--if-exists",], },
+            };
+        }
         case "data-quality.create-rule": {
             const ruleId = stringField(record, ["id", "created",]);
             if (!ruleId)
@@ -222,8 +334,11 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["code-env", "delete", lang, name, "--if-exists",], },
             };
         }
-        case "streaming-endpoint.create": {
-            const id = args[0];
+        case "streaming-endpoint.create":
+        case "streaming-endpoint.create-managed": {
+            const id = stringField(record, ["created",]) ?? args[0];
+            if (!id)
+                return undefined;
             return {
                 ...base,
                 id,
@@ -240,15 +355,14 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
             };
         }
         case "workspace.create": {
-            const input = resultRecord(createInputFromFlags(flags));
-            const workspaceKey = stringField(input, ["workspaceKey",]);
-            if (!workspaceKey)
+            const pinned = inputIdentifier(resource, action, flags);
+            if (!pinned)
                 return undefined;
             return {
                 ...base,
-                id: workspaceKey,
-                name: stringField(input, ["displayName",]),
-                cleanup: { argv: ["workspace", "delete", workspaceKey,], },
+                id: pinned.identifier,
+                name: stringField(pinned.input, ["displayName",]),
+                cleanup: { argv: ["workspace", "delete", pinned.identifier,], },
             };
         }
         case "project-library.create-file":

package/dist/src/cli/helpers/flow-zone.d.ts

@@ -56,7 +56,7 @@ export declare function dedupeFlowZonePlanItems(items: FlowZoneItemInput[]): Flo
 export declare function flowZonePlanItemKeys(plan: FlowZoneOrganizePlan): Set<string>;
 export declare function validateUniqueFlowZoneAssignments(plan: FlowZoneOrganizePlan): void;
 export declare function parseFlowZoneOrganizePlan(input: Record<string, unknown>): FlowZoneOrganizePlan;
-export declare function readFlowZoneOrganizePlan(flags: Record<string, string | boolean>, usage: string): FlowZoneOrganizePlan;
+export declare function readFlowZoneOrganizePlan(flags: Record<string, string | boolean>, usage: string): Promise<FlowZoneOrganizePlan>;
 export declare function findFlowZoneForPlan(zones: FlowZone[], plan: FlowZoneOrganizeZonePlan): FlowZone | undefined;
 export declare function ensureFlowZonePlanTarget(plan: FlowZoneOrganizeZonePlan, existing: FlowZone | undefined): void;
 export declare function flowZoneExplicitItems(zone: FlowZone): FlowZoneItemInput[];

package/dist/src/cli/helpers/flow-zone.js

@@ -1,8 +1,7 @@
-import { readFileSync, } from "node:fs";
 import { ClientValidationError, } from "../../errors.js";
 import { asRecord, } from "../../utils/records.js";
 import { compareStrings, } from "../../utils/stable-hash.js";
-import { finiteNumberField, jsonInput, optionalStringField, parseJsonObject, requiredStringArray, splitCsvFlag, } from "../coerce.js";
+import { finiteNumberField, jsonInput, optionalStringField, parseJsonObject, readTextFile, requiredStringArray, splitCsvFlag, } from "../coerce.js";
 import { commandUsage, } from "../syntax.js";
 import { UsageError, } from "../usage.js";
 export function flowZoneId(value) {
@@ -257,9 +256,9 @@ export function parseFlowZoneOrganizePlan(input) {
     validateUniqueFlowZoneAssignments(plan);
     return plan;
 }
-export function readFlowZoneOrganizePlan(flags, usage) {
+export async function readFlowZoneOrganizePlan(flags, usage) {
     const data = typeof flags["file"] === "string"
-        ? parseJsonObject(readFileSync(flags["file"], "utf-8"), flags["file"])
+        ? parseJsonObject(await readTextFile(flags["file"]), flags["file"])
         : jsonInput(flags);
     if (!data) {
         throw new UsageError(`--data, --data-file, --file, or --stdin is required. Usage: ${usage}`, "missing_required_flag");

package/dist/src/cli/list-output.d.ts

@@ -1,3 +1,7 @@
+import { type CompactListField } from "./list-shapes.js";
+type Item = Record<string, unknown>;
+/** One compact field of a DSS list item, as `RESOURCE.list` prints it. */
+export declare function compactValue(item: Item, spec: CompactListField): unknown;
 /**
  * Shape a `*.list` result for agents: `--contains` filters on identifier
  * fields, `--limit` caps the count (a `list_truncated` warning reports the
@@ -5,3 +9,4 @@
  * `--full` or `--fields` asks for the DSS objects.
  */
 export declare function shapeListResult(resource: string, result: unknown, flags: Record<string, string | boolean>): unknown;
+export {};

package/dist/src/cli/list-output.js

@@ -4,10 +4,19 @@ import { enqueueCliWarning, } from "./output.js";
 function record(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function compactValue(item, spec) {
+function valueAt(item, path) {
     let value = item;
-    for (const key of spec.path.split("."))
+    for (const key of path.split("."))
         value = record(value)[key];
+    return value;
+}
+/** One compact field of a DSS list item, as `RESOURCE.list` prints it. */
+export function compactValue(item, spec) {
+    const value = valueAt(item, spec.path);
+    if (value === undefined && spec.fallback
+        && valueAt(item, spec.fallback.when) === spec.fallback.equals) {
+        return spec.fallback.value;
+    }
     if (spec.roleRefs !== true)
         return value;
     // Dataset refs across every role of recipe inputs/outputs (`{main:{items:[{ref}]}}`).

package/dist/src/cli/list-shapes.d.ts

@@ -9,6 +9,12 @@ export interface CompactListField {
     path: string;
     /** Flatten recipe roles (`{main:{items:[{ref}]}}`) to the dataset refs. */
     roleRefs?: true;
+    /** Value when `path` is absent and the item's `when` path equals `equals`. */
+    fallback?: {
+        when: string;
+        equals: unknown;
+        value: unknown;
+    };
     schema: Record<string, unknown>;
 }
 /**

package/dist/src/cli/list-shapes.js

@@ -51,7 +51,12 @@ export const COMPACT_LIST_FIELDS = {
         id: field("def.id", STRING),
         name: field("def.name", STRING),
         type: field("def.type", STRING),
-        state: field("state", STRING),
+        // DSS lists in-progress jobs with `stableState: false` and no `state`
+        // (COMPUTING_DEPS or RUNNING); `job get` reports the exact phase.
+        state: {
+            ...field("state", STRING),
+            fallback: { when: "stableState", equals: false, value: "RUNNING", },
+        },
         startTime: field("startTime", NUMBER),
         endTime: field("endTime", NUMBER),
     },
@@ -83,6 +88,7 @@ export const COMPACT_LIST_FIELDS = {
         id: field("id", STRING),
         version: field("version", STRING),
         label: field("meta.label", STRING),
+        isDev: field("isDev", BOOLEAN),
     },
     macro: {
         runnableType: field("runnableType", STRING),

package/dist/src/cli/output-schemas.d.ts

@@ -3,7 +3,7 @@
  * the single source of truth for `src/generated/action-output-schemas.json`,
  * which discovery reads as plain data so no TypeBox schema graph loads on the
  * discovery path. Regenerate with
- * `bun scripts/generate-action-output-schemas.mjs`; `bun run check` fails when
+ * `bun scripts/generate-action-output-schemas.mjs`; `bun run verify` fails when
  * the generated file is stale. SDK validation keeps using the TypeBox schema
  * objects from `packages/types` directly and never depends on the generated file.
  */

package/dist/src/cli/output-schemas.js

@@ -72,7 +72,7 @@ let commandOutputSchemas;
  * the single source of truth for `src/generated/action-output-schemas.json`,
  * which discovery reads as plain data so no TypeBox schema graph loads on the
  * discovery path. Regenerate with
- * `bun scripts/generate-action-output-schemas.mjs`; `bun run check` fails when
+ * `bun scripts/generate-action-output-schemas.mjs`; `bun run verify` fails when
  * the generated file is stale. SDK validation keeps using the TypeBox schema
  * objects from `packages/types` directly and never depends on the generated file.
  */

package/dist/src/cli/output.d.ts

@@ -11,6 +11,8 @@ export declare function pickResultFields(item: unknown, fields: string[]): unkno
  * that are absent become null so every row keeps a stable, predictable shape.
  */
 export declare function projectResultFields(result: unknown, fields: string[], availableFieldNames?: () => string[]): unknown;
+/** One JSON value plus newline for stdout; indented when `DSS_PRETTY=1`. */
+export declare function stdoutJson(value: unknown): string;
 export declare function writeCommandResult(result: unknown): void;
 export declare function addTransientTargetContext(error: unknown, target: string, elapsedMs: number): never;
 export declare function isFailedWaitResult(result: unknown): boolean;

package/dist/src/cli/output.js

@@ -1,4 +1,5 @@
 import { DataikuError, } from "../errors.js";
+import { prettyOutputEnabled, } from "./env.js";
 let outputFieldProjection;
 export function setOutputFieldProjection(fields) {
     outputFieldProjection = fields;
@@ -98,12 +99,16 @@ export function projectResultFields(result, fields, availableFieldNames) {
         return result.map((item) => pickResultFields(item, fields));
     return pickResultFields(result, fields);
 }
+/** One JSON value plus newline for stdout; indented when `DSS_PRETTY=1`. */
+export function stdoutJson(value) {
+    return `${JSON.stringify(value, null, prettyOutputEnabled() ? 2 : undefined)}\n`;
+}
 export function writeCommandResult(result) {
     const projected = outputFieldProjection
         ? projectResultFields(result, outputFieldProjection)
         : result;
     flushCliWarnings();
-    process.stdout.write(`${JSON.stringify(projected ?? { ok: true, })}\n`);
+    process.stdout.write(stdoutJson(projected ?? { ok: true, }));
 }
 export function addTransientTargetContext(error, target, elapsedMs) {
     if (error instanceof DataikuError && error.category === "transient") {
@@ -193,13 +198,35 @@ export function commandFailureMessage(result) {
             if (typeof message === "string" && message.length > 0)
                 return message;
         }
+        if (record.timedOut === true && typeof record.jobId === "string"
+            && typeof record.progress === "object" && typeof record.state === "string") {
+            // A job wait result: the timeout only stopped polling, the DSS job is
+            // still running (and was not cancelled).
+            const resume = typeof record.resume === "string" ? ` Resume with: ${record.resume}` : "";
+            return `Timed out waiting for job ${record.jobId} after ${record.elapsedMs}ms (last known state: ${record.state}); the job is still running in DSS and was not cancelled.${resume}`;
+        }
+        if (record.timedOut === true) {
+            // ML training, scenario runs, futures, code run: the client stopped waiting. Only a
+            // result that says `cancelled: false` proves nothing was stopped; `code run` cleans up
+            // its throwaway scenario, so its `cleanup` status is what tells.
+            const known = typeof record.state === "string"
+                ? record.state
+                : typeof record.outcome === "string"
+                    ? record.outcome
+                    : undefined;
+            const elapsed = typeof record.elapsedMs === "number" ? ` after ${record.elapsedMs}ms` : "";
+            const after = record.cancelled === false
+                ? "the operation was not cancelled and may still be running in DSS."
+                : record.cleanup !== undefined
+                    ? "the client stopped waiting; see `cleanup` for what happened to the run."
+                    : "the client stopped waiting; the operation may still be running in DSS.";
+            return `Timed out waiting${elapsed}${known ? ` (last known state: ${known})` : ""}; ${after}`;
+        }
         const state = typeof record.state === "string"
             ? record.state
             : typeof record.outcome === "string"
                 ? record.outcome
-                : typeof record.timedOut === "boolean"
-                    ? "timed out"
-                    : undefined;
+                : undefined;
         return `Command completed with failed long-running result${state ? `: ${state}` : ""}.`;
     }
     if (isAssertionFailureResult(result)) {

package/dist/src/cli/read-shapes.js

@@ -32,6 +32,28 @@ export function compactReadOutputSchemas() {
         additionalProperties: false,
         properties: { type: STRING, message: STRING, },
     };
+    const triggerSchema = {
+        type: "object",
+        additionalProperties: false,
+        properties: { type: STRING, name: STRING, },
+    };
+    const failureSchema = {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            stepId: STRING,
+            jobId: STRING,
+            dataset: STRING,
+            recipe: STRING,
+            inputs: { type: "array", items: { type: "string", }, },
+            message: STRING,
+        },
+    };
+    const nextSchema = {
+        type: "array",
+        description: "Next commands to run, each as an argv array.",
+        items: { type: "array", items: STRING, },
+    };
     return {
         "job.get": {
             type: "object",
@@ -110,5 +132,73 @@ export function compactReadOutputSchemas() {
                 lastModifiedBy: STRING,
             },
         },
+        "scenario.get-run": {
+            type: "object",
+            additionalProperties: false,
+            required: ["runId", "steps",],
+            properties: {
+                runId: STRING,
+                scenarioId: STRING,
+                projectKey: STRING,
+                outcome: STRING,
+                start: NUMBER,
+                end: NUMBER,
+                durationMs: NUMBER,
+                trigger: triggerSchema,
+                steps: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            id: STRING,
+                            name: STRING,
+                            type: STRING,
+                            outcome: STRING,
+                            message: STRING,
+                            datasets: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    properties: { dataset: STRING, projectKey: STRING, partition: STRING, outcome: STRING, },
+                                },
+                            },
+                            jobs: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    properties: { jobId: STRING, outcome: STRING, message: STRING, },
+                                },
+                            },
+                        },
+                    },
+                },
+                failure: failureSchema,
+                next: nextSchema,
+                hint: {
+                    type: "string",
+                    description: "Edit-and-rerun commands when the failed recipe is known.",
+                },
+            },
+        },
+        "scenario.last-runs": {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["runId",],
+                properties: {
+                    runId: STRING,
+                    outcome: STRING,
+                    start: NUMBER,
+                    end: NUMBER,
+                    trigger: triggerSchema,
+                    failure: { type: "object", additionalProperties: false, properties: { message: STRING, }, },
+                    next: nextSchema,
+                },
+            },
+        },
     };
 }

package/dist/src/cli/result-shapes.d.ts

@@ -1,6 +1,24 @@
+type Item = Record<string, unknown>;
+/** The failed activity of a job: the recipe that failed and the datasets it read. */
+export interface FailedActivity {
+    recipe: string;
+    inputs: string[];
+}
+/**
+ * Failure diagnosis of a raw `scenario get-run` report: the first failure
+ * (`{ stepId, jobId, dataset, message }`) and the next command(s) to run as
+ * argv arrays. With the failed recipe known, `hint` names the edit-and-rerun
+ * loop, so the agent does not look up the write commands. Empty when the run did not fail.
+ */
+export declare function scenarioRunDiagnosis(details: unknown, activity?: FailedActivity): {
+    failure?: Item;
+    next?: string[][];
+    hint?: string;
+};
 /**
  * Compact a command result for agents: `*.list` items (filter, cap, compact
- * fields) and the four large read commands. `--full` and `--fields` bypass
+ * fields) and the large read commands. `--full` and `--fields` bypass
  * the read shapers so the DSS object (or a projection of it) is returned.
  */
 export declare function shapeCommandResult(resource: string, action: string, result: unknown, flags: Record<string, string | boolean>): unknown;
+export {};