dataiku-sdk 1.1.0 → 3.0.0

package/dist/src/cli/contract.js

@@ -2315,6 +2315,8 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                 identifiers: {
                     appId: id,
                     targetProjectKey,
+                    preflightExecuted: false,
+                    preflightWillRunDuringApply: true,
                     incarnationControl: "client-side-non-atomic-future-target-and-creation-tag-join",
                     incarnationObservationRequests: [
                         {
@@ -2337,7 +2339,13 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                             method: "GET",
                             endpoint: "/public/api/projects/",
                             when: "conditional",
-                            intent: "Fallback list probe issued only when the direct project GET is forbidden (403) to confirm the target is absent; an unconfirmed target rejects creation.",
+                            intent: "Fallback list probe issued only when the direct project GET is forbidden (403). Presence proves a collision; absence cannot prove availability.",
+                        },
+                        {
+                            method: "GET",
+                            endpoint: `/public/api/apps/${encodeURIComponent(id)}/instances/`,
+                            when: "conditional",
+                            intent: "Fallback app-instance list probe issued when the direct project GET is forbidden (403). Presence proves a collision; absence still rejects creation as unverifiable.",
                         },
                     ],
                     note: "Strict preflight: the instance POST runs only after the payload targetProjectKey is confirmed absent. Creation never writes into an existing or unprovable project.",
@@ -2399,6 +2407,8 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                     appId: id,
                     sourceProjectKey,
                     targetProjectKey,
+                    preflightExecuted: false,
+                    preflightWillRunDuringApply: true,
                     ...(targetProjectName !== undefined ? { targetProjectName, } : {}),
                     copyPermissions,
                     incarnationControl: "client-side-non-atomic-future-target-and-creation-tag-join",
@@ -2437,7 +2447,7 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                             method: "GET",
                             endpoint: "/public/api/projects/",
                             when: "conditional",
-                            intent: "Fallback list probe issued only when the direct project GET is forbidden (403) to confirm the target is absent; an unconfirmed target rejects creation.",
+                            intent: "Fallback list probe issued only when the direct project GET is forbidden (403). Presence proves a collision; absence cannot prove availability and rejects creation.",
                         },
                     ],
                     ...(copyPermissions

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

@@ -87,12 +87,22 @@ export declare function futureTargetIdentity(result: unknown): {
     projectKey: string;
     field: "targetProjectKey" | "projectKey";
 } | null;
+interface TargetAbsenceContext {
+    appId: string;
+    visibleAppInstanceKeys?: readonly (string | undefined)[];
+}
 /**
  * Creation cleanup is safe only when the target was proven absent before POST.
  * A hidden 403 is not absence: project listing can prove a collision, but it
  * cannot prove that an inaccessible project does not exist.
  */
-export declare function requireAbsentProjectTarget(client: DataikuClient, targetProjectKey: string, targetFlag: "--to" | "targetProjectKey"): Promise<void>;
+export declare function requireAbsentProjectTarget(client: DataikuClient, targetProjectKey: string, targetFlag: "--to" | "targetProjectKey", context: TargetAbsenceContext): Promise<void>;
+/**
+ * Run every read-only gate used by successor creation without changing the
+ * template version or issuing the creation POST. Its manifest hash is suitable
+ * for the subsequent set-manifest-version --expect-hash guard.
+ */
+export declare function preflightSuccessorInstance(client: DataikuClient, request: SuccessorInstanceRequest, usage: string): Promise<Record<string, unknown>>;
 /**
  * Create a new app instance from the current template version alongside an
  * existing instance. Classic app instances have no public upgrade endpoint, so
@@ -100,7 +110,9 @@ export declare function requireAbsentProjectTarget(client: DataikuClient, target
  * and deliberately retired.
  *
  * After the creation POST this function never throws. A post-POST failure
- * returns a failed-wait result carrying the target project key, so the CLI still
- * exits 4 and the cleanup ledger still records an addressable successor.
+ * returns a failed-wait result. Only a DSS future ID or verified project
+ * incarnation can authorize cleanup; an ambiguous POST with neither stays
+ * indeterminate and produces no cleanup entry.
  */
 export declare function createSuccessorInstance(client: DataikuClient, request: SuccessorInstanceRequest, usage: string): Promise<Record<string, unknown>>;
+export {};

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

@@ -150,6 +150,7 @@ export async function verifyAppInstance(client, appId, projectKey, expectVersion
 }
 const SUCCESSOR_REMEDIATION = "The successor project may exist: replay the recorded cleanup entry, which future-gates deletion when DSS supplied a future ID. Without a cleanup entry, inspect the creation future and wait for it to become terminal before deleting the requested successor project. The predecessor project was not modified.";
 const CREATE_REJECTED_REMEDIATION = "DSS refused the creation request, so no successor project was created: fix the reported problem and retry. The predecessor project was not modified.";
+const SUCCESSOR_UNBOUND_REMEDIATION = "DSS may have accepted the successor request, but no future ID or project incarnation is available to authorize cleanup. Inspect the app's instances and DSS task history; do not delete the requested key until creation is known terminal and its identity is verified. The predecessor project was not modified.";
 /**
  * True only when DSS definitively refused a write: a non-retryable 4xx with a
  * classified client-side taxonomy. Transport failures (status 0), 5xx, retryable
@@ -186,7 +187,19 @@ export function futureTargetIdentity(result) {
  * A hidden 403 is not absence: project listing can prove a collision, but it
  * cannot prove that an inaccessible project does not exist.
  */
-export async function requireAbsentProjectTarget(client, targetProjectKey, targetFlag) {
+export async function requireAbsentProjectTarget(client, targetProjectKey, targetFlag, context) {
+    if (context.visibleAppInstanceKeys?.includes(targetProjectKey) === true) {
+        throw new UsageError(`Target project ${targetProjectKey} already exists as an app instance.`, "validation_failed", `Choose an unused ${targetFlag}: app instance creation never writes into an existing project.`, {
+            targetProjectKey,
+            targetFlag,
+            directTargetProbe: "not-executed",
+            targetVisibleInProjectList: null,
+            targetVisibleInAppInstances: true,
+            appInstancesProbe: 200,
+            preflightExecuted: true,
+            creationPostAttempted: false,
+        });
+    }
     try {
         const existing = await readIfExists(() => client.projects.get(targetProjectKey));
         if (existing === undefined)
@@ -195,10 +208,61 @@ export async function requireAbsentProjectTarget(client, targetProjectKey, targe
     catch (error) {
         if (!(error instanceof DataikuError) || error.status !== 403)
             throw error;
-        const accessible = await client.projects.list();
-        if (!accessible.some((project) => project.projectKey === targetProjectKey)) {
-            throw new UsageError(`Could not confirm target project ${targetProjectKey} is absent.`, "validation_failed", "Grant project-list/details visibility or choose a target key whose absence DSS can confirm; creation never risks cleanup against an unproven target.", { targetProjectKey, targetFlag, targetProbe: "forbidden-and-not-listable", });
+        let projectListProbe = 200;
+        let targetVisibleInProjectList;
+        try {
+            const accessible = await client.projects.list();
+            targetVisibleInProjectList = accessible.some((project) => project.projectKey === targetProjectKey);
+        }
+        catch (projectListError) {
+            if (!(projectListError instanceof DataikuError) || projectListError.status !== 403) {
+                throw projectListError;
+            }
+            projectListProbe = 403;
+            targetVisibleInProjectList = null;
         }
+        let appInstancesProbe = 200;
+        let visibleAppInstanceKeys = context.visibleAppInstanceKeys;
+        if (visibleAppInstanceKeys === undefined) {
+            try {
+                visibleAppInstanceKeys = (await client.applications.listInstances(context.appId))
+                    .map((instance) => instance.projectKey);
+            }
+            catch (appInstancesError) {
+                if (!(appInstancesError instanceof DataikuError) || appInstancesError.status !== 403) {
+                    throw appInstancesError;
+                }
+                appInstancesProbe = 403;
+                visibleAppInstanceKeys = [];
+            }
+        }
+        const targetVisibleInAppInstances = appInstancesProbe === 200
+            ? visibleAppInstanceKeys?.includes(targetProjectKey) ?? false
+            : null;
+        const probeDetails = {
+            targetProjectKey,
+            targetFlag,
+            directTargetProbe: 403,
+            projectListProbe,
+            targetVisibleInProjectList,
+            targetVisibleInAppInstances,
+            appInstancesProbe,
+            preflightExecuted: true,
+            creationPostAttempted: false,
+        };
+        if (targetVisibleInProjectList !== true && targetVisibleInAppInstances !== true) {
+            throw new UsageError(`Could not confirm target project ${targetProjectKey} is absent.`, "target_absence_unverifiable", "DSS exposes no permission-independent project-key availability endpoint, and app-instance creation has no published atomic duplicate-key guarantee. Retry with an identity that has global project visibility; creation was not attempted.", {
+                ...probeDetails,
+                targetProbe: "forbidden-and-not-listable",
+                deploymentMasksUnknownProjects: "possible-but-unproven",
+                supportedRecoveryModes: ["grant-global-project-visibility",],
+                unavailableRecoveryModes: [
+                    "use-supported-key-availability-endpoint",
+                    "server-atomic-create",
+                ],
+            });
+        }
+        throw new UsageError(`Target project ${targetProjectKey} already exists.`, "validation_failed", `Choose an unused ${targetFlag}: app instance creation never writes into an existing project.`, probeDetails);
     }
     throw new UsageError(`Target project ${targetProjectKey} already exists.`, "validation_failed", `Choose an unused ${targetFlag}: app instance creation never writes into an existing project.`, { targetProjectKey, targetFlag, });
 }
@@ -226,12 +290,26 @@ async function preflightSuccessor(client, request, usage) {
     if (source.projectAppType !== "APP_INSTANCE") {
         throw new UsageError(`Project ${from} is a ${source.projectAppType ?? "non-app"} project, not a classic Dataiku App instance.`, "validation_failed", "--from must name an APP_INSTANCE project; app templates are versioned with `dss app set-manifest-version`.", { sourceProjectKey: from, projectAppType: source.projectAppType ?? null, });
     }
-    await requireAbsentProjectTarget(client, to, "--to");
+    await requireAbsentProjectTarget(client, to, "--to", {
+        appId,
+        visibleAppInstanceKeys: instances.map((instance) => instance.projectKey),
+    });
     const templateManifest = await client.applications.getAppManifest(appId);
     const templateVersion = rawVersion(templateManifest);
     if (templateVersion === null) {
         throw new UsageError(`App template ${appId} has no manifest version, so a successor instance cannot be verified against it.`, "validation_failed", "Set the template version first with `dss app set-manifest-version --manifest-version V --project-key <templateProjectKey>`.", { appId, });
     }
+    const templateReferenceValidation = await client.applications.validateAppManifest(templateManifest, appId);
+    if (!templateReferenceValidation.valid) {
+        throw new UsageError(`App template ${appId} failed manifest reference validation.`, "validation_failed", "Fix the template manifest references before changing its version or creating a successor.", {
+            appId,
+            manifestHash: templateReferenceValidation.manifestHash,
+            checks: templateReferenceValidation.checks,
+            errors: templateReferenceValidation.errors,
+            preflightExecuted: true,
+            creationPostAttempted: false,
+        });
+    }
     const sourcePermissions = request.copyPermissions
         ? await client.projects.getPermissions(from)
         : undefined;
@@ -243,6 +321,7 @@ async function preflightSuccessor(client, request, usage) {
         targetExists: false,
         templateManifestHash: stableHash(templateManifest),
         templateVersion,
+        templateReferenceValidation,
         ...(sourcePermissions
             ? {
                 sourcePermissions,
@@ -251,6 +330,52 @@ async function preflightSuccessor(client, request, usage) {
             : {}),
     };
 }
+/**
+ * Run every read-only gate used by successor creation without changing the
+ * template version or issuing the creation POST. Its manifest hash is suitable
+ * for the subsequent set-manifest-version --expect-hash guard.
+ */
+export async function preflightSuccessorInstance(client, request, usage) {
+    const preflight = await preflightSuccessor(client, request, usage);
+    return {
+        action: "successor-preflight",
+        preflight: "passed",
+        preflightExecuted: true,
+        creationPostAttempted: false,
+        versionMutationAttempted: false,
+        appId: request.appId,
+        source: {
+            projectKey: request.from,
+            projectAppType: preflight.sourceProjectAppType,
+            version: preflight.sourceVersion,
+            manifestHash: preflight.sourceManifestHash,
+            ...(preflight.sourcePermissionsHash
+                ? { permissionsHash: preflight.sourcePermissionsHash, }
+                : {}),
+        },
+        target: {
+            projectKey: request.to,
+            name: preflight.targetProjectName,
+            exists: false,
+        },
+        targetPreflight: "confirmed-absent",
+        template: {
+            projectKey: request.appId,
+            version: preflight.templateVersion,
+            manifestHash: preflight.templateManifestHash,
+            referenceValidation: {
+                valid: preflight.templateReferenceValidation.valid,
+                checks: preflight.templateReferenceValidation.checks,
+                errors: preflight.templateReferenceValidation.errors,
+            },
+        },
+        copyPermissions: request.copyPermissions,
+        next: {
+            setVersion: `dss app set-manifest-version --manifest-version <VERSION> --expect-hash ${preflight.templateManifestHash} --project-key ${request.appId}`,
+            createSuccessor: `dss app create-successor-instance ${request.appId} --from ${request.from} --to ${request.to}${request.name !== undefined ? ` --name ${JSON.stringify(request.name)}` : ""}${request.copyPermissions ? " --copy-permissions" : ""}`,
+        },
+    };
+}
 /**
  * Create a new app instance from the current template version alongside an
  * existing instance. Classic app instances have no public upgrade endpoint, so
@@ -258,8 +383,9 @@ async function preflightSuccessor(client, request, usage) {
  * and deliberately retired.
  *
  * After the creation POST this function never throws. A post-POST failure
- * returns a failed-wait result carrying the target project key, so the CLI still
- * exits 4 and the cleanup ledger still records an addressable successor.
+ * returns a failed-wait result. Only a DSS future ID or verified project
+ * incarnation can authorize cleanup; an ambiguous POST with neither stays
+ * indeterminate and produces no cleanup entry.
  */
 export async function createSuccessorInstance(client, request, usage) {
     const { appId, from, to, } = request;
@@ -312,12 +438,17 @@ export async function createSuccessorInstance(client, request, usage) {
             projectKey: to,
             target: { projectKey: to, name: preflight.targetProjectName, },
             success: false,
-            state: "CREATE_FAILED",
+            state: rejected ? "CREATE_FAILED" : "INDETERMINATE",
             elapsedMs: 0,
             pollCount: 0,
             stage: "create",
-            cleanupEligible: !rejected,
-            remediation: rejected ? CREATE_REJECTED_REMEDIATION : SUCCESSOR_REMEDIATION,
+            outcome: rejected ? "rejected" : "indeterminate",
+            creationPostAttempted: true,
+            cleanupEligible: false,
+            recoveryCommands: rejected
+                ? []
+                : [`dss app instances ${appId}`,],
+            remediation: rejected ? CREATE_REJECTED_REMEDIATION : SUCCESSOR_UNBOUND_REMEDIATION,
             ...safeErrorSummary(error),
         };
     }
@@ -342,11 +473,13 @@ export async function createSuccessorInstance(client, request, usage) {
             stage: "create",
             ...(instance ? { instance, } : {}),
             ...(jobId !== undefined ? { futureId: jobId, jobId, } : {}),
-            cleanupEligible: true,
+            cleanupEligible: jobId !== undefined,
             error: "DSS named a different target project in the creation response.",
             expected: { projectKey: to, },
             actual: { projectKey: echoedTarget, },
-            remediation: SUCCESSOR_REMEDIATION,
+            remediation: jobId !== undefined
+                ? SUCCESSOR_REMEDIATION
+                : SUCCESSOR_UNBOUND_REMEDIATION,
         };
     }
     const base = {
@@ -381,13 +514,16 @@ export async function createSuccessorInstance(client, request, usage) {
                         : "scalar",
             }),
             success: false,
-            state: "UNTRACKABLE",
+            state: "INDETERMINATE",
             elapsedMs: 0,
             pollCount: 0,
             stage: "future-wait",
-            cleanupEligible: true,
+            outcome: "indeterminate",
+            creationPostAttempted: true,
+            cleanupEligible: false,
             error: "DSS returned no instance-creation future ID, so the successor instance cannot be verified.",
-            remediation: SUCCESSOR_REMEDIATION,
+            remediation: SUCCESSOR_UNBOUND_REMEDIATION,
+            recoveryCommands: [`dss app instances ${appId}`,],
         };
     }
     else {
@@ -408,6 +544,7 @@ export async function createSuccessorInstance(client, request, usage) {
                 pollCount: 0,
                 stage: "future-wait",
                 cleanupEligible: true,
+                recoveryCommands: [`dss future wait ${jobId}`, `dss app instances ${appId}`,],
                 remediation: SUCCESSOR_REMEDIATION,
                 ...safeErrorSummary(error),
             };
@@ -451,6 +588,9 @@ export async function createSuccessorInstance(client, request, usage) {
     if (!waited.success) {
         return failure(waited.state, "future-wait", {
             error: "The instance-creation future did not complete successfully.",
+            recoveryCommands: jobId !== undefined
+                ? [`dss future wait ${jobId}`, `dss app instances ${appId}`,]
+                : [`dss app instances ${appId}`,],
         });
     }
     try {

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

@@ -12,7 +12,7 @@ export declare function isFullRevision(value: unknown): boolean;
 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 type CliRuntime = "bun";
 export declare function detectLoadSource(modulePath?: string): CliLoadSource;
 export declare function buildMetadataRevision(packageRoot: string | undefined): string | undefined;
 /**
@@ -37,6 +37,7 @@ export interface CliVersionPayload {
     buildRevision: string | null;
     staleBuild: boolean;
 }
+/** Bun is the only supported runtime; the field is retained for payload stability. */
 export declare function detectRuntime(): CliRuntime;
 export declare function buildVersionPayload(input: {
     packageVersion: string;

package/dist/src/cli/version.js

@@ -182,8 +182,9 @@ export function sourceTreeNewerThanBuild(packageRoot) {
         return false;
     }
 }
+/** Bun is the only supported runtime; the field is retained for payload stability. */
 export function detectRuntime() {
-    return process.versions.bun ? "bun" : "node";
+    return "bun";
 }
 export function buildVersionPayload(input) {
     const isDist = input.loadSource === "dist";

package/dist/src/cli.js

@@ -1241,8 +1241,11 @@ function buildErrorReport(err) {
             ok: false,
             error: err.message,
             code: err.code,
-            category: "usage",
+            category: err.code === "target_absence_unverifiable"
+                ? "permission_or_environment"
+                : "usage",
             exitCode,
+            ...(err.code === "target_absence_unverifiable" ? { retryable: false, } : {}),
             ...(err.hint ? { hint: err.hint, } : {}),
             ...(err.details ? { details: err.details, } : {}),
             ...context,

package/dist/src/client.js

@@ -1,4 +1,4 @@
-import { openAsBlob, readFileSync, } from "node:fs";
+import { readFileSync, } from "node:fs";
 import { basename, } from "node:path";
 import { getCACertificates, } from "node:tls";
 import { Value, } from "@sinclair/typebox/value";
@@ -479,7 +479,7 @@ export class DataikuClient {
         });
     }
     async uploadResponse(path, filePath, fileName) {
-        const fileBlob = await openAsBlob(filePath);
+        const fileBlob = Bun.file(filePath);
         const formData = new FormData();
         formData.append("file", fileBlob, fileName ?? basename(filePath));
         return this.fetchWithRetry(`${this.baseUrl}${path}`, {

package/dist/src/errors.d.ts

@@ -1,5 +1,5 @@
 export type DataikuErrorCategory = "not_found" | "forbidden" | "validation" | "transient" | "unknown";
-export type StableErrorCode = "usage_error" | "unknown_flag" | "missing_required_arg" | "missing_required_flag" | "invalid_flag_value" | "conflicting_input_sources" | "invalid_enum" | "not_found" | "permission_denied" | "validation_failed" | "transient" | "long_running_failure" | "command_result_failure" | "assertion_failed" | "ambiguous_outcome" | "internal_error";
+export type StableErrorCode = "usage_error" | "unknown_flag" | "missing_required_arg" | "missing_required_flag" | "invalid_flag_value" | "conflicting_input_sources" | "invalid_enum" | "not_found" | "permission_denied" | "target_absence_unverifiable" | "validation_failed" | "transient" | "long_running_failure" | "command_result_failure" | "assertion_failed" | "ambiguous_outcome" | "internal_error";
 export declare function dataikuErrorCode(category: DataikuErrorCategory): StableErrorCode;
 export interface DataikuErrorTaxonomy {
     category: DataikuErrorCategory;

package/dist/src/resources/folders.js

@@ -1,7 +1,4 @@
-import { createWriteStream, } from "node:fs";
-import { resolve, } from "node:path";
-import { Readable, } from "node:stream";
-import { pipeline, } from "node:stream/promises";
+import * as nodePath from "node:path";
 import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
@@ -72,10 +69,11 @@ export class FoldersResource extends BaseResource {
         const normalizedPath = normalizeRemotePath(path);
         const pEnc = encodeURIComponent(normalizedPath);
         const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/managedfolders/${fEnc}/contents/${pEnc}`);
-        const dest = opts?.localPath ?? resolve(process.cwd(), inferDownloadFileName(normalizedPath));
-        const nodeStream = Readable.fromWeb(res.body);
-        const fileOut = createWriteStream(dest);
-        await pipeline(nodeStream, fileOut);
+        if (!res.body)
+            throw new Error("folders.download response did not include a body");
+        const dest = opts?.localPath
+            ?? nodePath.resolve(process.cwd(), inferDownloadFileName(normalizedPath));
+        await Bun.write(dest, new Response(res.body), { createPath: false, });
         return dest;
     }
     upload(folderId, path, localPath, projectKey) {

package/dist/src/resources/projects.js

@@ -1,5 +1,3 @@
-import { createWriteStream, } from "node:fs";
-import { Writable, } from "node:stream";
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, } from "../schemas.js";
 import { normalizeFlowGraph, } from "../utils/flow-map.js";
@@ -159,14 +157,7 @@ export class ProjectsResource extends BaseResource {
         const res = await this.postStream(`/public/api/projects/${encodeURIComponent(projectKey)}/export`, options ?? {});
         if (!res.body)
             throw new Error("projects.exportArchive response did not include a body");
-        const file = createWriteStream(filePath);
-        try {
-            await res.body.pipeTo(Writable.toWeb(file));
-        }
-        catch (error) {
-            file.destroy();
-            throw error;
-        }
+        await Bun.write(filePath, new Response(res.body), { createPath: false, });
     }
     /** Upload a project archive and return its temporary import handle. */
     async prepareProjectImport(filePath) {

package/dist/src/skill.js

@@ -1,4 +1,3 @@
-import { execFileSync, } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -61,24 +60,11 @@ export const AGENTS = {
         content: skillContent,
     },
 };
-// ---------------------------------------------------------------------------
-// Agent detection
-// ---------------------------------------------------------------------------
-function binaryExists(name) {
-    const cmd = process.platform === "win32" ? "where" : "which";
-    try {
-        execFileSync(cmd, [name,], { stdio: "pipe", });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export function detectAgents() {
     const home = os.homedir();
     const found = [];
     for (const [id, def,] of Object.entries(AGENTS)) {
-        const hasBinary = binaryExists(def.binary);
+        const hasBinary = Bun.which(def.binary) !== null;
         const hasConfigDir = fs.existsSync(path.join(home, def.configDir));
         if (hasBinary && (!def.configDirRequired || hasConfigDir)) {
             found.push({ id, def, via: "binary", });
@@ -90,9 +76,6 @@ export function detectAgents() {
     return found;
 }
 // ---------------------------------------------------------------------------
-// Skill installation
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
 // Workspace root detection
 // ---------------------------------------------------------------------------
 const WORKSPACE_MARKERS = [".git",];

package/dist/src/utils/project-archive.d.ts

@@ -17,7 +17,7 @@ export interface ProjectArchiveInspection {
  * Inspect a DSS project export ZIP archive without extracting anything to
  * disk: enumerate every central-directory record, validate member paths
  * independently, stream every file member through a size/CRC-32 check with
- * bounded memory (manual `node:zlib.crc32`, covering data-descriptor
+ * bounded memory (manual `Bun.hash.crc32`, covering data-descriptor
  * records), parse `export-manifest.json` and the source project key, and run
  * the generic dangling-reference/orphan-member graph checks. Identity,
  * history and machine-specific residue is reported only as warnings carrying

package/dist/src/utils/project-archive.js

@@ -1,6 +1,5 @@
 import StreamZip from "node-stream-zip";
 import { stat, } from "node:fs/promises";
-import { crc32, } from "node:zlib";
 import { ClientValidationError, } from "../errors.js";
 const MANIFEST_MEMBER = "export-manifest.json";
 const DATASETS_ROOT = "project_config/datasets";
@@ -106,7 +105,7 @@ function isUnsafeMemberPath(name) {
 /**
  * Stream one member through a bounded-memory CRC-32/size check. The library's
  * own verification is bypassed for data-descriptor records (bit 3 set), so the
- * manual `node:zlib.crc32` computation covers every record uniformly.
+ * manual `Bun.hash.crc32` computation covers every record uniformly.
  *
  * When `accumulate` is set, buffered content never exceeds `maxBytes`: the
  * buffer is dropped as soon as the cap is reached while the member is still
@@ -130,7 +129,7 @@ function streamMember(zip, entry, accumulate, maxBytes = Number.POSITIVE_INFINIT
         stream.on("data", (chunk) => {
             const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
             bytes += buffer.length;
-            crc = crc32(buffer, crc) >>> 0;
+            crc = Bun.hash.crc32(buffer, crc) >>> 0;
             if (!content || truncated)
                 return;
             if (bytes > maxBytes) {
@@ -307,7 +306,7 @@ function residueIssue(member, counts) {
  * Inspect a DSS project export ZIP archive without extracting anything to
  * disk: enumerate every central-directory record, validate member paths
  * independently, stream every file member through a size/CRC-32 check with
- * bounded memory (manual `node:zlib.crc32`, covering data-descriptor
+ * bounded memory (manual `Bun.hash.crc32`, covering data-descriptor
  * records), parse `export-manifest.json` and the source project key, and run
  * the generic dangling-reference/orphan-member graph checks. Identity,
  * history and machine-specific residue is reported only as warnings carrying

package/dist/src/utils/stable-hash.js

@@ -1,6 +1,5 @@
-import { createHash, } from "node:crypto";
 export function sha256Hex(value) {
-    return createHash("sha256").update(value).digest("hex");
+    return new Bun.CryptoHasher("sha256").update(value).digest("hex");
 }
 /** Locale-independent UTF-16 code-unit order for deterministic machine output. */
 export function compareStrings(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "1.1.0",
+	"version": "3.0.0",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [
@@ -19,15 +19,14 @@
 		"packages/types/dist/"
 	],
 	"engines": {
-		"node": ">=22.15.0",
-		"bun": ">=1.3.14"
+		"bun": ">=1.4.0"
 	},
 	"scripts": {
-		"build": "tsc && node scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
-		"prepack": "node scripts/sync-plugin-version.mjs --check && tsc && node scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
-		"prepublishOnly": "node scripts/sync-plugin-version.mjs --check && tsc && node scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
-		"check": "tsc --noEmit && node scripts/sync-plugin-version.mjs --check",
-		"version": "node scripts/sync-plugin-version.mjs && git add plugin.json",
+		"build": "tsc && bun scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
+		"prepack": "bun scripts/sync-plugin-version.mjs --check && tsc && bun scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
+		"prepublishOnly": "bun scripts/sync-plugin-version.mjs --check && tsc && bun scripts/generate-build-metadata.mjs && tsc -p packages/types/tsconfig.json",
+		"check": "tsc --noEmit && bun scripts/sync-plugin-version.mjs --check",
+		"version": "bun scripts/sync-plugin-version.mjs && git add plugin.json",
 		"lint": "oxlint src/",
 		"lint:fix": "oxlint --fix src/",
 		"format": "dprint fmt",
@@ -41,7 +40,7 @@
 		"test:integration:rigorous:mutating": "cross-env RUN_DATAIKU_INTEGRATION=1 RUN_DATAIKU_INTEGRATION_MUTATING=1 bun test tests/integration-rigorous.test.ts"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.14",
+		"@types/bun": "^1.4.0",
 		"cross-env": "^10.1.0",
 		"dprint": "^0.55.2",
 		"js-tiktoken": "1.0.21",
@@ -57,7 +56,7 @@
 	"bundledDependencies": [
 		"@sinclair/typebox"
 	],
-	"license": "MIT",
+	"license": "SEE LICENSE IN LICENSE",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/clssck/dataiku-sdk.git"

package/plugin.json

@@ -1,11 +1,11 @@
 {
 	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
 	"name": "dataiku-sdk",
-	"version": "1.1.0",
+	"version": "3.0.0",
 	"description": "Dataiku DSS SDK and agent-oriented CLI for programmatic access to DSS REST APIs.",
 	"homepage": "https://github.com/clssck/dataiku-sdk",
 	"repository": "https://github.com/clssck/dataiku-sdk",
-	"license": "MIT",
+	"license": "LicenseRef-Dataiku-SDK-Limited-Use-1.0",
 	"keywords": [
 		"dataiku",
 		"dss",