dataiku-sdk 0.1.2 → 0.2.1

package/dist/src/auth.d.ts

@@ -0,0 +1,4 @@
+export declare function validateCredentials(url: string, apiKey: string): Promise<{
+    valid: boolean;
+    error?: string;
+}>;

package/dist/src/auth.js

@@ -0,0 +1,20 @@
+import { DataikuClient, } from "./client.js";
+import { DataikuError, } from "./errors.js";
+export async function validateCredentials(url, apiKey) {
+    try {
+        const client = new DataikuClient({
+            url,
+            apiKey,
+            requestTimeoutMs: 10_000,
+            retryMaxAttempts: 1,
+        });
+        await client.projects.list();
+        return { valid: true, };
+    }
+    catch (err) {
+        if (err instanceof DataikuError) {
+            return { valid: false, error: err.message, };
+        }
+        return { valid: false, error: err instanceof Error ? err.message : String(err), };
+    }
+}

package/dist/src/cli.js

@@ -1,12 +1,36 @@
 #!/usr/bin/env node
 import { readFileSync, } from "node:fs";
+import { writeFile, } from "node:fs/promises";
 import { dirname, resolve, } from "node:path";
+import { createInterface, } from "node:readline";
+import { Writable, } from "node:stream";
 import { fileURLToPath, } from "node:url";
+import { validateCredentials, } from "./auth.js";
 import { DataikuClient, } from "./client.js";
+import { deleteCredentials, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 import { DataikuError, } from "./errors.js";
+import { AGENTS, detectAgents, installSkill, } from "./skill.js";
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------
+const CLI_VERSION = (() => {
+    try {
+        let dir = dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 5; i++) {
+            const candidate = resolve(dir, "package.json");
+            try {
+                return JSON.parse(readFileSync(candidate, "utf-8")).version;
+            }
+            catch {
+                dir = dirname(dir);
+            }
+        }
+        return "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();
 function num(v) {
     if (typeof v !== "string")
         return undefined;
@@ -63,9 +87,29 @@ function formatLineDiff(remoteName, localPath, remoteContent, localContent) {
 function parseOutputFormat(v) {
     if (v === undefined)
         return "json";
-    if (v === "json" || v === "quiet" || v === "tsv")
+    if (v === "json" || v === "quiet" || v === "table" || v === "tsv")
         return v;
-    throw new UsageError(`Invalid --format value: ${String(v)}. Use json, tsv, or quiet.`);
+    throw new UsageError(`Invalid --format value: ${String(v)}. Use json, tsv, table, or quiet.`);
+}
+function writeTable(items) {
+    if (items.length === 0)
+        return;
+    const keys = Object.keys(items[0]);
+    const maxWidths = keys.map((k) => {
+        const values = items.map((item) => String(item[k] ?? ""));
+        return Math.min(40, Math.max(k.length, ...values.map((v) => v.length)));
+    });
+    process.stdout.write(`${keys.map((k, i) => k.padEnd(maxWidths[i])).join("  ")}\n`);
+    process.stdout.write(`${maxWidths.map((w) => "-".repeat(w)).join("  ")}\n`);
+    for (const item of items) {
+        const row = keys.map((k, i) => {
+            const val = String(item[k] ?? "");
+            return (val.length > maxWidths[i]
+                ? `${val.slice(0, maxWidths[i] - 1)}\u2026`
+                : val).padEnd(maxWidths[i]);
+        });
+        process.stdout.write(`${row.join("  ")}\n`);
+    }
 }
 function writeCommandResult(result, format) {
     if (result === undefined || result === null) {
@@ -84,9 +128,9 @@ function writeCommandResult(result, format) {
     }
     if (format === "quiet")
         return;
-    if (format === "tsv"
-        && Array.isArray(result)
-        && result.every((item) => item !== null && typeof item === "object" && !Array.isArray(item))) {
+    const isArrayOfObjects = Array.isArray(result)
+        && result.every((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+    if (format === "tsv" && isArrayOfObjects) {
         const items = result;
         if (items.length === 0)
             return;
@@ -97,8 +141,23 @@ function writeCommandResult(result, format) {
         }
         return;
     }
+    if (format === "table" && isArrayOfObjects) {
+        writeTable(result);
+        return;
+    }
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 }
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+const BOOLEAN_FLAGS = new Set(["help", "verbose", "version", "stdin", "global", "list-agents",]);
+const SHORT_FLAGS = {
+    h: "help",
+    v: "verbose",
+    V: "version",
+    f: "format",
+    o: "output",
+};
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -115,16 +174,43 @@ function parseArgs(argv) {
                 flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
             }
             else {
-                const next = argv[i + 1];
-                if (next !== undefined && !next.startsWith("--")) {
-                    flags[arg.slice(2)] = next;
-                    i++;
+                const flagName = arg.slice(2);
+                if (BOOLEAN_FLAGS.has(flagName)) {
+                    flags[flagName] = true;
                 }
                 else {
-                    flags[arg.slice(2)] = true;
+                    const next = argv[i + 1];
+                    if (next !== undefined && !next.startsWith("-")) {
+                        flags[flagName] = next;
+                        i++;
+                    }
+                    else {
+                        flags[flagName] = true;
+                    }
                 }
             }
         }
+        else if (arg.length === 2 && arg[0] === "-" && arg[1] !== "-") {
+            const long = SHORT_FLAGS[arg[1]];
+            if (long) {
+                if (BOOLEAN_FLAGS.has(long)) {
+                    flags[long] = true;
+                }
+                else {
+                    const next = argv[i + 1];
+                    if (next !== undefined && !next.startsWith("-")) {
+                        flags[long] = next;
+                        i++;
+                    }
+                    else {
+                        flags[long] = true;
+                    }
+                }
+            }
+            else {
+                positional.push(arg);
+            }
+        }
         else {
             positional.push(arg);
         }
@@ -325,6 +411,33 @@ const commands = {
             },
             usage: "dss recipe update <name> [--data '{...}' | --data-file PATH | --stdin] [--project-key KEY]",
         },
+        "get-payload": {
+            handler: async (c, a, f) => {
+                requireArgs(a, 1, "dss recipe get-payload <name>");
+                const payload = await c.recipes.getPayload(a[0], {
+                    projectKey: f["project-key"],
+                });
+                if (typeof f["output"] === "string") {
+                    await writeFile(f["output"], payload, "utf-8");
+                    return f["output"];
+                }
+                return payload;
+            },
+            usage: "dss recipe get-payload <name> [--output PATH] [--project-key KEY]",
+        },
+        "set-payload": {
+            handler: async (c, a, f) => {
+                requireArgs(a, 1, "dss recipe set-payload <name> --file PATH");
+                const filePath = f["file"];
+                if (!filePath)
+                    throw new UsageError("--file is required.");
+                const content = readFileSync(filePath, "utf-8");
+                await c.recipes.setPayload(a[0], content, {
+                    projectKey: f["project-key"],
+                });
+            },
+            usage: "dss recipe set-payload <name> --file PATH [--project-key KEY]",
+        },
     },
     job: {
         list: {
@@ -648,21 +761,35 @@ const commands = {
 // ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
-const RESOURCE_NAMES = Object.keys(commands).sort();
+const RESOURCE_NAMES = [...Object.keys(commands), "auth", "install-skill",].sort();
 function printTopLevelHelp() {
     const lines = [
         "Usage: dss <resource> <action> [args...] [--flags]",
         "",
         "Global flags:",
-        "  --url URL            Dataiku DSS base URL (env: DATAIKU_URL)",
-        "  --api-key KEY        API key              (env: DATAIKU_API_KEY)",
-        "  --project-key KEY    Default project key   (env: DATAIKU_PROJECT_KEY)",
-        "  --format FORMAT      Output format: json|tsv|quiet",
-        "  --verbose            Log HTTP requests to stderr",
-        "  --help               Show help",
+        "  -h, --help               Show help",
+        "  -v, --verbose            Log HTTP requests to stderr",
+        "  -V, --version            Show version",
+        "  -f, --format FORMAT      Output format: json|tsv|table|quiet",
+        "  -o, --output PATH        Write output to file (recipe get-payload)",
+        "      --url URL            Dataiku DSS base URL (env: DATAIKU_URL)",
+        "      --api-key KEY        API key              (env: DATAIKU_API_KEY)",
+        "      --project-key KEY    Default project key   (env: DATAIKU_PROJECT_KEY)",
+        "      --timeout MS         Request timeout in ms  (default: 30000)",
         "",
         "Resources:",
         ...RESOURCE_NAMES.map((r) => `  ${r}`),
+        "",
+        "Quick start:",
+        "  dss auth login                         Save DSS credentials",
+        "  dss auth status                        Verify connection",
+        "  dss project list                       List accessible projects",
+        "  dss dataset list                       List datasets in default project",
+        "  dss dataset preview <name>             Preview dataset rows as CSV",
+        "  dss recipe get-payload <name>          Print recipe code to stdout",
+        "  dss recipe download-code <name>        Download recipe code to a file",
+        "  dss job log <id>                       View job log output",
+        "  dss install-skill                      Install agent skill for coding agents",
     ];
     process.stderr.write(`${lines.join("\n")}\n`);
 }
@@ -728,11 +855,133 @@ function loadEnvFile() {
     }
 }
 // ---------------------------------------------------------------------------
+// Auth commands (run before client creation)
+// ---------------------------------------------------------------------------
+const AUTH_ACTIONS = {
+    login: {
+        handler: async (flags) => {
+            let { url, apiKey, projectKey, } = resolveCredentials(flags);
+            if (!url || !apiKey) {
+                if (!process.stdin.isTTY) {
+                    throw new UsageError("Missing --url and/or --api-key. Provide them as flags or run interactively.");
+                }
+                if (!url)
+                    url = await promptLine("DSS URL: ");
+                if (!apiKey)
+                    apiKey = await promptSecret("API key: ");
+                if (!projectKey)
+                    projectKey = (await promptLine("Project key (optional): ")) || undefined;
+            }
+            if (!url)
+                throw new UsageError("URL is required.");
+            if (!apiKey)
+                throw new UsageError("API key is required.");
+            process.stderr.write("Validating credentials... ");
+            const result = await validateCredentials(url, apiKey);
+            if (!result.valid) {
+                process.stderr.write(`✗ Failed\n`);
+                throw new DataikuError(0, "Authentication Failed", result.error ?? "Credential validation failed");
+            }
+            process.stderr.write("\u2713 Connected\n");
+            saveCredentials({ url, apiKey, projectKey, });
+            process.stderr.write(`Credentials saved to ${getCredentialsPath()}\n`);
+        },
+        usage: "dss auth login [--url URL] [--api-key KEY] [--project-key KEY]",
+    },
+    status: {
+        handler: async (_flags) => {
+            const creds = loadCredentials();
+            if (!creds) {
+                process.stderr.write("No saved credentials. Run: dss auth login\n");
+                return;
+            }
+            const lines = [
+                `URL:         ${creds.url}`,
+                `API key:     ${maskApiKey(creds.apiKey)}`,
+                `Project key: ${creds.projectKey ?? "(not set)"}`,
+            ];
+            for (const line of lines)
+                process.stderr.write(`${line}\n`);
+            const result = await validateCredentials(creds.url, creds.apiKey);
+            if (result.valid) {
+                process.stderr.write("Connection:  \u2713 Valid\n");
+            }
+            else {
+                process.stderr.write(`Connection:  \u2717 Failed (${result.error ?? "unknown error"})\n`);
+            }
+            process.stderr.write(`Config:      ${getCredentialsPath()}\n`);
+        },
+        usage: "dss auth status",
+    },
+    logout: {
+        handler: async (_flags) => {
+            deleteCredentials();
+            process.stderr.write("Credentials removed.\n");
+        },
+        usage: "dss auth logout",
+    },
+};
+// ---------------------------------------------------------------------------
+// Interactive prompts
+// ---------------------------------------------------------------------------
+function promptLine(label) {
+    return new Promise((res, rej) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr, });
+        rl.on("close", () => rej(new UsageError("Input closed before a value was provided.")));
+        rl.question(label, (answer) => {
+            rl.close();
+            res(answer.trim());
+        });
+    });
+}
+function promptSecret(label) {
+    return new Promise((res, rej) => {
+        const muted = new Writable({
+            write(_chunk, _encoding, cb) {
+                cb();
+            },
+        });
+        const rl = createInterface({ input: process.stdin, output: muted, terminal: true, });
+        rl.on("close", () => rej(new UsageError("Input closed before a value was provided.")));
+        process.stderr.write(label);
+        rl.question("", (answer) => {
+            rl.close();
+            process.stderr.write("\n");
+            res(answer.trim());
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Credential resolution
+// ---------------------------------------------------------------------------
+function resolveCredentials(flags) {
+    let url = flags["url"];
+    let apiKey = flags["api-key"];
+    let projectKey = flags["project-key"];
+    url ??= process.env.DATAIKU_URL;
+    apiKey ??= process.env.DATAIKU_API_KEY;
+    projectKey ??= process.env.DATAIKU_PROJECT_KEY;
+    if (!url || !apiKey) {
+        const saved = loadCredentials();
+        if (saved) {
+            url ||= saved.url;
+            apiKey ||= saved.apiKey;
+            projectKey ??= saved.projectKey;
+        }
+    }
+    return { url: url ?? "", apiKey: apiKey ?? "", projectKey, };
+}
+// ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 async function main() {
     loadEnvFile();
     const { positional, flags, } = parseArgs(process.argv.slice(2));
+    // --version
+    if (flags["version"] === true) {
+        process.stdout.write(`${CLI_VERSION}\n`);
+        process.exit(0);
+    }
     // Top-level help
     if (positional.length === 0 || (positional.length === 0 && flags["help"])) {
         printTopLevelHelp();
@@ -741,13 +990,91 @@ async function main() {
         process.exit(1);
     }
     const resource = positional[0];
+    // Auth commands — dispatched before client creation
+    if (resource === "auth") {
+        const action = positional[1];
+        if (!action || flags["help"] === true) {
+            const lines = [
+                "Usage: dss auth <action> [--flags]",
+                "",
+                "Actions:",
+                ...Object.entries(AUTH_ACTIONS).map(([name, meta,]) => `  ${name}  \u2192  ${meta.usage}`),
+            ];
+            process.stderr.write(`${lines.join("\n")}\n`);
+            process.exit(flags["help"] === true ? 0 : 1);
+        }
+        const authMeta = AUTH_ACTIONS[action];
+        if (!authMeta) {
+            process.stderr.write(`Unknown action: auth ${action}\nAvailable: ${Object.keys(AUTH_ACTIONS).join(", ")}\n`);
+            process.exit(1);
+        }
+        await authMeta.handler(flags);
+        return;
+    }
+    // install-skill — dispatched before client creation
+    if (resource === "install-skill") {
+        if (flags["help"] === true) {
+            const lines = [
+                "Usage: dss install-skill [--global] [--agent NAME] [--list-agents]",
+                "",
+                "Install the dataiku-dss agent skill for detected coding agents.",
+                "",
+                "Flags:",
+                "  --global         Install to user-level global scope (default: project)",
+                "  --agent NAME     Target a specific agent: claude, codex, cursor, pi, omp",
+                "  --list-agents    Print detected agents and exit",
+            ];
+            process.stderr.write(`${lines.join("\n")}\n`);
+            process.exit(0);
+        }
+        const listOnly = flags["list-agents"] === true;
+        const agentFilter = typeof flags["agent"] === "string" ? flags["agent"] : undefined;
+        const isGlobal = flags["global"] === true;
+        // Resolve target agents
+        let targets;
+        if (agentFilter) {
+            const def = AGENTS[agentFilter];
+            if (!def) {
+                throw new UsageError(`Unknown agent: ${agentFilter}. Available: ${Object.keys(AGENTS).join(", ")}`);
+            }
+            targets = [{ id: agentFilter, def, via: "flag", },];
+        }
+        else {
+            targets = detectAgents();
+        }
+        if (listOnly) {
+            if (targets.length === 0) {
+                process.stderr.write("No coding agents detected.\n");
+            }
+            else {
+                process.stderr.write("Detected agents:\n");
+                for (const t of targets) {
+                    process.stderr.write(`  ${t.id}  (${t.def.name}, via ${t.via})\n`);
+                }
+            }
+            process.exit(0);
+        }
+        if (targets.length === 0) {
+            throw new UsageError("No coding agents detected. Install one (claude, codex, cursor, pi, omp) or use --agent NAME.");
+        }
+        const scope = isGlobal ? "global" : "project";
+        process.stderr.write(`Installing dataiku-dss skill (${scope} scope):\n`);
+        const results = installSkill(targets, { global: isGlobal, cwd: process.cwd(), });
+        for (const r of results) {
+            process.stderr.write(`  ${r.agent}  \u2192  ${r.path}\n`);
+        }
+        if (results.length > 0) {
+            process.stderr.write(`\nDone. ${results.length} skill(s) installed.\n`);
+        }
+        return;
+    }
     // Unknown resource
     if (!commands[resource]) {
         if (flags["help"]) {
             printTopLevelHelp();
             process.exit(0);
         }
-        process.stderr.write(`Unknown resource: ${resource}\nAvailable: ${RESOURCE_NAMES.join(", ")}\n`);
+        process.stderr.write(`Unknown resource: ${resource} \nAvailable: ${RESOURCE_NAMES.join(", ")} \n`);
         process.exit(1);
     }
     // Resource-level help
@@ -763,7 +1090,7 @@ async function main() {
     const actionMeta = commands[resource][action];
     // Unknown action
     if (!actionMeta) {
-        process.stderr.write(`Unknown action: ${resource} ${action}\nAvailable actions for ${resource}: ${Object.keys(commands[resource]).join(", ")}\n`);
+        process.stderr.write(`Unknown action: ${resource} ${action} \nAvailable actions for ${resource}: ${Object.keys(commands[resource]).join(", ")} \n`);
         process.exit(1);
     }
     // Action-level help
@@ -771,22 +1098,21 @@ async function main() {
         printActionHelp(resource, action);
         process.exit(0);
     }
-    // Validate config
-    const url = flags["url"] ?? process.env.DATAIKU_URL ?? "";
-    const apiKey = flags["api-key"] ?? process.env.DATAIKU_API_KEY ?? "";
+    // Resolve credentials: flags > env > saved > .env
+    const { url, apiKey, projectKey, } = resolveCredentials(flags);
     if (!url) {
-        process.stderr.write(`${JSON.stringify({ error: "Missing Dataiku URL. Set DATAIKU_URL or pass --url.", }, null, 2)}\n`);
-        process.exit(1);
+        throw new UsageError("Missing Dataiku URL. Set DATAIKU_URL, pass --url, or run: dss auth login");
     }
     if (!apiKey) {
-        process.stderr.write(`${JSON.stringify({ error: "Missing API key. Set DATAIKU_API_KEY or pass --api-key.", }, null, 2)}\n`);
-        process.exit(1);
+        throw new UsageError("Missing API key. Set DATAIKU_API_KEY, pass --api-key, or run: dss auth login");
     }
+    const requestTimeoutMs = num(flags["timeout"]) ?? undefined;
     const client = new DataikuClient({
         url,
         apiKey,
-        projectKey: flags["project-key"] ?? process.env.DATAIKU_PROJECT_KEY,
+        projectKey,
         verbose: flags["verbose"] === true,
+        requestTimeoutMs,
     });
     const args = positional.slice(2);
     const format = parseOutputFormat(flags["format"]);
@@ -795,7 +1121,7 @@ async function main() {
 }
 main().catch((err) => {
     if (err instanceof UsageError) {
-        process.stderr.write(`${err.message}\n`);
+        process.stderr.write(`${err.message} \n`);
         process.exit(1);
     }
     if (err instanceof DataikuError) {
@@ -806,10 +1132,10 @@ main().catch((err) => {
         };
         if (err.retryHint)
             payload.retryHint = err.retryHint;
-        process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        process.stderr.write(`${JSON.stringify(payload, null, 2)} \n`);
         process.exit(err.category === "transient" ? 3 : 2);
     }
     const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`${JSON.stringify({ error: message, }, null, 2)}\n`);
+    process.stderr.write(`${JSON.stringify({ error: message, }, null, 2)} \n`);
     process.exit(1);
 });

package/dist/src/config.d.ts

@@ -0,0 +1,11 @@
+export interface DssCredentials {
+    url: string;
+    apiKey: string;
+    projectKey?: string;
+}
+export declare function getConfigDir(): string;
+export declare function getCredentialsPath(): string;
+export declare function loadCredentials(): DssCredentials | null;
+export declare function saveCredentials(creds: DssCredentials): void;
+export declare function deleteCredentials(): void;
+export declare function maskApiKey(apiKey: string): string;

package/dist/src/config.js

@@ -0,0 +1,64 @@
+import { chmodSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { dirname, join, resolve, } from "node:path";
+export function getConfigDir() {
+    if (process.env.DSS_CONFIG_DIR)
+        return process.env.DSS_CONFIG_DIR;
+    if (process.env.XDG_CONFIG_HOME)
+        return resolve(process.env.XDG_CONFIG_HOME, "dataiku");
+    if (process.platform === "win32" && process.env.APPDATA) {
+        return resolve(process.env.APPDATA, "dataiku");
+    }
+    return resolve(homedir(), ".config", "dataiku");
+}
+export function getCredentialsPath() {
+    return join(getConfigDir(), "credentials.json");
+}
+export function loadCredentials() {
+    try {
+        const raw = readFileSync(getCredentialsPath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed
+            || typeof parsed !== "object"
+            || Array.isArray(parsed)
+            || typeof parsed.url !== "string"
+            || typeof parsed.apiKey !== "string") {
+            return null;
+        }
+        const obj = parsed;
+        return {
+            url: obj.url,
+            apiKey: obj.apiKey,
+            projectKey: typeof obj.projectKey === "string" ? obj.projectKey : undefined,
+        };
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export function saveCredentials(creds) {
+    const path = getCredentialsPath();
+    mkdirSync(dirname(path), { recursive: true, });
+    const data = { url: creds.url, apiKey: creds.apiKey, };
+    if (creds.projectKey)
+        data.projectKey = creds.projectKey;
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+    chmodSync(path, 0o600);
+}
+export function deleteCredentials() {
+    try {
+        unlinkSync(getCredentialsPath());
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+export function maskApiKey(apiKey) {
+    if (apiKey.length <= 12)
+        return "***";
+    return `${apiKey.slice(0, 6)}...${apiKey.slice(-6)}`;
+}

package/dist/src/index.d.ts

@@ -1,4 +1,6 @@
 export { DataikuClient, type DataikuClientConfig, } from "./client.js";
+export { validateCredentials, } from "./auth.js";
+export { deleteCredentials, type DssCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
 export { CodeEnvsResource, } from "./resources/code-envs.js";
 export { ConnectionsResource, } from "./resources/connections.js";

package/dist/src/index.js

@@ -1,5 +1,8 @@
 // Client
 export { DataikuClient, } from "./client.js";
+// Auth & Config
+export { validateCredentials, } from "./auth.js";
+export { deleteCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 // Errors
 export { DataikuError, } from "./errors.js";
 // Resources (for advanced use / extension)

package/dist/src/resources/recipes.d.ts

@@ -23,14 +23,22 @@ export declare class RecipesResource extends BaseResource {
      */
     update(recipeName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     /**
-     * Download a recipe code payload to a local file.
+    * Download a recipe code payload to a local file.
 
-     * Returns the path to the written file.
-     */
+    * Returns the path to the written file.
+    */
     downloadCode(recipeName: string, opts?: {
         outputPath?: string;
         projectKey?: string;
     }): Promise<string>;
+    /** Get only the code payload of a recipe as a raw string. */
+    getPayload(recipeName: string, opts?: {
+        projectKey?: string;
+    }): Promise<string>;
+    /** Replace only the code payload of a recipe. */
+    setPayload(recipeName: string, payload: string, opts?: {
+        projectKey?: string;
+    }): Promise<void>;
     /** Delete a recipe. */
     delete(recipeName: string, projectKey?: string): Promise<void>;
     /**