dataiku-sdk 0.12.7 → 1.1.0

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

@@ -38,6 +38,7 @@ export interface FixtureDiscoveryResult {
 export interface DoctorEnvironment {
     projectKey?: string;
     dssVersion?: string;
+    dssApiVersion?: string;
     instanceTime?: string;
     integrationFlags: {
         mutating: boolean;
@@ -48,6 +49,15 @@ export interface DoctorEnvironment {
         apiServices: boolean;
     };
 }
+/**
+ * Server provenance captured from documented response headers on the public
+ * project-list connectivity call. Null entries mean the header was absent.
+ */
+export interface DoctorVersionInfo {
+    dssVersion: string | null;
+    dssApiVersion: string | null;
+    instanceTime: string | null;
+}
 export interface DoctorResult {
     ok: boolean;
     checks: DoctorCheck[];
@@ -66,7 +76,7 @@ export interface DoctorResult {
 export declare function errorDetails(error: unknown): Record<string, unknown>;
 export declare function firstStringField(items: unknown[] | undefined, fields: string[]): string | null;
 export declare function integrationFlag(name: string): boolean;
-export declare function doctorEnvironment(projectKey?: string): DoctorEnvironment;
+export declare function doctorEnvironment(projectKey?: string, versionInfo?: DoctorVersionInfo): DoctorEnvironment;
 export declare function permissionStatusForError(error: unknown): PermissionStatus;
 export declare function probeDoctorPermission(probe: () => Promise<unknown>): Promise<{
     status: PermissionStatus;
@@ -96,7 +106,7 @@ export declare function firstSafeJupyterNotebook(items: unknown[]): {
     unsafe: FixtureReject[];
 };
 export declare function discoverFixtureReport(client: DataikuClient, projectKey: string, flags: Record<string, string | boolean>): Promise<FixtureDiscoveryResult>;
-export declare function doctorCapabilities(client: DataikuClient, projectKey: string | undefined, accessibleProjects: unknown[] | undefined, flags: Record<string, string | boolean>): Promise<Pick<DoctorResult, "permissions" | "permissionDetails" | "fixtures" | "environment">>;
+export declare function doctorCapabilities(client: DataikuClient, projectKey: string | undefined, accessibleProjects: unknown[] | undefined, flags: Record<string, string | boolean>, versionInfo?: DoctorVersionInfo): Promise<Pick<DoctorResult, "permissions" | "permissionDetails" | "fixtures" | "environment">>;
 export declare function runDoctor(flags: Record<string, string | boolean>): Promise<{
     result: DoctorResult;
     exitCode: number;

package/dist/src/cli/doctor.js

@@ -1,5 +1,6 @@
 import { DataikuClient, } from "../client.js";
 import { DataikuError, } from "../errors.js";
+import { ProjectSummaryArraySchema, safeParseSchema, } from "../schemas.js";
 import { num, splitCsvFlag, stringField, } from "./coerce.js";
 import { currentCommandContext, resolveCredentials, } from "./runtime.js";
 import { UsageError, } from "./usage.js";
@@ -31,9 +32,12 @@ export function integrationFlag(name) {
     const value = process.env[name];
     return value === "1" || value?.toLowerCase() === "true";
 }
-export function doctorEnvironment(projectKey) {
+export function doctorEnvironment(projectKey, versionInfo) {
     return {
         ...(projectKey ? { projectKey, } : {}),
+        ...(versionInfo?.dssVersion ? { dssVersion: versionInfo.dssVersion, } : {}),
+        ...(versionInfo?.dssApiVersion ? { dssApiVersion: versionInfo.dssApiVersion, } : {}),
+        ...(versionInfo?.instanceTime ? { instanceTime: versionInfo.instanceTime, } : {}),
         integrationFlags: {
             mutating: integrationFlag("RUN_DATAIKU_INTEGRATION_MUTATING"),
             adminMutating: integrationFlag("RUN_DATAIKU_ADMIN_MUTATING"),
@@ -174,7 +178,7 @@ export async function discoverFixtureReport(client, projectKey, flags) {
         },
     };
 }
-export async function doctorCapabilities(client, projectKey, accessibleProjects, flags) {
+export async function doctorCapabilities(client, projectKey, accessibleProjects, flags, versionInfo) {
     const probeProjectKey = projectKey ?? firstStringField(accessibleProjects, ["projectKey",])
         ?? undefined;
     const probes = {
@@ -210,7 +214,7 @@ export async function doctorCapabilities(client, projectKey, accessibleProjects,
     const capabilityResult = {
         permissions,
         ...(Object.keys(permissionDetails).length > 0 ? { permissionDetails, } : {}),
-        environment: doctorEnvironment(projectKey),
+        environment: doctorEnvironment(projectKey, versionInfo),
     };
     if (flags["fast"] !== true && probeProjectKey) {
         try {
@@ -255,9 +259,10 @@ export async function runDoctor(flags) {
             : "Missing Dataiku URL and/or API key. Set DATAIKU_URL/DATAIKU_API_KEY or pass --url/--api-key.",
     });
     let accessibleProjects;
+    let environmentVersion;
     if (credentialsOk) {
-        const requestTimeoutMs = num(flags["request-timeout"]);
-        const retryMaxAttempts = num(flags["retries"]);
+        const requestTimeoutMs = num(flags["request-timeout"], "--request-timeout");
+        const retryMaxAttempts = num(flags["retries"], "--retries");
         const client = new DataikuClient({
             url,
             apiKey,
@@ -269,14 +274,40 @@ export async function runDoctor(flags) {
             caCertPath,
         });
         try {
-            const projects = await client.projects.list();
-            accessibleProjects = projects;
-            checks.push({
-                name: "connectivity",
-                ok: true,
-                message: "Connected to DSS and listed accessible projects.",
-                details: { projectCount: projects.length, },
-            });
+            const projects = await client.getWithMetadata("/public/api/projects/");
+            // Documented headers on the public project-list call populate the
+            // optional environment fields; absent headers stay absent. Header
+            // provenance is independent of the body being well-formed.
+            environmentVersion = {
+                dssVersion: projects.meta.dssVersion,
+                dssApiVersion: projects.meta.dssApiVersion,
+                instanceTime: projects.meta.date,
+            };
+            // A reachable endpoint that answers with something other than a
+            // project list is not working connectivity: the body never becomes
+            // capability input, so probes cannot iterate a non-array.
+            const parsed = safeParseSchema(ProjectSummaryArraySchema, projects.data);
+            if (parsed.success) {
+                accessibleProjects = parsed.data;
+                checks.push({
+                    name: "connectivity",
+                    ok: true,
+                    message: "Connected to DSS and listed accessible projects.",
+                    details: { projectCount: parsed.data.length, },
+                });
+            }
+            else {
+                checks.push({
+                    name: "connectivity",
+                    ok: false,
+                    message: "Connected to DSS but the project list response was not a project list.",
+                    details: {
+                        reason: "invalid_project_list",
+                        errorCount: parsed.errors.length,
+                        errors: parsed.errors.slice(0, 5),
+                    },
+                });
+            }
         }
         catch (error) {
             checks.push({
@@ -311,8 +342,8 @@ export async function runDoctor(flags) {
     }
     const result = { ok: checks.every((check) => check.ok), checks, context, };
     if (flags["capabilities"] === true && credentialsOk) {
-        const requestTimeoutMs = num(flags["request-timeout"]);
-        const retryMaxAttempts = num(flags["retries"]) ?? 1;
+        const requestTimeoutMs = num(flags["request-timeout"], "--request-timeout");
+        const retryMaxAttempts = num(flags["retries"], "--retries") ?? 1;
         const client = new DataikuClient({
             url,
             apiKey,
@@ -323,8 +354,8 @@ export async function runDoctor(flags) {
             tlsRejectUnauthorized,
             caCertPath,
         });
-        result.environment = doctorEnvironment(projectKey);
-        Object.assign(result, await doctorCapabilities(client, projectKey, accessibleProjects, flags));
+        result.environment = doctorEnvironment(projectKey, environmentVersion);
+        Object.assign(result, await doctorCapabilities(client, projectKey, accessibleProjects, flags, environmentVersion));
     }
     return { result, exitCode: result.ok ? 0 : 2, };
 }
@@ -340,8 +371,8 @@ export async function runFixtures(flags) {
         throw new UsageError("Missing project key. Set DATAIKU_PROJECT_KEY or pass --project-key.", "missing_required_flag");
     }
     currentCommandContext.projectKey = projectKey;
-    const requestTimeoutMs = num(flags["request-timeout"]);
-    const retryMaxAttempts = num(flags["retries"]) ?? 1;
+    const requestTimeoutMs = num(flags["request-timeout"], "--request-timeout");
+    const retryMaxAttempts = num(flags["retries"], "--retries") ?? 1;
     const client = new DataikuClient({
         url,
         apiKey,

package/dist/src/cli/flags.js

@@ -7,7 +7,6 @@ export const BOOLEAN_FLAGS = new Set([
     "global",
     "list-agents",
     "include-raw",
-    "raw",
     "include-payload",
     "no-payload",
     "include-logs",
@@ -22,7 +21,6 @@ export const BOOLEAN_FLAGS = new Set([
     "wait",
     "if-not-exists",
     "if-exists",
-    "json",
     "no-wait",
     "force-rebuild",
     "latest",
@@ -40,6 +38,14 @@ export const BOOLEAN_FLAGS = new Set([
     "drop-data",
     "normalize",
     "unconfirmed-creation",
+    "remote",
+    "duplicate-project",
+    "delete-remotely",
+    "force-delete",
+    "i-know-what-i-am-doing",
+    "no-add-to-python-path",
+    "delete-directory",
+    "peek",
 ]);
 export const SHORT_FLAGS = {
     v: "verbose",
@@ -71,26 +77,32 @@ export const VALUE_FLAGS = new Set([
     "backup-dir",
     "backend-type",
     "backup",
+    "branch",
     "ca-cert",
     "catalog",
+    "checkout",
     "cell-id",
     "allow-types",
     "color",
+    "commit",
     "connection",
     "contains",
     "content",
     "content-type",
+    "count",
     "data",
     "active",
     "deployment-mode",
     "env-version",
     "expect-hash",
     "expect-project-incarnation",
+    "expected",
     "expect-version",
     "data-file",
     "database",
     "dataset",
     "file",
+    "file-name",
     "file-type",
     "env",
     "install-core-packages",
@@ -110,6 +122,7 @@ export const VALUE_FLAGS = new Set([
     "package",
     "packages",
     "local",
+    "login",
     "manifest-version",
     "max-edges",
     "max-lines",
@@ -120,6 +133,7 @@ export const VALUE_FLAGS = new Set([
     "max-rows",
     "limit",
     "max-timestamp",
+    "message",
     "only-monitored",
     "min-timestamp",
     "mode",
@@ -140,12 +154,16 @@ export const VALUE_FLAGS = new Set([
     "partition",
     "parent",
     "path",
+    "path-in-repository",
     "preview",
     "prediction-type",
     "project-key",
     "recipe",
+    "reference",
+    "repository",
     "request-timeout",
     "params",
+    "password-env",
     "results-per-page",
     "record-cleanup",
     "rule-id",
@@ -164,11 +182,14 @@ export const VALUE_FLAGS = new Set([
     "sql",
     "schema",
     "sql-file",
+    "start-commit",
     "start-retries",
     "standard",
     "state",
     "streaming-endpoint",
     "target",
+    "target-project-folder-id",
+    "target-project-key",
     "task-type",
     "test-dataset",
     "train-dataset",

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

@@ -4,7 +4,7 @@ export function projectArg(projectKey) {
 }
 export function cleanupLedgerEntry(resource, action, args, flags, result, projectKey) {
     if (!(action.startsWith("create") || action === "clone" || action === "duplicate"
-        || action === "upload"))
+        || action === "import" || action === "upload"))
         return undefined;
     const record = resultRecord(result);
     if (record.skipped !== undefined)
@@ -190,6 +190,35 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 path: args[1],
                 cleanup: { argv: ["folder", "delete-file", args[0], args[1], ...withProject,], },
             };
+        case "project.import": {
+            const usedProjectKey = stringField(record, ["usedProjectKey",]);
+            const recordedIncarnation = stringField(record, ["projectIncarnationHash",]);
+            const boundIncarnation = recordedIncarnation
+                && /^[0-9a-f]{64}$/.test(recordedIncarnation)
+                ? recordedIncarnation
+                : undefined;
+            // Only a verified success may produce a cleanup entry, and it must
+            // bind the concrete landed project incarnation: replaying an
+            // unbound delete could remove a replacement project that reused the
+            // key. Never emit legacy/unbound project entries.
+            if (!usedProjectKey || !boundIncarnation)
+                return undefined;
+            return {
+                ...base,
+                projectKey: usedProjectKey,
+                name: usedProjectKey,
+                cleanup: {
+                    argv: [
+                        "project",
+                        "delete",
+                        usedProjectKey,
+                        "--if-exists",
+                        "--expect-project-incarnation",
+                        boundIncarnation,
+                    ],
+                },
+            };
+        }
         case "app.create-instance":
         case "app.create-successor-instance": {
             const targetKey = stringField(record, ["projectKey", "targetProjectKey",]);

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

@@ -6,7 +6,7 @@ export function datasetSourceSummary(details) {
         projectKey: details.projectKey,
         type: details.type,
         managed: details.managed,
-        connection: params.connection,
+        connection: params.connection ?? params.uploadConnection,
         catalog: params.catalog,
         schema: params.schema,
         table: params.table,

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

@@ -1,8 +1,9 @@
 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;
+/** Emit queued warnings as one JSONL warning event on stderr. Idempotent. */
+export declare function flushCliWarnings(): void;
 export declare function pickResultFields(item: unknown, fields: string[]): unknown;
 /**
  * Project the top-level fields callers asked for via --fields. Arrays are mapped
@@ -20,7 +21,8 @@ export declare function commandFailureExitCode(result: unknown): number | undefi
  * 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`.
+ * for a result that finished synchronously with `unchanged: false` or
+ * `satisfied: false`.
  */
 export declare function commandFailureCode(result: unknown, exitCode: number): StableErrorCode;
 export declare class CommandResultFailure extends Error {
@@ -43,6 +45,7 @@ export declare function planResult(resource: string, action: string, options: {
     payload?: unknown;
     localWrites?: unknown;
     plannedAndDryRun?: boolean;
+    requests?: unknown;
     wait?: unknown;
 }): Record<string, unknown>;
 export declare function encodedProjectEndpoint(client: DataikuClient, projectKey: string | undefined, suffix: string): string;

package/dist/src/cli/output.js

@@ -1,9 +1,5 @@
 import { DataikuError, } from "../errors.js";
 let outputFieldProjection;
-let compactJsonOutput = false;
-export function setCompactJsonOutput(compact) {
-    compactJsonOutput = compact;
-}
 export function setOutputFieldProjection(fields) {
     outputFieldProjection = fields;
 }
@@ -17,7 +13,7 @@ export function enqueueCliWarning(warning) {
     pendingCliWarnings.push(warning);
 }
 /** Emit queued warnings as one JSONL warning event on stderr. Idempotent. */
-function flushCliWarnings() {
+export function flushCliWarnings() {
     if (pendingCliWarnings.length === 0)
         return;
     const warnings = pendingCliWarnings;
@@ -57,7 +53,7 @@ export function writeCommandResult(result) {
     const projected = outputFieldProjection
         ? projectResultFields(result, outputFieldProjection)
         : result;
-    process.stdout.write(`${JSON.stringify(projected ?? { ok: true, }, null, compactJsonOutput ? undefined : 2)}\n`);
+    process.stdout.write(`${JSON.stringify(projected ?? { ok: true, })}\n`);
 }
 export function transientBodyWithTargetContext(body, target, elapsedMs) {
     try {
@@ -91,10 +87,10 @@ export function isFailedWaitResult(result) {
         && (typeof record.state === "string" || typeof record.outcome === "string");
 }
 export function isAssertionFailureResult(result) {
-    return result !== null
-        && typeof result === "object"
-        && !Array.isArray(result)
-        && result.unchanged === false;
+    if (result === null || typeof result !== "object" || Array.isArray(result))
+        return false;
+    const record = result;
+    return record.unchanged === false || record.satisfied === false;
 }
 function isNestedAssertionFailureResult(result) {
     if (result === null || typeof result !== "object" || Array.isArray(result))
@@ -125,7 +121,8 @@ export function commandFailureExitCode(result) {
  * 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`.
+ * for a result that finished synchronously with `unchanged: false` or
+ * `satisfied: false`.
  */
 export function commandFailureCode(result, exitCode) {
     if (isAssertionFailureResult(result) || isNestedAssertionFailureResult(result)) {
@@ -154,7 +151,10 @@ export function commandFailureMessage(result) {
         return `Command completed with failed long-running result${state ? `: ${state}` : ""}.`;
     }
     if (isAssertionFailureResult(result)) {
-        return "Command completed with failed assertion result.";
+        const record = result;
+        return record.unchanged === false
+            ? "Command completed with failed assertion result."
+            : "Command completed with unsatisfied assertion result.";
     }
     if (isNestedAssertionFailureResult(result)) {
         return "Command completed with nested failed assertion result.";
@@ -192,6 +192,7 @@ export function planResult(resource, action, options) {
         ...(options.endpoint ? { endpoint: options.endpoint, } : {}),
         ...(options.payload !== undefined ? { payload: options.payload, } : {}),
         ...(options.localWrites !== undefined ? { localWrites: options.localWrites, } : {}),
+        ...(options.requests !== undefined ? { requests: options.requests, } : {}),
         ...(options.wait !== undefined ? { wait: options.wait, } : {}),
         idempotency: options.idempotency,
         async: options.asyncKind,

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

@@ -1,5 +1,6 @@
 import type { DataikuClient } from "../client.js";
 export type CommandHandler = (client: DataikuClient, args: string[], flags: Record<string, string | boolean>) => Promise<unknown>;
+export type LocalCommandHandler = (args: string[], flags: Record<string, string | boolean>) => Promise<unknown>;
 export interface CommandPayloadSchema {
     stdin?: boolean;
     dataFlag?: boolean;
@@ -19,6 +20,7 @@ export interface CommandRegistryOverride {
 }
 export interface CommandMeta extends CommandRegistryOverride {
     handler: CommandHandler;
+    localHandler?: LocalCommandHandler;
     usage: string;
     description?: string;
     examples?: string[];

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 --fields RESOURCE.ACTION --json` for scoped, compact command discovery; omit --fields only when you need the full registry.";
+export declare const COMMANDS_RUN_HINT = "Use `dss commands run --fields RESOURCE.ACTION` for scoped command discovery; use `dss commands run` for the action summary or `--output PATH` to export 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

@@ -8,6 +8,7 @@ export const RESOURCE_NAMES = [
     "api-deployer",
     "bundle",
     "project-deployer",
+    "project-git",
     "project-library",
     "streaming-endpoint",
     "continuous-activity",
@@ -59,7 +60,7 @@ export class UsageError extends Error {
         this.details = details;
     }
 }
-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 const COMMANDS_RUN_HINT = "Use `dss commands run --fields RESOURCE.ACTION` for scoped command discovery; use `dss commands run` for the action summary or `--output PATH` to export the full registry.";
 export function unsupportedHelpFlag() {
     return new UsageError("Help screens are not supported.", "usage_error", COMMANDS_RUN_HINT, { command: "dss commands run", });
 }

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

@@ -1,14 +1,56 @@
 export declare function findPackageRoot(): string | undefined;
 export declare function packageVersion(packageRoot: string | undefined): string;
 export declare function gitDirectory(packageRoot: string): string;
+export declare function isFullRevision(value: unknown): boolean;
+/**
+ * Full checkout HEAD revision (40-lowercase-hex) — the basis for staleness
+ * comparison. Resolution follows Git's own layouts: a detached revision, then
+ * loose refs in the worktree git dir, then the shared store reached through
+ * `commondir`, then packed-refs in each. Anything that is not a full
+ * lowercase hexadecimal revision is rejected.
+ */
+export declare function gitFullRevision(packageRoot: string | undefined): string | undefined;
 export declare function gitRevision(packageRoot: string | undefined): string | undefined;
+export type CliLoadSource = "source" | "dist";
+export type CliRuntime = "bun" | "node";
+export declare function detectLoadSource(modulePath?: string): CliLoadSource;
+export declare function buildMetadataRevision(packageRoot: string | undefined): string | undefined;
+/**
+ * Whether compiled CLI output predates any source input. The build metadata
+ * file is written after `tsc`, so its mtime is the build-completion marker.
+ * Installed packages omit `src/`; without both sides there is no drift claim.
+ */
+export declare function sourceTreeNewerThanBuild(packageRoot: string | undefined): boolean;
+/**
+ * CLI provenance payload. `source` distinguishes a source checkout run from a
+ * published dist run; `runtime` names the executing runtime. `buildRevision`
+ * is only ever claimed by a dist build that carries build metadata — source
+ * execution never claims one. `staleBuild` is true only when the running dist
+ * build revision differs from the checkout or a source input is newer than the
+ * build-completion marker.
+ */
+export interface CliVersionPayload {
+    version: string;
+    gitRevision: string | null;
+    source: CliLoadSource;
+    runtime: CliRuntime;
+    buildRevision: string | null;
+    staleBuild: boolean;
+}
+export declare function detectRuntime(): CliRuntime;
+export declare function buildVersionPayload(input: {
+    packageVersion: string;
+    checkoutRevision: string | undefined;
+    checkoutFullRevision: string | undefined;
+    loadSource: string | undefined;
+    buildRevision: string | undefined;
+    sourceNewerThanBuild?: boolean;
+    runtime: CliRuntime;
+}): CliVersionPayload;
 export declare const PACKAGE_ROOT: string | undefined;
 export declare const CLI_VERSION: string;
 export declare const CLI_GIT_REVISION: string | undefined;
-export declare const AGENT_CONTRACT_VERSION = 1;
+export declare const AGENT_CONTRACT_VERSION = 2;
 export declare const JSON_SCHEMA_DRAFT = "https://json-schema.org/draft/2020-12/schema";
-export declare const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v1.json";
-export declare function cliVersionResult(): {
-    version: string;
-    gitRevision: string | null;
-};
+export declare const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v2.json";
+export declare function cliVersionResult(): CliVersionPayload;