dataiku-sdk 0.10.0 → 0.11.0

package/dist/src/cli/commands/app.js

@@ -0,0 +1,78 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, requireNoArgs, } from "../usage.js";
+export const appCommands = {
+    list: {
+        handler: (c) => c.applications.listApps(),
+        usage: "dss app list",
+        description: "List all Dataiku App templates.",
+        examples: ["dss app list",],
+    },
+    manifest: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss app manifest <appId>");
+            return c.applications.getAppManifest(a[0]);
+        },
+        usage: "dss app manifest <appId>",
+        description: "Get the manifest of a Dataiku App template.",
+        examples: ["dss app manifest my-app",],
+    },
+    instances: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss app instances <appId>");
+            return c.applications.listInstances(a[0]);
+        },
+        usage: "dss app instances <appId>",
+        description: "List instances created from a Dataiku App template.",
+        examples: ["dss app instances my-app",],
+    },
+    "create-instance": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss app create-instance <appId> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (instance creation payload).");
+            return c.applications.createInstance(a[0], body);
+        },
+        usage: "dss app create-instance <appId> (--data JSON|--data-file PATH|--stdin)",
+        description: "Create an app instance from a Dataiku App template.",
+        examples: ['dss app create-instance my-app --data \'{"targetProjectKey":"NEWPROJ"}\'',],
+    },
+    "instance-manifest": {
+        handler: (c, a, f) => {
+            requireNoArgs(a, "dss app instance-manifest [--project-key KEY]");
+            return c.applications.getInstanceManifest(f["project-key"]);
+        },
+        usage: "dss app instance-manifest [--project-key KEY]",
+        description: "Get the app manifest of a Dataiku App template or app-instance project.",
+        examples: ["dss app instance-manifest --project-key MYINSTANCE",],
+    },
+    "save-instance-manifest": {
+        handler: (c, a, f) => {
+            requireNoArgs(a, "dss app save-instance-manifest (--data JSON|--data-file PATH|--stdin) [--project-key KEY]");
+            const manifest = requiredJsonInput(f, "--data, --data-file, or --stdin is required (manifest JSON).");
+            return c.applications.saveInstanceManifest(manifest, f["project-key"]);
+        },
+        usage: "dss app save-instance-manifest (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Save the app manifest of a Dataiku App template project (homepage sections, use-as-recipe settings). Classic app-instance project manifests are read-only through this endpoint.",
+        examples: [
+            "dss app save-instance-manifest --data-file manifest.json --project-key MYAPP_TEMPLATE",
+        ],
+    },
+    "delete-instance": {
+        handler: async (c, a, f) => {
+            requireNoArgs(a, "dss app delete-instance [--project-key KEY]");
+            await c.applications.deleteInstance(f["project-key"]);
+            return { deleted: true, };
+        },
+        usage: "dss app delete-instance [--project-key KEY]",
+        description: "Delete an app-instance project (destructive: removes the instance project).",
+        examples: ["dss app delete-instance --project-key MYINSTANCE",],
+    },
+    "business-app-instance-permissions": {
+        handler: (c, a) => {
+            requireArgs(a, 3, "dss app business-app-instance-permissions <businessAppId> <instanceProjectKey> <userLogin>");
+            return c.applications.getBusinessAppInstanceUserPermissions(a[0], a[1], a[2]);
+        },
+        usage: "dss app business-app-instance-permissions <businessAppId> <instanceProjectKey> <userLogin>",
+        description: "Get a user's effective permissions on a Business App instance.",
+        examples: ["dss app business-app-instance-permissions my-bapp INSTANCEPROJ alice",],
+    },
+};

package/dist/src/cli/commands/bundle.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const bundleCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/bundle.js

@@ -0,0 +1,107 @@
+import { writeFileSync, } from "node:fs";
+import { requireArgs, UsageError, } from "../usage.js";
+export const bundleCommands = {
+    "list-exported": {
+        handler: (c, _a, f) => c.bundles.listExported(f["project-key"]),
+        usage: "dss bundle list-exported [--project-key KEY]",
+        description: "List bundles exported from a project on the Design node.",
+        examples: ["dss bundle list-exported",],
+    },
+    export: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss bundle export <bundleId> [--project-key KEY]");
+            await c.bundles.exportBundle(a[0], f["project-key"]);
+            return { exported: a[0], };
+        },
+        usage: "dss bundle export <bundleId> [--project-key KEY]",
+        description: "Create (or overwrite) an exported Design-node bundle.",
+        examples: ["dss bundle export v1",],
+    },
+    "delete-exported": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss bundle delete-exported <bundleId> [--project-key KEY]");
+            await c.bundles.deleteExported(a[0], f["project-key"]);
+            return { deleted: true, };
+        },
+        usage: "dss bundle delete-exported <bundleId> [--project-key KEY]",
+        description: "Delete an exported Design-node bundle.",
+        examples: ["dss bundle delete-exported v1",],
+    },
+    "download-exported": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss bundle download-exported <bundleId> --output PATH [--project-key KEY]");
+            const out = f["output"];
+            if (!out)
+                throw new UsageError("--output PATH is required.", "missing_required_flag");
+            const res = await c.bundles.downloadExportedArchive(a[0], f["project-key"]);
+            const buf = Buffer.from(await res.arrayBuffer());
+            writeFileSync(out, buf);
+            return { path: out, bytes: buf.length, };
+        },
+        usage: "dss bundle download-exported <bundleId> --output PATH [--project-key KEY]",
+        description: "Download an exported Design-node bundle archive to a local file.",
+        examples: ["dss bundle download-exported v1 --output ./bundle.zip",],
+    },
+    publish: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss bundle publish <bundleId> [--project-key KEY]");
+            return c.bundles.publish(a[0], f["project-key"]);
+        },
+        usage: "dss bundle publish <bundleId> [--project-key KEY]",
+        description: "Publish a Design-node bundle to the Project Deployer.",
+        examples: ["dss bundle publish v1",],
+    },
+    "list-imported": {
+        handler: (c, _a, f) => c.bundles.listImported(f["project-key"]),
+        usage: "dss bundle list-imported [--project-key KEY]",
+        description: "List bundles imported into a project on the Automation node.",
+        examples: ["dss bundle list-imported",],
+    },
+    "import-from-archive": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss bundle import-from-archive <serverArchivePath> [--project-key KEY]");
+            return c.bundles.importFromArchive(a[0], f["project-key"]);
+        },
+        usage: "dss bundle import-from-archive <serverArchivePath> [--project-key KEY]",
+        description: "Import a server-side bundle archive into an Automation-node project.",
+        examples: ["dss bundle import-from-archive /data/bundles/v1.zip",],
+    },
+    "import-from-stream": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss bundle import-from-stream <filePath> [--project-key KEY]");
+            await c.bundles.importFromStream(a[0], f["project-key"]);
+            return { imported: true, };
+        },
+        usage: "dss bundle import-from-stream <filePath> [--project-key KEY]",
+        description: "Upload and import a local bundle archive into an Automation-node project.",
+        examples: ["dss bundle import-from-stream ./v1.zip",],
+    },
+    activate: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss bundle activate <bundleId> [--project-key KEY]");
+            return c.bundles.activate(a[0], f["project-key"]);
+        },
+        usage: "dss bundle activate <bundleId> [--project-key KEY]",
+        description: "Activate an imported Automation-node bundle.",
+        examples: ["dss bundle activate v1",],
+    },
+    preload: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss bundle preload <bundleId> [--project-key KEY]");
+            return c.bundles.preload(a[0], f["project-key"]);
+        },
+        usage: "dss bundle preload <bundleId> [--project-key KEY]",
+        description: "Preload an imported Automation-node bundle (stage data/models).",
+        examples: ["dss bundle preload v1",],
+    },
+    "delete-imported": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss bundle delete-imported <bundleId> [--project-key KEY]");
+            await c.bundles.deleteImported(a[0], f["project-key"]);
+            return { deleted: true, };
+        },
+        usage: "dss bundle delete-imported <bundleId> [--project-key KEY]",
+        description: "Delete an imported Automation-node bundle.",
+        examples: ["dss bundle delete-imported v1",],
+    },
+};

package/dist/src/cli/commands/business-app.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const businessAppCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/business-app.js

@@ -0,0 +1,76 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const businessAppCommands = {
+    list: {
+        handler: (c) => c.applications.listBusinessApps(),
+        usage: "dss business-app list",
+        description: "List all Business Apps.",
+        examples: ["dss business-app list",],
+    },
+    get: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss business-app get <id>");
+            return c.applications.getBusinessApp(a[0]);
+        },
+        usage: "dss business-app get <id>",
+        description: "Get Business App details.",
+        examples: ["dss business-app get my-bapp",],
+    },
+    settings: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss business-app settings <id>");
+            return c.applications.getBusinessAppSettings(a[0]);
+        },
+        usage: "dss business-app settings <id>",
+        description: "Get Business App settings.",
+        examples: ["dss business-app settings my-bapp",],
+    },
+    "save-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss business-app save-settings <id> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (settings JSON).");
+            return c.applications.saveBusinessAppSettings(a[0], body);
+        },
+        usage: "dss business-app save-settings <id> (--data JSON|--data-file PATH|--stdin)",
+        description: "Save Business App settings (admin only; includes connection remapping).",
+        examples: ["dss business-app save-settings my-bapp --data-file settings.json",],
+    },
+    instances: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss business-app instances <id>");
+            return c.applications.listBusinessAppInstances(a[0]);
+        },
+        usage: "dss business-app instances <id>",
+        description: "List instances of a Business App.",
+        examples: ["dss business-app instances my-bapp",],
+    },
+    "create-instance": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss business-app create-instance <id> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (instance payload).");
+            return c.applications.createBusinessAppInstance(a[0], body);
+        },
+        usage: "dss business-app create-instance <id> (--data JSON|--data-file PATH|--stdin)",
+        description: "Create an instance of a Business App.",
+        examples: ["dss business-app create-instance my-bapp --data '{}'",],
+    },
+    "upgrade-instance": {
+        handler: (c, a) => {
+            requireArgs(a, 2, "dss business-app upgrade-instance <id> <projectKey>");
+            return c.applications.upgradeBusinessAppInstance(a[0], a[1]);
+        },
+        usage: "dss business-app upgrade-instance <id> <projectKey>",
+        description: "Upgrade a Business App instance to the latest version.",
+        examples: ["dss business-app upgrade-instance my-bapp INSTANCEPROJ",],
+    },
+    "install-from-archive": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss business-app install-from-archive <filePath>");
+            await c.applications.installBusinessAppFromArchive(a[0]);
+            return { installed: true, };
+        },
+        usage: "dss business-app install-from-archive <filePath>",
+        description: "Install or upgrade a Business App from a zip archive (admin only).",
+        examples: ["dss business-app install-from-archive ./my-bapp.zip",],
+    },
+};

package/dist/src/cli/commands/code-env.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const codeEnvCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/code-env.js

@@ -0,0 +1,255 @@
+import { readFileSync, } from "node:fs";
+import { json, jsonInput, parseBooleanOption, } from "../coerce.js";
+import { isNotFoundError, readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+function codeEnvWait(flags) {
+    return flags["no-wait"] !== true;
+}
+function codeEnvParams(flags) {
+    const params = json(flags["params"]) ?? jsonInput(flags) ?? {};
+    if (typeof flags["python-interpreter"] === "string") {
+        params.pythonInterpreter = flags["python-interpreter"];
+    }
+    return params;
+}
+function splitPackageSpec(raw) {
+    return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function codeEnvPackageList(flags) {
+    const packages = [];
+    if (typeof flags["file"] === "string") {
+        packages.push(...splitPackageSpec(readFileSync(flags["file"], "utf-8")));
+    }
+    if (typeof flags["packages"] === "string") {
+        packages.push(...splitPackageSpec(flags["packages"]));
+    }
+    if (typeof flags["package"] === "string") {
+        packages.push(...splitPackageSpec(flags["package"]));
+    }
+    if (packages.length === 0) {
+        throw new UsageError("--packages, --package, or --file is required. Use newline-separated package specs for version constraints.");
+    }
+    return packages;
+}
+export const codeEnvCommands = {
+    list: {
+        handler: (c, _a, f) => c.codeEnvs.list({
+            envLang: f["lang"],
+        }),
+        usage: "dss code-env list [--lang LANG]",
+        description: "List code environments.",
+        examples: ["dss code-env list", "dss code-env list --lang PYTHON",],
+    },
+    get: {
+        handler: (c, a) => {
+            requireArgs(a, 2, "dss code-env get <lang> <name>");
+            return c.codeEnvs.get(a[0], a[1]);
+        },
+        usage: "dss code-env get <lang> <name>",
+        description: "Get code environment details.",
+        examples: ["dss code-env get PYTHON my_env",],
+    },
+    "get-definition": {
+        handler: (c, a) => {
+            requireArgs(a, 2, "dss code-env get-definition <lang> <name>");
+            return c.codeEnvs.getDefinition(a[0], a[1]);
+        },
+        usage: "dss code-env get-definition <lang> <name>",
+        description: "Get raw code environment definition.",
+        examples: ["dss code-env get-definition PYTHON my_env",],
+    },
+    create: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env create <lang> <name> --deployment-mode MODE");
+            const deploymentMode = f["deployment-mode"];
+            if (!deploymentMode) {
+                throw new UsageError("--deployment-mode is required. Usage: dss code-env create <lang> <name> --deployment-mode MODE");
+            }
+            const params = codeEnvParams(f);
+            const wait = codeEnvWait(f);
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const existing = (await c.codeEnvs.list({ envLang: a[0], }))
+                    .find((env) => env.envName === a[1]);
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("code-env", a[1], "exists", { envLang: a[0], current: existing, });
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "code-env",
+                        envLang: a[0],
+                        envName: a[1],
+                        payload: {
+                            deploymentMode,
+                            params,
+                            wait,
+                        },
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.codeEnvs.create({
+                envLang: a[0],
+                envName: a[1],
+                deploymentMode,
+                params,
+                wait,
+            });
+            return { created: a[1], resource: "code-env", envLang: a[0], ...created, };
+        },
+        usage: "dss code-env create <lang> <name> --deployment-mode MODE [--params JSON|--data JSON|--data-file PATH|--stdin] [--python-interpreter PYTHON311] [--no-wait] [--if-not-exists] [--dry-run]",
+        description: "Create a code environment.",
+        examples: [
+            "dss code-env create PYTHON my_env --deployment-mode DESIGN_MANAGED --python-interpreter PYTHON311",
+            'dss code-env create PYTHON my_env --deployment-mode DESIGN_MANAGED --params \'{"pythonInterpreter":"PYTHON311"}\' --dry-run',
+        ],
+    },
+    "set-definition": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env set-definition <lang> <name> --data JSON");
+            const definition = jsonInput(f);
+            if (!definition) {
+                throw new UsageError("--data, --data-file, or --stdin is required. Usage: dss code-env set-definition <lang> <name> --data JSON");
+            }
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "set-definition",
+                    resource: "code-env",
+                    envLang: a[0],
+                    envName: a[1],
+                    definition,
+                };
+            }
+            return c.codeEnvs.setDefinition(a[0], a[1], definition);
+        },
+        usage: "dss code-env set-definition <lang> <name> [--data JSON|--data-file PATH|--stdin] [--dry-run]",
+        description: "Replace a code environment definition previously fetched from DSS.",
+        examples: ["dss code-env set-definition PYTHON my_env --data-file code-env.json --dry-run",],
+    },
+    "set-packages": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env set-packages <lang> <name> --packages PKGS");
+            const packages = codeEnvPackageList(f);
+            const installCorePackages = parseBooleanOption(f["install-core-packages"], "--install-core-packages");
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "set-packages",
+                    resource: "code-env",
+                    envLang: a[0],
+                    envName: a[1],
+                    packages,
+                    installCorePackages,
+                };
+            }
+            return c.codeEnvs.setPackages(a[0], a[1], packages, { installCorePackages, });
+        },
+        usage: "dss code-env set-packages <lang> <name> [--packages PKGS|--package PKG|--file PATH] [--install-core-packages true|false] [--dry-run]",
+        description: "Update requested package specs without rebuilding packages.",
+        examples: [
+            "dss code-env set-packages PYTHON my_env --packages 'tabulate\\nnameparser' --dry-run",
+            "dss code-env set-packages PYTHON my_env --file requirements.txt",
+        ],
+    },
+    "update-packages": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env update-packages <lang> <name>");
+            const wait = codeEnvWait(f);
+            const versionToUpdate = typeof f["env-version"] === "string"
+                ? f["env-version"]
+                : typeof f["version"] === "string"
+                    ? f["version"]
+                    : undefined;
+            const opts = {
+                forceRebuildEnv: f["force-rebuild"] === true,
+                versionToUpdate,
+                wait,
+            };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "update-packages",
+                    resource: "code-env",
+                    envLang: a[0],
+                    envName: a[1],
+                    ...opts,
+                };
+            }
+            return c.codeEnvs.updatePackages(a[0], a[1], opts);
+        },
+        usage: "dss code-env update-packages <lang> <name> [--force-rebuild] [--env-version VERSION] [--no-wait] [--dry-run]",
+        description: "Rebuild or update code environment packages to match the requested specs.",
+        examples: ["dss code-env update-packages PYTHON my_env --force-rebuild --dry-run",],
+    },
+    "set-jupyter": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env set-jupyter <lang> <name> --active true|false");
+            const active = parseBooleanOption(f["active"], "--active");
+            if (active === undefined) {
+                throw new UsageError("--active is required. Usage: dss code-env set-jupyter <lang> <name> --active true|false");
+            }
+            const wait = codeEnvWait(f);
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "set-jupyter",
+                    resource: "code-env",
+                    envLang: a[0],
+                    envName: a[1],
+                    active,
+                    wait,
+                };
+            }
+            return c.codeEnvs.setJupyterSupport(a[0], a[1], active, { wait, });
+        },
+        usage: "dss code-env set-jupyter <lang> <name> --active true|false [--no-wait] [--dry-run]",
+        description: "Enable or disable Jupyter support for a code environment.",
+        examples: ["dss code-env set-jupyter PYTHON my_env --active true --dry-run",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss code-env delete <lang> <name>");
+            const wait = codeEnvWait(f);
+            if (f["dry-run"] === true) {
+                const current = await readIfExists(() => c.codeEnvs.get(a[0], a[1]));
+                if (!current)
+                    return skipResult("code-env", a[1], "missing", { envLang: a[0], });
+                return {
+                    dryRun: true,
+                    action: "delete",
+                    resource: "code-env",
+                    envLang: a[0],
+                    envName: a[1],
+                    wait,
+                    current,
+                };
+            }
+            if (f["if-exists"] === true) {
+                return await c.codeEnvs.delete(a[0], a[1], { wait, }).catch((error) => {
+                    if (isNotFoundError(error)) {
+                        return skipResult("code-env", a[1], "missing", { envLang: a[0], });
+                    }
+                    throw error;
+                });
+            }
+            return c.codeEnvs.delete(a[0], a[1], { wait, });
+        },
+        usage: "dss code-env delete <lang> <name> [--no-wait] [--if-exists] [--dry-run]",
+        description: "Delete a code environment.",
+        examples: ["dss code-env delete PYTHON my_env --dry-run",],
+    },
+    usages: {
+        handler: (c, a) => {
+            if (a.length === 0)
+                return c.codeEnvs.listUsages();
+            if (a.length === 2)
+                return c.codeEnvs.listUsages(a[0], a[1]);
+            throw new UsageError("Usage: dss code-env usages [<lang> <name>]");
+        },
+        usage: "dss code-env usages [<lang> <name>]",
+        description: "List code environment usages globally or for one environment.",
+        examples: ["dss code-env usages", "dss code-env usages PYTHON my_env",],
+    },
+};

package/dist/src/cli/commands/code.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const codeCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/code.js

@@ -0,0 +1,63 @@
+import { readFileSync, } from "node:fs";
+import { num, readStdinText, stripUtf8Bom, } from "../coerce.js";
+import { UsageError, } from "../usage.js";
+const CODE_RUN_USAGE = "dss code run (--file PATH | --stdin) [--env ENV] [--timeout MS] [--keep] [--full-log] [--max-log-bytes N] [--project-key KEY]";
+function resolveCodeInput(args, flags) {
+    if (args.length > 0) {
+        throw new UsageError(`code run takes no positional arguments; pass the script via --file PATH or --stdin. Usage: ${CODE_RUN_USAGE}`);
+    }
+    const sources = [];
+    if (typeof flags["file"] === "string") {
+        sources.push({ label: "--file", read: () => readFileSync(flags["file"], "utf-8"), });
+    }
+    if (flags["stdin"] === true) {
+        sources.push({ label: "--stdin", read: readStdinText, });
+    }
+    if (sources.length === 0) {
+        throw new UsageError(`Python source is required: pass --file PATH or --stdin. Usage: ${CODE_RUN_USAGE}`);
+    }
+    if (sources.length > 1) {
+        throw new UsageError(`Choose exactly one Python source: --file or --stdin. Usage: ${CODE_RUN_USAGE}`);
+    }
+    const script = stripUtf8Bom(sources[0].read());
+    if (script.trim().length === 0) {
+        throw new UsageError(`Python source from ${sources[0].label} must not be empty. Usage: ${CODE_RUN_USAGE}`);
+    }
+    return script;
+}
+export const codeCommands = {
+    run: {
+        handler: async (c, a, f) => {
+            const script = resolveCodeInput(a, f);
+            const run = await c.scenarios.runScript(script, {
+                envName: f["env"],
+                projectKey: f["project-key"],
+                timeoutMs: num(f["timeout"]),
+                keepScenario: f["keep"] === true,
+                maxLogBytes: num(f["max-log-bytes"]),
+            });
+            const result = {
+                outcome: run.outcome,
+                success: run.success,
+                runId: run.runId,
+                elapsedMs: run.elapsedMs,
+                pollCount: run.pollCount,
+                output: run.output ?? "",
+                logTruncated: run.logTruncated,
+                maxLogBytes: run.maxLogBytes,
+            };
+            if (f["full-log"] === true || run.output === undefined) {
+                result.log = run.log;
+            }
+            return result;
+        },
+        usage: CODE_RUN_USAGE,
+        description: "Run one-off Python in a DSS code env via a throwaway custom-python scenario; returns the script's captured output (stdout+stderr) plus outcome/success. Log retrieval is capped by --max-log-bytes (default 1048576); pass --full-log to include the capped raw DSS run log. Exits 4 on a non-SUCCESS outcome.",
+        examples: [
+            "dss code run --file inspect.py",
+            "dss code run --file inspect.py --env py39_pandas",
+            "cat snippet.py | dss code run --stdin",
+            "dss code run --file inspect.py --full-log",
+        ],
+    },
+};

package/dist/src/cli/commands/connection.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const connectionCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/connection.js

@@ -0,0 +1,54 @@
+import { UsageError, } from "../usage.js";
+export const connectionCommands = {
+    list: {
+        handler: (c, _a, f) => c.connections.list({
+            type: f["type"],
+        }),
+        usage: "dss connection list [--type TYPE]",
+        description: "List all connection names, optionally filtered by connection type.",
+        examples: ["dss connection list", "dss connection list --type Filesystem",],
+    },
+    infer: {
+        handler: (c, _a, f) => c.connections.infer({
+            mode: f["mode"],
+            projectKey: f["project-key"],
+        }),
+        usage: "dss connection infer [--mode fast|rich] [--project-key KEY]",
+        description: "List connections with inferred types and metadata.",
+        examples: ["dss connection infer", "dss connection infer --mode rich",],
+    },
+    schemas: {
+        handler: (c, _a, f) => {
+            const connection = f["connection"];
+            if (!connection) {
+                throw new UsageError("--connection is required. Usage: dss connection schemas --connection CONN");
+            }
+            return c.connections.schemas({
+                connection,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss connection schemas --connection CONN [--project-key KEY]",
+        description: "List schemas in a SQL connection.",
+        examples: ["dss connection schemas --connection ATHENA_CONN --project-key MYPROJ",],
+    },
+    tables: {
+        handler: (c, _a, f) => {
+            const connection = f["connection"];
+            if (!connection) {
+                throw new UsageError("--connection is required. Usage: dss connection tables --connection CONN");
+            }
+            return c.connections.tables({
+                connection,
+                catalog: f["catalog"],
+                schema: f["schema"],
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss connection tables --connection CONN [--catalog CATALOG] [--schema SCHEMA] [--project-key KEY]",
+        description: "List importable tables in a SQL connection, optionally scoped by catalog and schema.",
+        examples: [
+            "dss connection tables --connection ATHENA_CONN --schema analytics --project-key MYPROJ",
+        ],
+    },
+};

package/dist/src/cli/commands/continuous-activity.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const continuousActivityCommands: Record<string, CommandMeta>;