dataiku-sdk 0.10.1 → 0.12.0

package/dist/src/cli/commands/api-service.js

@@ -0,0 +1,121 @@
+import { writeFileSync, } from "node:fs";
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const apiServiceCommands = {
+    list: {
+        handler: (c, _a, f) => c.apiServices.list(f["project-key"]),
+        usage: "dss api-service list [--project-key KEY]",
+        description: "List API services in a project.",
+        examples: ["dss api-service list",],
+    },
+    create: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss api-service create <serviceId> [--project-key KEY]");
+            return c.apiServices.create(a[0], f["project-key"]);
+        },
+        usage: "dss api-service create <serviceId> [--project-key KEY]",
+        description: "Create an empty API service.",
+        examples: ["dss api-service create my-service",],
+    },
+    "get-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss api-service get-settings <serviceId> [--project-key KEY]");
+            return c.apiServices.getSettings(a[0], f["project-key"]);
+        },
+        usage: "dss api-service get-settings <serviceId> [--project-key KEY]",
+        description: "Get an API service's settings (endpoint definitions).",
+        examples: ["dss api-service get-settings my-service",],
+    },
+    "save-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss api-service save-settings <serviceId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (service settings).");
+            return c.apiServices.saveSettings(a[0], body, f["project-key"]);
+        },
+        usage: "dss api-service save-settings <serviceId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Save an API service's settings.",
+        examples: ["dss api-service save-settings my-service --data-file service.json",],
+    },
+    "add-prediction-endpoint": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 3, "dss api-service add-prediction-endpoint <serviceId> <endpointId> <savedModelId> [--dry-run] [--project-key KEY]");
+            const endpoint = {
+                id: a[1],
+                type: "STD_PREDICTION",
+                modelRef: a[2],
+            };
+            if (f["dry-run"] === true)
+                return endpoint;
+            return c.apiServices.addPredictionEndpoint(a[0], a[1], a[2], f["project-key"]);
+        },
+        usage: "dss api-service add-prediction-endpoint <serviceId> <endpointId> <savedModelId> [--dry-run] [--project-key KEY]",
+        description: "Add a saved-model prediction endpoint to an API service.",
+        examples: [
+            "dss api-service add-prediction-endpoint my-service predict churn-model",
+            "dss api-service add-prediction-endpoint my-service predict churn-model --dry-run",
+        ],
+    },
+    "list-packages": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss api-service list-packages <serviceId> [--project-key KEY]");
+            const projectKey = f["project-key"];
+            await c.apiServices.getSettings(a[0], projectKey);
+            return c.apiServices.listPackages(a[0], projectKey);
+        },
+        usage: "dss api-service list-packages <serviceId> [--project-key KEY]",
+        description: "List deployable packages of an API service.",
+        examples: ["dss api-service list-packages my-service",],
+    },
+    "package-summary": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss api-service package-summary <serviceId> <packageId> [--project-key KEY]");
+            return c.apiServices.getPackageSummary(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss api-service package-summary <serviceId> <packageId> [--project-key KEY]",
+        description: "Get a package summary.",
+        examples: ["dss api-service package-summary my-service v1",],
+    },
+    "create-package": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss api-service create-package <serviceId> <packageId> [--project-key KEY]");
+            return c.apiServices.createPackage(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss api-service create-package <serviceId> <packageId> [--project-key KEY]",
+        description: "Build a deployable package from the current service state.",
+        examples: ["dss api-service create-package my-service v1",],
+    },
+    "delete-package": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss api-service delete-package <serviceId> <packageId> [--project-key KEY]");
+            await c.apiServices.deletePackage(a[0], a[1], f["project-key"]);
+            return { deleted: true, };
+        },
+        usage: "dss api-service delete-package <serviceId> <packageId> [--project-key KEY]",
+        description: "Delete an API service package.",
+        examples: ["dss api-service delete-package my-service v1",],
+    },
+    "download-package": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss api-service download-package <serviceId> <packageId> --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.apiServices.downloadPackageArchive(a[0], a[1], f["project-key"]);
+            const buf = Buffer.from(await res.arrayBuffer());
+            writeFileSync(out, buf);
+            return { path: out, bytes: buf.length, };
+        },
+        usage: "dss api-service download-package <serviceId> <packageId> --output PATH [--project-key KEY]",
+        description: "Download an API service package archive to a local file.",
+        examples: ["dss api-service download-package my-service v1 --output ./pkg.zip",],
+    },
+    "publish-package": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss api-service publish-package <serviceId> <packageId> [--project-key KEY]");
+            return c.apiServices.publishPackage(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss api-service publish-package <serviceId> <packageId> [--project-key KEY]",
+        description: "Publish a package to the API Deployer.",
+        examples: ["dss api-service publish-package my-service v1",],
+    },
+};

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

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

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>;