dataiku-sdk 3.0.0 → 3.2.0

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

@@ -34,6 +34,24 @@ const NON_DATASET_REFERENCE_TYPES = {
 const MAX_JSON_MEMBER_BYTES = 16 * 1024 * 1024;
 /** Upper bound for residue text scanning of individual members. */
 const MAX_RESIDUE_SCAN_BYTES = 1024 * 1024;
+export const PROJECT_ARCHIVE_DEFAULT_LIMITS = Object
+    .freeze({
+    maxMembers: 100_000,
+    maxCompressedBytesPerMember: 4 * 1024 * 1024 * 1024,
+    maxExpandedBytesPerMember: 4 * 1024 * 1024 * 1024,
+    maxCompressionRatio: 1_000,
+    maxTotalExpandedBytes: 16 * 1024 * 1024 * 1024,
+});
+/** Merge per-call overrides onto the exported default inspection limits. */
+function effectiveLimits(overrides) {
+    const merged = { ...PROJECT_ARCHIVE_DEFAULT_LIMITS, };
+    for (const key of Object.keys(overrides)) {
+        const value = overrides[key];
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+}
 function plainRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -107,12 +125,19 @@ function isUnsafeMemberPath(name) {
  * own verification is bypassed for data-descriptor records (bit 3 set), so the
  * 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
- * streamed in full, so CRC/size verification stays complete and the size
+ * When `accumulate` is set, buffered content never exceeds `bufferMaxBytes`:
+ * the buffer is dropped as soon as the cap is reached while the member is
+ * still streamed in full, so CRC/size verification stays complete and the size
  * mismatch (if the declared size lied) is still reported.
+ *
+ * The safety budgets bound decompression itself, not just buffering: once the
+ * per-member expanded-byte budget (`expandedBytes`) or the aggregate
+ * expanded-byte budget (`totalExpandedBytes`, tracked across members in
+ * `tally`) is crossed, the member stream is destroyed immediately and no
+ * further decompression or hashing happens. The caller must not compare the
+ * partial CRC/size result, which is why the result carries `aborted`.
  */
-function streamMember(zip, entry, accumulate, maxBytes = Number.POSITIVE_INFINITY) {
+function streamMember(zip, entry, accumulate, bufferMaxBytes, limits) {
     const { promise, resolve, reject, } = Promise.withResolvers();
     zip.stream(entry, (err, stm) => {
         if (err) {
@@ -125,14 +150,29 @@ function streamMember(zip, entry, accumulate, maxBytes = Number.POSITIVE_INFINIT
         let bytes = 0;
         let crc = 0;
         let truncated = false;
+        let aborted = false;
         const content = accumulate ? [] : undefined;
+        const abort = (reason) => {
+            aborted = reason;
+            stream.destroy();
+            resolve({ bytes, crc, content: undefined, truncated, aborted, });
+        };
         stream.on("data", (chunk) => {
+            if (aborted)
+                return;
             const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
             bytes += buffer.length;
+            limits.tally.expandedBytes += buffer.length;
+            if (limits.tally.expandedBytes > limits.totalExpandedBytes) {
+                return abort("aggregate");
+            }
+            if (bytes > limits.expandedBytes) {
+                return abort("member");
+            }
             crc = Bun.hash.crc32(buffer, crc) >>> 0;
             if (!content || truncated)
                 return;
-            if (bytes > maxBytes) {
+            if (bytes > bufferMaxBytes) {
                 truncated = true;
                 content.length = 0;
                 return;
@@ -140,14 +180,21 @@ function streamMember(zip, entry, accumulate, maxBytes = Number.POSITIVE_INFINIT
             content.push(buffer);
         });
         stream.on("end", () => {
+            if (aborted)
+                return;
             resolve({
                 bytes,
                 crc,
                 content: truncated ? undefined : content,
                 truncated,
+                aborted: false,
             });
         });
         stream.on("error", (streamErr) => {
+            // A stream destroyed by a budget breach may surface a late error;
+            // the result was already resolved and the partial data is unusable.
+            if (aborted)
+                return;
             reject(streamErr);
         });
     });
@@ -302,6 +349,17 @@ function residueIssue(member, counts) {
         member,
     };
 }
+/** Deterministic issue ordering: severity, then code, member, message. */
+function sortIssues(issues) {
+    issues.sort((a, b) => {
+        const severityOrder = a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1;
+        return (severityOrder
+            || a.code.localeCompare(b.code)
+            || (a.member ?? "").localeCompare(b.member ?? "")
+            || a.message.localeCompare(b.message));
+    });
+    return issues;
+}
 /**
  * Inspect a DSS project export ZIP archive without extracting anything to
  * disk: enumerate every central-directory record, validate member paths
@@ -311,8 +369,18 @@ function residueIssue(member, counts) {
  * the generic dangling-reference/orphan-member graph checks. Identity,
  * history and machine-specific residue is reported only as warnings carrying
  * member paths and pattern counts, never matched values.
+ *
+ * Safety budgets (see {@link ProjectArchiveInspectionLimits}) bound every
+ * amount of work: archives with more members than `maxMembers` are reported
+ * without opening any member stream, members whose central-directory record
+ * declares a compressed size or compression ratio above budget are skipped
+ * without being read, and per-member/aggregate expanded-byte overruns
+ * destroy the member stream immediately. Pass a partial limits object as
+ * `overrides` to customize the budgets for a single inspection; importers
+ * use the exported defaults.
  */
-export async function inspectProjectArchive(filePath) {
+export async function inspectProjectArchive(filePath, overrides = {}) {
+    const limits = effectiveLimits(overrides);
     let sizeBytes = 0;
     let statError;
     try {
@@ -373,6 +441,23 @@ export async function inspectProjectArchive(filePath) {
         };
     }
     try {
+        // The member-count budget bounds inspection work per archive. When it
+        // is exceeded no member stream is opened: the archive reports a single
+        // error and cannot be imported.
+        if (records.length > limits.maxMembers) {
+            issues.push({
+                severity: "error",
+                code: "member_count_exceeded",
+                message: `archive contains ${records.length} members, above the inspection limit of ${limits.maxMembers}`,
+            });
+            return {
+                filePath,
+                sizeBytes,
+                memberCount: records.length,
+                valid: false,
+                issues,
+            };
+        }
         const memberCounts = new Map();
         for (const entry of records) {
             memberCounts.set(entry.name, (memberCounts.get(entry.name) ?? 0) + 1);
@@ -398,6 +483,8 @@ export async function inspectProjectArchive(filePath) {
         }
         const manifestJson = new Map();
         const recipes = new Map();
+        const tally = { expandedBytes: 0, };
+        let aggregateAborted = false;
         for (const entry of records) {
             if (!entry.isFile)
                 continue;
@@ -426,16 +513,44 @@ export async function inspectProjectArchive(filePath) {
                 || name.startsWith(`${BUNDLED_DATA_ROOT}/`)
                 || name.startsWith(`${UPLOADS_ROOT}/`))
                 && entry.size <= MAX_RESIDUE_SCAN_BYTES;
+            // Budgets computed from the central-directory record abort before
+            // any decompression work: a member whose declared compressed size
+            // or expanded/compressed ratio is above budget is never streamed.
+            if (entry.compressedSize > limits.maxCompressedBytesPerMember) {
+                issues.push({
+                    severity: "error",
+                    code: "member_compressed_size_exceeded",
+                    message: `member ${name}: declared compressed size exceeds the inspection limit and was not read`,
+                    member: name,
+                });
+                continue;
+            }
+            if (entry.compressedSize > 0
+                && entry.size / entry.compressedSize > limits.maxCompressionRatio) {
+                issues.push({
+                    severity: "error",
+                    code: "member_compression_ratio_exceeded",
+                    message: `member ${name}: declared compression ratio exceeds the inspection limit and was not read`,
+                    member: name,
+                });
+                continue;
+            }
             let streamed;
             try {
                 // The buffering cap applies to actual streamed bytes, not the
                 // declared size: a member can declare a small size and still
                 // inflate arbitrarily, which must not be buffered unbounded.
+                // The expanded-byte budgets bound decompression itself and
+                // destroy the member stream the moment one is crossed.
                 streamed = await streamMember(zip, entry, parseCandidate || scanCandidate, parseCandidate
                     ? MAX_JSON_MEMBER_BYTES
                     : scanCandidate
                         ? MAX_RESIDUE_SCAN_BYTES
-                        : Number.POSITIVE_INFINITY);
+                        : Number.POSITIVE_INFINITY, {
+                    expandedBytes: limits.maxExpandedBytesPerMember,
+                    totalExpandedBytes: limits.maxTotalExpandedBytes,
+                    tally,
+                });
             }
             catch (streamErr) {
                 streamed = undefined;
@@ -467,6 +582,26 @@ export async function inspectProjectArchive(filePath) {
             }
             if (!streamed)
                 continue;
+            if (streamed.aborted) {
+                issues.push(streamed.aborted === "aggregate"
+                    ? {
+                        severity: "error",
+                        code: "aggregate_inflation_limit_exceeded",
+                        message: `member ${name}: aggregate expanded bytes exceed the inspection budget; remaining members were not inspected`,
+                        member: name,
+                    }
+                    : {
+                        severity: "error",
+                        code: "member_inflation_limit_exceeded",
+                        message: `member ${name}: data exceeds the per-member expanded-byte inspection budget and was not fully inspected`,
+                        member: name,
+                    });
+                if (streamed.aborted === "aggregate") {
+                    aggregateAborted = true;
+                    break;
+                }
+                continue;
+            }
             if (streamed.bytes !== entry.size) {
                 issues.push({
                     severity: "error",
@@ -524,6 +659,20 @@ export async function inspectProjectArchive(filePath) {
                 }
             }
         }
+        // Once the aggregate expanded-byte budget is crossed, remaining
+        // members were not inspected: report the budget issue and stop, so no
+        // manifest/graph conclusion is drawn from the partial inspection.
+        if (aggregateAborted) {
+            sortIssues(issues);
+            return {
+                filePath,
+                sizeBytes,
+                memberCount: records.length,
+                sourceProjectKey: undefined,
+                valid: false,
+                issues,
+            };
+        }
         let sourceProjectKey;
         let manifestDatasetNames;
         const manifestMember = manifestJson.get(MANIFEST_MEMBER);
@@ -580,13 +729,7 @@ export async function inspectProjectArchive(filePath) {
         const recipeNames = recipeDefinitionNames(records);
         checkRecipeReferences(recipes, datasetNames, nonDatasetNames, issues);
         checkOrphanMembers(records, recipeNames, anchored, issues);
-        issues.sort((a, b) => {
-            const severityOrder = a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1;
-            return (severityOrder
-                || a.code.localeCompare(b.code)
-                || (a.member ?? "").localeCompare(b.member ?? "")
-                || a.message.localeCompare(b.message));
-        });
+        sortIssues(issues);
         return {
             filePath,
             sizeBytes,
@@ -613,8 +756,8 @@ export async function inspectProjectArchive(filePath) {
  * `validation_failed` code when the inspection contains any error-severity
  * issue, so the archive cannot be imported.
  */
-export async function assertImportableProjectArchive(filePath) {
-    const inspection = await inspectProjectArchive(filePath);
+export async function assertImportableProjectArchive(filePath, overrides = {}) {
+    const inspection = await inspectProjectArchive(filePath, overrides);
     const errorCount = inspection.issues.filter((issue) => issue.severity === "error").length;
     if (errorCount > 0) {
         throw new ClientValidationError(`project archive is not importable: ${errorCount} validation error(s) found`, "validation_failed", undefined, { filePath: inspection.filePath, issues: inspection.issues, });

package/dist/src/utils/response-file.d.ts

@@ -0,0 +1,2 @@
+/** Stream with backpressure; publish only a complete download, preserving existing output on failure. */
+export declare function writeResponseToFile(path: string, response: Response, permissions?: "private" | "preserve"): Promise<number>;

package/dist/src/utils/response-file.js

@@ -0,0 +1,34 @@
+import { randomUUID, } from "node:crypto";
+import { createWriteStream, } from "node:fs";
+import { chmod, rename, rm, stat, } from "node:fs/promises";
+import { basename, dirname, join, } from "node:path";
+import { Readable, } from "node:stream";
+import { pipeline, } from "node:stream/promises";
+/** Stream with backpressure; publish only a complete download, preserving existing output on failure. */
+export async function writeResponseToFile(path, response, permissions = "private") {
+    let mode;
+    if (permissions === "preserve") {
+        try {
+            mode = (await stat(path)).mode & 0o777;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            mode = 0o666 & ~process.umask();
+        }
+    }
+    const input = Readable.fromWeb(response.body);
+    const temporaryPath = join(dirname(path), `.${basename(path)}.tmp-${randomUUID()}`);
+    const output = createWriteStream(temporaryPath, { flags: "wx", mode: 0o600, });
+    try {
+        await pipeline(input, output);
+        // Keep partial contents private; restore publication permissions only after completion.
+        if (mode !== undefined)
+            await chmod(temporaryPath, mode);
+        await rename(temporaryPath, path);
+        return output.bytesWritten;
+    }
+    finally {
+        await rm(temporaryPath, { force: true, });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "3.0.0",
+	"version": "3.2.0",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [
@@ -25,13 +25,15 @@
 		"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",
+		"check": "tsc --noEmit && bun run check:live && 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/",
+		"lint": "oxlint src/ scripts/live-suite.ts tests/live-*.ts",
+		"lint:fix": "oxlint --fix src/ scripts/live-suite.ts tests/live-*.ts",
 		"format": "dprint fmt",
 		"format:check": "dprint check",
 		"test": "bun test",
+		"test:live": "bun --no-env-file scripts/live-suite.ts",
+		"check:live": "tsc --noEmit -p tsconfig.live.json",
 		"test:tokens": "bun test tests/cli/agent-token-budget.test.ts",
 		"test:platform": "bun scripts/platform-smoke.mjs",
 		"test:integration": "cross-env RUN_DATAIKU_INTEGRATION=1 bun test tests/integration-playground.test.ts",
@@ -42,11 +44,11 @@
 	"devDependencies": {
 		"@types/bun": "^1.4.0",
 		"cross-env": "^10.1.0",
-		"dprint": "^0.55.2",
+		"dprint": "^0.57.0",
 		"js-tiktoken": "1.0.21",
-		"oxlint": "^1.78.0",
+		"oxlint": "^1.81.0",
 		"typescript": "^7.0.2",
-		"typescript-language-server": "5.3.0",
+		"typescript-language-server": "6.0.0",
 		"typescript-language-service": "npm:typescript@5.9.3"
 	},
 	"dependencies": {

package/packages/types/dist/index.d.ts

@@ -430,7 +430,6 @@ export type ConnectionSummary = Static<typeof ConnectionSummarySchema>;
 export declare const CodeEnvSummarySchema: import("@sinclair/typebox").TObject<{
     envName: import("@sinclair/typebox").TString;
     envLang: import("@sinclair/typebox").TString;
-    pythonInterpreter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     deploymentMode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export type CodeEnvSummary = Static<typeof CodeEnvSummarySchema>;
@@ -438,10 +437,42 @@ export declare const CodeEnvDetailsSchema: import("@sinclair/typebox").TObject<{
     envName: import("@sinclair/typebox").TString;
     envLang: import("@sinclair/typebox").TString;
     pythonInterpreter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    deploymentMode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     requestedPackages: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     installedPackages: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    definitionHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export type CodeEnvDetails = Static<typeof CodeEnvDetailsSchema>;
+export declare const CodeEnvLogSummarySchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>;
+export type CodeEnvLogSummary = Static<typeof CodeEnvLogSummarySchema>;
+export declare const CodeEnvLogSummaryArraySchema: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+}>>;
+export type CodeEnvLogSummaryArray = Static<typeof CodeEnvLogSummaryArraySchema>;
+export declare const CodeEnvLogResultSchema: import("@sinclair/typebox").TObject<{
+    log: import("@sinclair/typebox").TString;
+    bytes: import("@sinclair/typebox").TNumber;
+    truncated: import("@sinclair/typebox").TBoolean;
+    tailed: import("@sinclair/typebox").TBoolean;
+}>;
+export type CodeEnvLogResult = Static<typeof CodeEnvLogResultSchema>;
+export declare const CodeEnvGetLogOptionsSchema: import("@sinclair/typebox").TObject<{
+    maxBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    maxLines: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type CodeEnvGetLogOptions = Static<typeof CodeEnvGetLogOptionsSchema>;
+export declare const CodeEnvUpdateImagesOptionsSchema: import("@sinclair/typebox").TObject<{
+    envVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    wait: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export type CodeEnvUpdateImagesOptions = Static<typeof CodeEnvUpdateImagesOptionsSchema>;
+export declare const CodeEnvVersionForProjectSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    bundleId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type CodeEnvVersionForProject = Static<typeof CodeEnvVersionForProjectSchema>;
 export declare const CodeEnvActionResultSchema: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>;
 export type CodeEnvActionResult = Static<typeof CodeEnvActionResultSchema>;
 export declare const CodeEnvCreateOptionsSchema: import("@sinclair/typebox").TObject<{
@@ -457,6 +488,7 @@ export type CodeEnvPackageList = Static<typeof CodeEnvPackageListSchema>;
 export declare const CodeEnvSetPackagesOptionsSchema: import("@sinclair/typebox").TObject<{
     packages: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>;
     installCorePackages: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    expectHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export type CodeEnvSetPackagesOptions = Static<typeof CodeEnvSetPackagesOptionsSchema>;
 export declare const CodeEnvUpdatePackagesOptionsSchema: import("@sinclair/typebox").TObject<{
@@ -583,7 +615,7 @@ export declare const DataQualityComputeResultSchema: import("@sinclair/typebox")
 export type DataQualityComputeResult = Static<typeof DataQualityComputeResultSchema>;
 export declare const JupyterCellSchema: import("@sinclair/typebox").TObject<{
     cell_type: import("@sinclair/typebox").TString;
-    source: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    source: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>;
     metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
     outputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
     execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>>;
@@ -606,7 +638,7 @@ export declare const JupyterNotebookContentSchema: import("@sinclair/typebox").T
     nbformat_minor: import("@sinclair/typebox").TNumber;
     cells: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
         cell_type: import("@sinclair/typebox").TString;
-        source: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        source: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>;
         metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
         outputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
         execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>>;
@@ -646,6 +678,9 @@ export declare const SqlNotebookContentSchema: import("@sinclair/typebox").TObje
     }>>;
 }>;
 export type SqlNotebookContent = Static<typeof SqlNotebookContentSchema>;
+/** Execution history of a SQL notebook: cell ID to the runs recorded for it. */
+export declare const SqlNotebookHistorySchema: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
+export type SqlNotebookHistory = Static<typeof SqlNotebookHistorySchema>;
 export declare const SqlQuerySchemaSchema: import("@sinclair/typebox").TObject<{
     name: import("@sinclair/typebox").TString;
     type: import("@sinclair/typebox").TString;
@@ -677,6 +712,7 @@ export declare const FlowMapOptionsSchema: import("@sinclair/typebox").TObject<{
     maxNodes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     maxEdges: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     includeRaw: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    render: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"ascii">, import("@sinclair/typebox").TLiteral<"mermaid">]>>;
 }>;
 export type FlowMapOptions = Static<typeof FlowMapOptionsSchema>;
 /**
@@ -853,7 +889,6 @@ export declare const FolderItemArraySchema: import("@sinclair/typebox").TArray<i
 export declare const CodeEnvSummaryArraySchema: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
     envName: import("@sinclair/typebox").TString;
     envLang: import("@sinclair/typebox").TString;
-    pythonInterpreter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     deploymentMode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>>;
 export declare const WikiArticleDataArraySchema: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{

package/packages/types/dist/index.js

@@ -444,16 +444,39 @@ export const ConnectionSummarySchema = Type.Object({
 export const CodeEnvSummarySchema = Type.Object({
     envName: Type.String(),
     envLang: Type.String(),
-    pythonInterpreter: Type.Optional(Type.String()),
     deploymentMode: Type.Optional(Type.String()),
 }, { additionalProperties: true, });
 export const CodeEnvDetailsSchema = Type.Object({
     envName: Type.String(),
     envLang: Type.String(),
     pythonInterpreter: Type.Optional(Type.String()),
+    deploymentMode: Type.Optional(Type.String()),
     requestedPackages: Type.Array(Type.String()),
     installedPackages: Type.Array(Type.String()),
+    definitionHash: Type.Optional(Type.String()),
 });
+export const CodeEnvLogSummarySchema = Type.Object({
+    name: Type.String(),
+}, { additionalProperties: true, });
+export const CodeEnvLogSummaryArraySchema = Type.Array(CodeEnvLogSummarySchema);
+export const CodeEnvLogResultSchema = Type.Object({
+    log: Type.String(),
+    bytes: Type.Number(),
+    truncated: Type.Boolean(),
+    tailed: Type.Boolean(),
+}, { additionalProperties: false, });
+export const CodeEnvGetLogOptionsSchema = Type.Object({
+    maxBytes: Type.Optional(Type.Number()),
+    maxLines: Type.Optional(Type.Number()),
+}, { additionalProperties: false, });
+export const CodeEnvUpdateImagesOptionsSchema = Type.Object({
+    envVersion: Type.Optional(Type.String()),
+    wait: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false, });
+export const CodeEnvVersionForProjectSchema = Type.Object({
+    version: Type.Optional(Type.String()),
+    bundleId: Type.Optional(Type.String()),
+}, { additionalProperties: true, });
 export const CodeEnvActionResultSchema = Type.Record(Type.String(), Type.Unknown());
 export const CodeEnvCreateOptionsSchema = Type.Object({
     envLang: Type.String(),
@@ -469,6 +492,7 @@ export const CodeEnvPackageListSchema = Type.Union([
 export const CodeEnvSetPackagesOptionsSchema = Type.Object({
     packages: CodeEnvPackageListSchema,
     installCorePackages: Type.Optional(Type.Boolean()),
+    expectHash: Type.Optional(Type.String()),
 }, { additionalProperties: false, });
 export const CodeEnvUpdatePackagesOptionsSchema = Type.Object({
     forceRebuildEnv: Type.Optional(Type.Boolean()),
@@ -569,7 +593,9 @@ export const DataQualityComputeResultSchema = Type.Object({
 // ---------------------------------------------------------------------------
 export const JupyterCellSchema = Type.Object({
     cell_type: Type.String(),
-    source: Type.Array(Type.String()),
+    // nbformat permits a cell's source to be either a single string or an
+    // array of strings; DSS returns whichever form the notebook carries.
+    source: Type.Union([Type.String(), Type.Array(Type.String()),]),
     metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
     outputs: Type.Optional(Type.Array(Type.Unknown())),
     execution_count: Type.Optional(Type.Union([Type.Null(), Type.Number(),])),
@@ -617,6 +643,8 @@ export const SqlNotebookContentSchema = Type.Object({
     connection: Type.String(),
     cells: Type.Array(SqlNotebookCellSchema),
 }, { additionalProperties: true, });
+/** Execution history of a SQL notebook: cell ID to the runs recorded for it. */
+export const SqlNotebookHistorySchema = Type.Record(Type.String(), Type.Array(Type.Unknown()));
 // ---------------------------------------------------------------------------
 // SQL Queries
 // ---------------------------------------------------------------------------
@@ -642,6 +670,7 @@ export const FlowMapOptionsSchema = Type.Object({
     maxNodes: Type.Optional(Type.Number()),
     maxEdges: Type.Optional(Type.Number()),
     includeRaw: Type.Optional(Type.Boolean()),
+    render: Type.Optional(Type.Union([Type.Literal("ascii"), Type.Literal("mermaid"),])),
 });
 // ---------------------------------------------------------------------------
 // Project Git

package/plugin.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
 	"name": "dataiku-sdk",
-	"version": "3.0.0",
+	"version": "3.2.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",