dataiku-sdk 0.12.4 → 0.12.5

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

@@ -9,6 +9,10 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
     const record = resultRecord(result);
     if (record.skipped !== undefined)
         return undefined;
+    // Only an explicit `cleanupEligible:false` suppresses the ledger: absent or
+    // true (including indeterminate post-POST outcomes) must stay addressable.
+    if (record.cleanupEligible === false)
+        return undefined;
     const project = flags["project-key"] ?? projectKey;
     const withProject = projectArg(project);
     const ts = new Date().toISOString();
@@ -179,18 +183,6 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["code-env", "delete", lang, name, "--if-exists",], },
             };
         }
-        case "project.duplicate": {
-            const targetKey = args[1];
-            if (!targetKey)
-                return undefined;
-            return {
-                ts,
-                action,
-                resource,
-                name: targetKey,
-                cleanup: { argv: ["project", "delete", targetKey, "--drop-data",], },
-            };
-        }
         case "folder.upload":
             return {
                 ...base,
@@ -198,6 +190,48 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 path: args[1],
                 cleanup: { argv: ["folder", "delete-file", args[0], args[1], ...withProject,], },
             };
+        case "app.create-instance":
+        case "app.create-successor-instance": {
+            const targetKey = stringField(record, ["projectKey", "targetProjectKey",]);
+            if (!targetKey)
+                return undefined;
+            const nestedInstance = resultRecord(record.instance);
+            const futureId = stringField(record, ["futureId", "jobId",])
+                ?? stringField(nestedInstance, ["futureId", "jobId",]);
+            const projectIncarnationHash = stringField(record, ["projectIncarnationHash",]);
+            const boundIncarnation = projectIncarnationHash
+                && /^[0-9a-f]{64}$/.test(projectIncarnationHash)
+                ? projectIncarnationHash
+                : undefined;
+            // Cleanup can delete only the concrete project incarnation created by
+            // this lifecycle. A terminal future proves the requested key, but not
+            // that the same project still occupies that key at replay time.
+            const settled = record.futureTargetVerified === true;
+            const lifecycleArgs = !boundIncarnation || (!settled && !futureId)
+                ? ["--unconfirmed-creation",]
+                : futureId && !settled
+                    ? [
+                        "--future-id",
+                        futureId,
+                        "--expect-project-incarnation",
+                        boundIncarnation,
+                    ]
+                    : ["--expect-project-incarnation", boundIncarnation,];
+            return {
+                ...base,
+                projectKey: targetKey,
+                name: targetKey,
+                cleanup: {
+                    argv: [
+                        "app",
+                        "delete-instance",
+                        "--project-key",
+                        targetKey,
+                        ...lifecycleArgs,
+                    ],
+                },
+            };
+        }
         default:
             return undefined;
     }

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

@@ -1,4 +1,6 @@
 import type { DataikuClient } from "../client.js";
+import { type StableErrorCode } from "../errors.js";
+export declare function setCompactJsonOutput(compact: boolean): void;
 export declare function setOutputFieldProjection(fields: string[] | undefined): void;
 export declare function enqueueCliWarning(warning: Record<string, unknown>): void;
 export declare function pickResultFields(item: unknown, fields: string[]): unknown;
@@ -12,11 +14,20 @@ export declare function writeCommandResult(result: unknown): void;
 export declare function transientBodyWithTargetContext(body: string, target: string, elapsedMs: number): string;
 export declare function addTransientTargetContext(error: unknown, target: string, elapsedMs: number): never;
 export declare function isFailedWaitResult(result: unknown): boolean;
+export declare function isAssertionFailureResult(result: unknown): boolean;
 export declare function commandFailureExitCode(result: unknown): number | undefined;
+/**
+ * Stable error code for a command-level failure report. A failed synchronous
+ * assertion (exit 4) is a distinct outcome from a failed long-running remote
+ * operation (also exit 4), so agents must never see `long_running_failure`
+ * for a result that finished synchronously with `unchanged: false`.
+ */
+export declare function commandFailureCode(result: unknown, exitCode: number): StableErrorCode;
 export declare class CommandResultFailure extends Error {
     readonly result: unknown;
     readonly exitCode: number;
-    constructor(result: unknown, exitCode: number);
+    readonly code: StableErrorCode;
+    constructor(result: unknown, exitCode: number, code?: StableErrorCode);
 }
 export declare function commandFailureMessage(result: unknown): string;
 export declare function isNotFoundError(error: unknown): boolean;

package/dist/src/cli/output.js

@@ -1,5 +1,9 @@
 import { DataikuError, } from "../errors.js";
 let outputFieldProjection;
+let compactJsonOutput = false;
+export function setCompactJsonOutput(compact) {
+    compactJsonOutput = compact;
+}
 export function setOutputFieldProjection(fields) {
     outputFieldProjection = fields;
 }
@@ -53,7 +57,7 @@ export function writeCommandResult(result) {
     const projected = outputFieldProjection
         ? projectResultFields(result, outputFieldProjection)
         : result;
-    process.stdout.write(`${JSON.stringify(projected ?? { ok: true, }, null, 2)}\n`);
+    process.stdout.write(`${JSON.stringify(projected ?? { ok: true, }, null, compactJsonOutput ? undefined : 2)}\n`);
 }
 export function transientBodyWithTargetContext(body, target, elapsedMs) {
     try {
@@ -86,21 +90,61 @@ export function isFailedWaitResult(result) {
         && typeof record.pollCount === "number"
         && (typeof record.state === "string" || typeof record.outcome === "string");
 }
+export function isAssertionFailureResult(result) {
+    return result !== null
+        && typeof result === "object"
+        && !Array.isArray(result)
+        && result.unchanged === false;
+}
+function isNestedAssertionFailureResult(result) {
+    if (result === null || typeof result !== "object" || Array.isArray(result))
+        return false;
+    const steps = result.steps;
+    if (!Array.isArray(steps))
+        return false;
+    for (const step of steps) {
+        if (step === null || typeof step !== "object" || Array.isArray(step))
+            continue;
+        const stepRecord = step;
+        if (stepRecord.ok !== false)
+            continue;
+        const error = stepRecord.error;
+        return error !== null
+            && typeof error === "object"
+            && !Array.isArray(error)
+            && error.code === "assertion_failed";
+    }
+    return false;
+}
 export function commandFailureExitCode(result) {
-    if (isFailedWaitResult(result))
-        return 4;
-    if (result && typeof result === "object" && result.unchanged === false)
+    if (isFailedWaitResult(result) || isAssertionFailureResult(result))
         return 4;
     return undefined;
 }
+/**
+ * Stable error code for a command-level failure report. A failed synchronous
+ * assertion (exit 4) is a distinct outcome from a failed long-running remote
+ * operation (also exit 4), so agents must never see `long_running_failure`
+ * for a result that finished synchronously with `unchanged: false`.
+ */
+export function commandFailureCode(result, exitCode) {
+    if (isAssertionFailureResult(result) || isNestedAssertionFailureResult(result)) {
+        return "assertion_failed";
+    }
+    if (isFailedWaitResult(result))
+        return "long_running_failure";
+    return exitCode === 4 ? "long_running_failure" : "command_result_failure";
+}
 export class CommandResultFailure extends Error {
     result;
     exitCode;
-    constructor(result, exitCode) {
+    code;
+    constructor(result, exitCode, code) {
         super(commandFailureMessage(result));
         this.name = "CommandResultFailure";
         this.result = result;
         this.exitCode = exitCode;
+        this.code = code ?? commandFailureCode(result, exitCode);
     }
 }
 export function commandFailureMessage(result) {
@@ -109,9 +153,12 @@ export function commandFailureMessage(result) {
         const state = typeof record.state === "string" ? record.state : record.outcome;
         return `Command completed with failed long-running result${state ? `: ${state}` : ""}.`;
     }
-    if (result && typeof result === "object" && result.unchanged === false) {
+    if (isAssertionFailureResult(result)) {
         return "Command completed with failed assertion result.";
     }
+    if (isNestedAssertionFailureResult(result)) {
+        return "Command completed with nested failed assertion result.";
+    }
     return "Command completed with failed result.";
 }
 export function isNotFoundError(error) {

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

@@ -6,7 +6,7 @@ export declare class UsageError extends Error {
     readonly details?: Record<string, unknown>;
     constructor(message: string, code?: StableErrorCode, hint?: string, details?: Record<string, unknown>);
 }
-export declare const COMMANDS_RUN_HINT = "Use `dss commands run` for machine-readable command discovery.";
+export declare const COMMANDS_RUN_HINT = "Use `dss commands run --fields RESOURCE.ACTION --json` for scoped, compact command discovery; omit --fields only when you need the full registry.";
 export declare function unsupportedHelpFlag(): UsageError;
 export declare function noCommandError(): UsageError;
 export declare function missingActionError(resource: string, validActions: string[], usage?: string): UsageError;

package/dist/src/cli/usage.js

@@ -1,6 +1,7 @@
 export const RESOURCE_NAMES = [
-    "project",
+    "agent",
     "app",
+    "batch",
     "business-app",
     "webapp",
     "api-service",
@@ -42,6 +43,8 @@ export const RESOURCE_NAMES = [
     "commands",
     "fixtures",
     "install-skill",
+    "project",
+    "version",
 ]
     .sort();
 export class UsageError extends Error {
@@ -56,7 +59,7 @@ export class UsageError extends Error {
         this.details = details;
     }
 }
-export const COMMANDS_RUN_HINT = "Use `dss commands run` for machine-readable command discovery.";
+export const COMMANDS_RUN_HINT = "Use `dss commands run --fields RESOURCE.ACTION --json` for scoped, compact command discovery; omit --fields only when you need the full registry.";
 export function unsupportedHelpFlag() {
     return new UsageError("Help screens are not supported.", "usage_error", COMMANDS_RUN_HINT, { command: "dss commands run", });
 }