dataiku-sdk 0.2.3 → 0.2.4

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

@@ -14,9 +14,9 @@ export type SafeParseResult<T> = {
     errors: string[];
 };
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export declare function safeParseSchema<S extends TSchema>(schema: S, data: unknown): SafeParseResult<Static<S>>;
 export declare const ProjectSummarySchema: import("@sinclair/typebox").TObject<{

package/dist/packages/types/src/index.js

@@ -12,15 +12,65 @@ export function parseSchema(schema, data) {
     return data;
 }
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Format invalid values for validation errors without throwing on BigInt, circular,
+ * function, symbol, or other non-JSON-serializable input.
+ */
+function formatInvalidValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "bigint")
+        return `${value.toString()}n`;
+    if (typeof value === "symbol") {
+        return value.description === undefined ? "Symbol()" : `Symbol(${value.description})`;
+    }
+    if (typeof value === "function") {
+        return value.name ? `[Function ${value.name}]` : "[Function anonymous]";
+    }
+    const seen = new WeakSet();
+    try {
+        const json = JSON.stringify(value, (_key, nestedValue) => {
+            if (typeof nestedValue === "bigint")
+                return `${nestedValue.toString()}n`;
+            if (typeof nestedValue === "symbol") {
+                return nestedValue.description === undefined
+                    ? "Symbol()"
+                    : `Symbol(${nestedValue.description})`;
+            }
+            if (typeof nestedValue === "function") {
+                return nestedValue.name
+                    ? `[Function ${nestedValue.name}]`
+                    : "[Function anonymous]";
+            }
+            if (nestedValue !== null && typeof nestedValue === "object") {
+                if (seen.has(nestedValue))
+                    return "[Circular]";
+                seen.add(nestedValue);
+            }
+            return nestedValue;
+        });
+        if (json !== undefined)
+            return json;
+    }
+    catch {
+        // Ignore serialization failures and fall back to a safer summary below.
+    }
+    try {
+        return Object.prototype.toString.call(value);
+    }
+    catch {
+        return "[Unformattable value]";
+    }
+}
+/**
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export function safeParseSchema(schema, data) {
     if (Value.Check(schema, data)) {
         return { success: true, data: data, };
     }
-    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${JSON.stringify(e.value)})`);
+    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${formatInvalidValue(e.value)})`);
     return { success: false, data: data, errors, };
 }
 // ---------------------------------------------------------------------------

package/dist/src/auth.d.ts

@@ -1,4 +1,7 @@
-export declare function validateCredentials(url: string, apiKey: string): Promise<{
+import { DataikuError } from "./errors.js";
+export interface CredentialValidationResult {
     valid: boolean;
     error?: string;
-}>;
+    dataikuError?: DataikuError;
+}
+export declare function validateCredentials(url: string, apiKey: string): Promise<CredentialValidationResult>;

package/dist/src/auth.js

@@ -13,7 +13,7 @@ export async function validateCredentials(url, apiKey) {
     }
     catch (err) {
         if (err instanceof DataikuError) {
-            return { valid: false, error: err.message, };
+            return { valid: false, error: err.message, dataikuError: err, };
         }
         return { valid: false, error: err instanceof Error ? err.message : String(err), };
     }

package/dist/src/cli.js

@@ -150,7 +150,18 @@ function writeCommandResult(result, format) {
 // ---------------------------------------------------------------------------
 // Arg parsing
 // ---------------------------------------------------------------------------
-const BOOLEAN_FLAGS = new Set(["help", "verbose", "version", "stdin", "global", "list-agents",]);
+const BOOLEAN_FLAGS = new Set([
+    "help",
+    "verbose",
+    "version",
+    "stdin",
+    "global",
+    "list-agents",
+    "include-raw",
+    "include-payload",
+    "include-logs",
+    "replace",
+]);
 const SHORT_FLAGS = {
     h: "help",
     v: "verbose",
@@ -162,6 +173,15 @@ const SHORT_FLAGS = {
 const FLAG_ALIASES = {
     project: "project-key",
 };
+function isNegativeNumberToken(value) {
+    return value.startsWith("-") && Number.isFinite(Number(value));
+}
+function requireFlagValue(flagLabel, next) {
+    if (next === undefined || (next.startsWith("-") && !isNegativeNumberToken(next))) {
+        throw new UsageError(`Flag ${flagLabel} requires a value.`);
+    }
+    return next;
+}
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -179,19 +199,15 @@ function parseArgs(argv) {
                 flags[FLAG_ALIASES[raw] ?? raw] = arg.slice(eqIdx + 1);
             }
             else {
-                const flagName = FLAG_ALIASES[arg.slice(2)] ?? arg.slice(2);
+                const rawFlagName = arg.slice(2);
+                const flagName = FLAG_ALIASES[rawFlagName] ?? rawFlagName;
                 if (BOOLEAN_FLAGS.has(flagName)) {
                     flags[flagName] = true;
                 }
                 else {
-                    const next = argv[i + 1];
-                    if (next !== undefined && !next.startsWith("-")) {
-                        flags[flagName] = next;
-                        i++;
-                    }
-                    else {
-                        flags[flagName] = true;
-                    }
+                    const next = requireFlagValue(`--${rawFlagName}`, argv[i + 1]);
+                    flags[flagName] = next;
+                    i++;
                 }
             }
         }
@@ -202,14 +218,9 @@ function parseArgs(argv) {
                     flags[long] = true;
                 }
                 else {
-                    const next = argv[i + 1];
-                    if (next !== undefined && !next.startsWith("-")) {
-                        flags[long] = next;
-                        i++;
-                    }
-                    else {
-                        flags[long] = true;
-                    }
+                    const next = requireFlagValue(`-${arg[1]}`, argv[i + 1]);
+                    flags[long] = next;
+                    i++;
                 }
             }
             else {
@@ -886,6 +897,8 @@ const AUTH_ACTIONS = {
             const result = await validateCredentials(url, apiKey);
             if (!result.valid) {
                 process.stderr.write(`✗ Failed\n`);
+                if (result.dataikuError)
+                    throw result.dataikuError;
                 throw new DataikuError(0, "Authentication Failed", result.error ?? "Credential validation failed");
             }
             process.stderr.write("\u2713 Connected\n");

package/dist/src/client.d.ts

@@ -81,9 +81,10 @@ export declare class DataikuClient {
      */
     parse<S extends TSchema>(schema: S, data: unknown): Static<S>;
     /**
-     * Validate raw data against a TypeBox schema without throwing.
-     * Always returns the data. On mismatch, fires onValidationWarning callback
-     * with the method name and error details.
+     * Validate raw data against a TypeBox schema without throwing, even when
+     * mismatched values are not JSON-serializable. Always returns the original
+     * data, and on mismatch emits onValidationWarning with the method name and
+     * error details. If the callback throws, that error still propagates.
      */
     safeParse<S extends TSchema>(schema: S, data: unknown, method: string): Static<S>;
     /** Emit a validation warning via the configured callback. */

package/dist/src/client.js

@@ -223,9 +223,10 @@ export class DataikuClient {
         return data;
     }
     /**
-     * Validate raw data against a TypeBox schema without throwing.
-     * Always returns the data. On mismatch, fires onValidationWarning callback
-     * with the method name and error details.
+     * Validate raw data against a TypeBox schema without throwing, even when
+     * mismatched values are not JSON-serializable. Always returns the original
+     * data, and on mismatch emits onValidationWarning with the method name and
+     * error details. If the callback throws, that error still propagates.
      */
     safeParse(schema, data, method) {
         const result = safeParseSchema(schema, data);

package/dist/src/skill.js

@@ -36,7 +36,7 @@ dss auth login --url https://dss.example.com --api-key YOUR_KEY
 dss auth status                      # verify connection
 \`\`\`
 
-Credentials are saved to \`~/.dss/credentials.json\`. Alternatively set environment variables:
+Credentials are saved to \`~/.config/dataiku/credentials.json\`. Alternatively set environment variables:
 
 \`\`\`bash
 export DATAIKU_URL=https://dss.example.com
@@ -206,7 +206,7 @@ export function detectAgents() {
 // ---------------------------------------------------------------------------
 // Workspace root detection
 // ---------------------------------------------------------------------------
-const WORKSPACE_MARKERS = [".git", ".cursor", ".claude", ".codex", ".vscode",];
+const WORKSPACE_MARKERS = [".git", ".cursor", ".claude", ".codex", ".pi", ".omp", ".vscode",];
 /**
  * Walk upward from startDir looking for common workspace markers.
  * Returns the first directory containing a marker, or startDir if none found.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.2.3",
+	"version": "0.2.4",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [

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

@@ -14,9 +14,9 @@ export type SafeParseResult<T> = {
     errors: string[];
 };
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export declare function safeParseSchema<S extends TSchema>(schema: S, data: unknown): SafeParseResult<Static<S>>;
 export declare const ProjectSummarySchema: import("@sinclair/typebox").TObject<{

package/packages/types/dist/index.js

@@ -12,15 +12,65 @@ export function parseSchema(schema, data) {
     return data;
 }
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Format invalid values for validation errors without throwing on BigInt, circular,
+ * function, symbol, or other non-JSON-serializable input.
+ */
+function formatInvalidValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "bigint")
+        return `${value.toString()}n`;
+    if (typeof value === "symbol") {
+        return value.description === undefined ? "Symbol()" : `Symbol(${value.description})`;
+    }
+    if (typeof value === "function") {
+        return value.name ? `[Function ${value.name}]` : "[Function anonymous]";
+    }
+    const seen = new WeakSet();
+    try {
+        const json = JSON.stringify(value, (_key, nestedValue) => {
+            if (typeof nestedValue === "bigint")
+                return `${nestedValue.toString()}n`;
+            if (typeof nestedValue === "symbol") {
+                return nestedValue.description === undefined
+                    ? "Symbol()"
+                    : `Symbol(${nestedValue.description})`;
+            }
+            if (typeof nestedValue === "function") {
+                return nestedValue.name
+                    ? `[Function ${nestedValue.name}]`
+                    : "[Function anonymous]";
+            }
+            if (nestedValue !== null && typeof nestedValue === "object") {
+                if (seen.has(nestedValue))
+                    return "[Circular]";
+                seen.add(nestedValue);
+            }
+            return nestedValue;
+        });
+        if (json !== undefined)
+            return json;
+    }
+    catch {
+        // Ignore serialization failures and fall back to a safer summary below.
+    }
+    try {
+        return Object.prototype.toString.call(value);
+    }
+    catch {
+        return "[Unformattable value]";
+    }
+}
+/**
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export function safeParseSchema(schema, data) {
     if (Value.Check(schema, data)) {
         return { success: true, data: data, };
     }
-    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${JSON.stringify(e.value)})`);
+    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${formatInvalidValue(e.value)})`);
     return { success: false, data: data, errors, };
 }
 // ---------------------------------------------------------------------------