dataiku-sdk 0.10.1 → 0.12.0

package/dist/src/cli/commands/ml-task.js

@@ -0,0 +1,171 @@
+import { requiredJsonInput, requiredStringFlag, } from "../coerce.js";
+import { requireArgs, UsageError, } from "../usage.js";
+function optionalStringFlag(flags, name) {
+    const value = flags[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`--${name} requires a non-empty value.`, "usage_error");
+    }
+    return value.trim();
+}
+function taskType(flags, usage) {
+    const normalized = requiredStringFlag(flags, "task-type", usage).toUpperCase();
+    if (normalized === "PREDICTION" || normalized === "CLUSTERING")
+        return normalized;
+    throw new UsageError("--task-type must be PREDICTION or CLUSTERING.", "invalid_enum");
+}
+export const mlTaskCommands = {
+    create: {
+        handler: async (c, a, f) => {
+            const usage = "dss ml-task create <analysisId> --task-type PREDICTION|CLUSTERING [--target COLUMN] [--prediction-type TYPE] [--backend-type TYPE] [--guess-policy POLICY] [--project-key KEY]";
+            requireArgs(a, 1, usage);
+            const projectKey = f["project-key"];
+            const normalizedTaskType = taskType(f, usage);
+            const targetVariable = optionalStringFlag(f, "target");
+            if (normalizedTaskType === "PREDICTION" && targetVariable === undefined) {
+                throw new UsageError("--target is required for PREDICTION ML tasks.", "missing_required_flag");
+            }
+            const options = {
+                analysisId: a[0],
+                taskType: normalizedTaskType,
+                targetVariable,
+                predictionType: optionalStringFlag(f, "prediction-type"),
+                backendType: optionalStringFlag(f, "backend-type"),
+                guessPolicy: optionalStringFlag(f, "guess-policy"),
+                projectKey,
+            };
+            const created = await c.mlTasks.create(options);
+            return { created: created.mlTaskId, resource: "ml-task", analysisId: a[0], ...created, };
+        },
+        usage: "dss ml-task create <analysisId> --task-type PREDICTION|CLUSTERING [--target COLUMN] [--prediction-type TYPE] [--backend-type TYPE] [--guess-policy POLICY] [--project-key KEY]",
+        description: "Create a prediction or clustering task in an analysis.",
+        examples: [
+            "dss ml-task create ANALYSIS_ID --task-type prediction --target churn --project-key PROJECT",
+        ],
+    },
+    status: {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task status <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.status(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task status <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "Get a Visual ML task's current status.",
+        examples: ["dss ml-task status ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "get-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task get-settings <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.getSettings(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task get-settings <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "Get a Visual ML task's settings.",
+        examples: ["dss ml-task get-settings ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "set-settings": {
+        handler: (c, a, f) => {
+            const usage = "dss ml-task set-settings <analysisId> <mlTaskId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]";
+            requireArgs(a, 2, usage);
+            const settings = requiredJsonInput(f, "--data, --data-file, or --stdin is required (ML task settings).");
+            const projectKey = f["project-key"];
+            return c.mlTasks.saveSettings(a[0], a[1], settings, projectKey);
+        },
+        usage: "dss ml-task set-settings <analysisId> <mlTaskId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Replace a Visual ML task's settings from JSON input.",
+        examples: [
+            "dss ml-task set-settings ANALYSIS_ID TASK_ID --data-file settings.json --project-key PROJECT",
+        ],
+    },
+    train: {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task train <analysisId> <mlTaskId> [--session-name NAME] [--wait] [--project-key KEY]");
+            const options = {
+                analysisId: a[0],
+                mlTaskId: a[1],
+                sessionName: optionalStringFlag(f, "session-name"),
+                wait: f["wait"] === true,
+                projectKey: f["project-key"],
+            };
+            return c.mlTasks.train(options);
+        },
+        usage: "dss ml-task train <analysisId> <mlTaskId> [--session-name NAME] [--wait] [--project-key KEY]",
+        description: "Start ML task training, optionally waiting for trained model IDs.",
+        examples: [
+            "dss ml-task train ANALYSIS_ID TASK_ID --session-name baseline --wait --project-key PROJECT",
+        ],
+    },
+    "list-models": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task list-models <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.listTrainedModels(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task list-models <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "List trained models for a Visual ML task.",
+        examples: ["dss ml-task list-models ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "model-details": {
+        handler: (c, a, f) => {
+            requireArgs(a, 3, "dss ml-task model-details <analysisId> <mlTaskId> <modelId> [--project-key KEY]");
+            return c.mlTasks.trainedModelDetails(a[0], a[1], a[2], f["project-key"]);
+        },
+        usage: "dss ml-task model-details <analysisId> <mlTaskId> <modelId> [--project-key KEY]",
+        description: "Get details for one trained model.",
+        examples: [
+            "dss ml-task model-details ANALYSIS_ID TASK_ID MODEL_ID --project-key PROJECT",
+        ],
+    },
+    deploy: {
+        handler: async (c, a, f) => {
+            const usage = "dss ml-task deploy <analysisId> <mlTaskId> <modelId> --model-name NAME --train-dataset DATASET [--test-dataset DATASET] [--dry-run] [--project-key KEY]";
+            requireArgs(a, 3, usage);
+            const options = {
+                analysisId: a[0],
+                mlTaskId: a[1],
+                modelId: a[2],
+                modelName: requiredStringFlag(f, "model-name", usage),
+                trainDatasetRef: requiredStringFlag(f, "train-dataset", usage),
+                testDatasetRef: optionalStringFlag(f, "test-dataset"),
+                projectKey: f["project-key"],
+            };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "deploy",
+                    resource: "ml-task",
+                    ...options,
+                };
+            }
+            return c.mlTasks.deployToFlow(options);
+        },
+        usage: "dss ml-task deploy <analysisId> <mlTaskId> <modelId> --model-name NAME --train-dataset DATASET [--test-dataset DATASET] [--dry-run] [--project-key KEY]",
+        description: "Deploy a trained model to the Flow as a saved model.",
+        examples: [
+            "dss ml-task deploy ANALYSIS_ID TASK_ID MODEL_ID --model-name churn-model --train-dataset train --test-dataset test --project-key PROJECT",
+            "dss ml-task deploy ANALYSIS_ID TASK_ID MODEL_ID --model-name churn-model --train-dataset train --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task delete <analysisId> <mlTaskId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "delete",
+                    resource: "ml-task",
+                    analysisId: a[0],
+                    mlTaskId: a[1],
+                    projectKey,
+                };
+            }
+            await c.mlTasks.delete(a[0], a[1], projectKey);
+            return { deleted: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        usage: "dss ml-task delete <analysisId> <mlTaskId> [--dry-run] [--project-key KEY]",
+        description: "Delete a Visual ML task.",
+        examples: [
+            "dss ml-task delete ANALYSIS_ID TASK_ID --project-key PROJECT",
+            "dss ml-task delete ANALYSIS_ID TASK_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

package/dist/src/cli/commands/model-evaluation-store.d.ts

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

package/dist/src/cli/commands/model-evaluation-store.js

@@ -0,0 +1,83 @@
+import { requiredStringFlag, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const modelEvaluationStoreCommands = {
+    list: {
+        handler: (c, _a, f) => c.modelEvaluationStores.list(f["project-key"]),
+        usage: "dss model-evaluation-store list [--project-key KEY]",
+        description: "List model evaluation stores in a project.",
+        examples: ["dss model-evaluation-store list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store get <storeId> [--project-key KEY]");
+            return c.modelEvaluationStores.get(a[0], f["project-key"]);
+        },
+        usage: "dss model-evaluation-store get <storeId> [--project-key KEY]",
+        description: "Get a model evaluation store.",
+        examples: ["dss model-evaluation-store get STORE_ID --project-key PROJECT",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const usage = "dss model-evaluation-store create --name NAME [--dry-run] [--project-key KEY]";
+            const name = requiredStringFlag(f, "name", usage);
+            const projectKey = f["project-key"];
+            const options = { name, projectKey, };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "create",
+                    resource: "model-evaluation-store",
+                    payload: options,
+                };
+            }
+            const created = await c.modelEvaluationStores.create(options);
+            return { created: created.id, resource: "model-evaluation-store", ...created, };
+        },
+        usage: "dss model-evaluation-store create --name NAME [--dry-run] [--project-key KEY]",
+        description: "Create an empty model evaluation store.",
+        examples: [
+            "dss model-evaluation-store create --name production-evaluations --project-key PROJECT",
+            "dss model-evaluation-store create --name production-evaluations --dry-run --project-key PROJECT",
+        ],
+    },
+    "list-evaluations": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store list-evaluations <storeId> [--project-key KEY]");
+            return c.modelEvaluationStores.listEvaluations(a[0], f["project-key"]);
+        },
+        usage: "dss model-evaluation-store list-evaluations <storeId> [--project-key KEY]",
+        description: "List evaluations in a model evaluation store.",
+        examples: [
+            "dss model-evaluation-store list-evaluations STORE_ID --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store delete <storeId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.modelEvaluationStores.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("model-evaluation-store", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "delete",
+                        resource: "model-evaluation-store",
+                        id: a[0],
+                        current,
+                    };
+                }
+            }
+            await c.modelEvaluationStores.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "model-evaluation-store", };
+        },
+        usage: "dss model-evaluation-store delete <storeId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a model evaluation store.",
+        examples: [
+            "dss model-evaluation-store delete STORE_ID --if-exists --project-key PROJECT",
+            "dss model-evaluation-store delete STORE_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

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

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

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

@@ -0,0 +1,242 @@
+import { jsonInput, num, } from "../coerce.js";
+import { encodedProjectEndpoint, isNotFoundError, readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const notebookCommands = {
+    "list-jupyter": {
+        handler: (c, _a, f) => c.notebooks.listJupyter(f["project-key"]),
+        usage: "dss notebook list-jupyter [--project-key KEY]",
+        description: "List Jupyter notebooks.",
+        examples: ["dss notebook list-jupyter",],
+    },
+    "get-jupyter": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss notebook get-jupyter <name>");
+            return c.notebooks.getJupyter(a[0], f["project-key"]);
+        },
+        usage: "dss notebook get-jupyter <name> [--project-key KEY]",
+        description: "Get a Jupyter notebook.",
+        examples: ["dss notebook get-jupyter my_notebook",],
+    },
+    "delete-jupyter": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook delete-jupyter <name>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.notebooks.getJupyter(a[0], pk));
+                if (!current)
+                    return skipResult("jupyter-notebook", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "jupyter-notebook", name: a[0], current, };
+                }
+            }
+            await c.notebooks.deleteJupyter(a[0], pk);
+            return { deleted: a[0], resource: "jupyter-notebook", };
+        },
+        usage: "dss notebook delete-jupyter <name> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a Jupyter notebook.",
+        examples: ["dss notebook delete-jupyter my_notebook --dry-run",],
+    },
+    "clear-jupyter-outputs": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook clear-jupyter-outputs <name>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                const current = await c.notebooks.getJupyter(a[0], pk);
+                const next = {
+                    ...current,
+                    cells: current.cells.map((cell) => ({ ...cell, outputs: [], execution_count: null, })),
+                };
+                return {
+                    dryRun: true,
+                    action: "clear-jupyter-outputs",
+                    resource: "jupyter-notebook",
+                    name: a[0],
+                    current,
+                    next,
+                };
+            }
+            await c.notebooks.clearJupyterOutputs(a[0], pk);
+            return { cleared: a[0], resource: "jupyter-notebook", };
+        },
+        usage: "dss notebook clear-jupyter-outputs <name> [--dry-run] [--project-key KEY]",
+        description: "Clear all cell outputs from a Jupyter notebook.",
+        examples: ["dss notebook clear-jupyter-outputs my_notebook --dry-run",],
+    },
+    "sessions-jupyter": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss notebook sessions-jupyter <name>");
+            return c.notebooks.listJupyterSessions(a[0], f["project-key"]);
+        },
+        usage: "dss notebook sessions-jupyter <name> [--project-key KEY]",
+        description: "List active kernel sessions for a Jupyter notebook.",
+        examples: ["dss notebook sessions-jupyter my_notebook",],
+    },
+    "unload-jupyter": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss notebook unload-jupyter <name> <sessionId>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                const sessions = await c.notebooks.listJupyterSessions(a[0], pk);
+                const current = sessions.find((session) => session.sessionId === a[1]);
+                return {
+                    dryRun: true,
+                    action: "unload-jupyter",
+                    resource: "jupyter-notebook",
+                    name: a[0],
+                    sessionId: a[1],
+                    current,
+                    endpoint: encodedProjectEndpoint(c, pk, `/jupyter-notebooks/${encodeURIComponent(a[0])}/sessions/${encodeURIComponent(a[1])}`),
+                    method: "DELETE",
+                };
+            }
+            await c.notebooks.unloadJupyter(a[0], a[1], pk);
+            return { unloaded: a[0], sessionId: a[1], resource: "jupyter-notebook", };
+        },
+        usage: "dss notebook unload-jupyter <name> <sessionId> [--dry-run] [--project-key KEY]",
+        description: "Unload a Jupyter notebook kernel session.",
+        examples: ["dss notebook unload-jupyter my_notebook SESSION_ID --dry-run",],
+    },
+    "list-sql": {
+        handler: (c, _a, f) => c.notebooks.listSql(f["project-key"]),
+        usage: "dss notebook list-sql [--project-key KEY]",
+        description: "List SQL notebooks.",
+        examples: ["dss notebook list-sql",],
+    },
+    "get-sql": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss notebook get-sql <id>");
+            return c.notebooks.getSql(a[0], f["project-key"]);
+        },
+        usage: "dss notebook get-sql <id> [--project-key KEY]",
+        description: "Get a SQL notebook.",
+        examples: ["dss notebook get-sql my_sql_notebook",],
+    },
+    "delete-sql": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook delete-sql <id>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.notebooks.getSql(a[0], pk));
+                if (!current)
+                    return skipResult("sql-notebook", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "sql-notebook", id: a[0], current, };
+                }
+            }
+            await c.notebooks.deleteSql(a[0], pk);
+            return { deleted: a[0], resource: "sql-notebook", };
+        },
+        usage: "dss notebook delete-sql <id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a SQL notebook.",
+        examples: ["dss notebook delete-sql my_sql_notebook --dry-run",],
+    },
+    "history-sql": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss notebook history-sql <id>");
+            return c.notebooks.getSqlHistory(a[0], f["project-key"]);
+        },
+        usage: "dss notebook history-sql <id> [--project-key KEY]",
+        description: "Get query history for a SQL notebook.",
+        examples: ["dss notebook history-sql my_sql_notebook",],
+    },
+    "save-jupyter": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook save-jupyter <name> [--data '{...}' | --data-file PATH | --stdin]");
+            const data = jsonInput(f);
+            if (!data) {
+                throw new UsageError("--data, --data-file, or --stdin is required (notebook JSON content).");
+            }
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                const current = await readIfExists(() => c.notebooks.getJupyter(a[0], pk));
+                return {
+                    dryRun: true,
+                    action: "save-jupyter",
+                    resource: "jupyter-notebook",
+                    name: a[0],
+                    current,
+                    next: data,
+                };
+            }
+            try {
+                await c.notebooks.saveJupyter(a[0], data, pk);
+            }
+            catch (error) {
+                if (!isNotFoundError(error))
+                    throw error;
+                await c.notebooks.createJupyter(a[0], data, pk);
+            }
+            return { saved: a[0], resource: "jupyter-notebook", };
+        },
+        usage: "dss notebook save-jupyter <name> [--data '{...}' | --data-file PATH | --stdin] [--dry-run] [--project-key KEY]",
+        description: "Save content to a Jupyter notebook, creating it if missing.",
+        examples: [
+            "dss notebook save-jupyter my_notebook --data-file notebook.json --dry-run",
+            "cat notebook.json | dss notebook save-jupyter my_notebook --stdin",
+        ],
+    },
+    "save-sql": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook save-sql <id> [--data '{...}' | --data-file PATH | --stdin]");
+            const data = jsonInput(f);
+            if (!data) {
+                throw new UsageError("--data, --data-file, or --stdin is required (SQL notebook content JSON).");
+            }
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                const current = await readIfExists(() => c.notebooks.getSql(a[0], pk));
+                return {
+                    dryRun: true,
+                    action: "save-sql",
+                    resource: "sql-notebook",
+                    id: a[0],
+                    current,
+                    next: data,
+                };
+            }
+            const current = await readIfExists(() => c.notebooks.getSql(a[0], pk));
+            if (current) {
+                await c.notebooks.saveSql(a[0], data, pk);
+            }
+            else {
+                await c.notebooks.createSql(a[0], data, pk);
+            }
+            return { saved: a[0], resource: "sql-notebook", };
+        },
+        usage: "dss notebook save-sql <id> [--data '{...}' | --data-file PATH | --stdin] [--dry-run] [--project-key KEY]",
+        description: "Save content to a SQL notebook, creating it if missing.",
+        examples: ["dss notebook save-sql my_sql_notebook --data-file content.json --dry-run",],
+    },
+    "clear-sql-history": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss notebook clear-sql-history <id>");
+            const pk = f["project-key"];
+            const options = {
+                cellId: f["cell-id"],
+                numRunsToRetain: num(f["retain"]),
+                projectKey: pk,
+            };
+            if (f["dry-run"] === true) {
+                const current = await c.notebooks.getSqlHistory(a[0], pk);
+                return {
+                    dryRun: true,
+                    action: "clear-sql-history",
+                    resource: "sql-notebook",
+                    id: a[0],
+                    current,
+                    next: options,
+                    endpoint: encodedProjectEndpoint(c, pk, `/sql-notebooks/${encodeURIComponent(a[0])}/history/clear`),
+                    method: "POST",
+                };
+            }
+            await c.notebooks.clearSqlHistory(a[0], options);
+            return { cleared: a[0], resource: "sql-notebook", };
+        },
+        usage: "dss notebook clear-sql-history <id> [--cell-id CID] [--retain N] [--dry-run] [--project-key KEY]",
+        description: "Clear query history for a SQL notebook.",
+        examples: [
+            "dss notebook clear-sql-history my_sql_notebook --dry-run",
+            "dss notebook clear-sql-history my_sql_notebook --cell-id CELL1 --retain 5",
+        ],
+    },
+};

package/dist/src/cli/commands/project-deployer.d.ts

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

package/dist/src/cli/commands/project-deployer.js

@@ -0,0 +1,118 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const projectDeployerCommands = {
+    "list-projects": {
+        handler: (c) => c.projectDeployer.listProjects(),
+        usage: "dss project-deployer list-projects",
+        description: "List published projects on the Project Deployer.",
+        examples: ["dss project-deployer list-projects",],
+    },
+    "create-project": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (published project settings).");
+            return c.projectDeployer.createProject(body);
+        },
+        usage: "dss project-deployer create-project (--data JSON|--data-file PATH|--stdin)",
+        description: "Create a published project on the Project Deployer.",
+        examples: ["dss project-deployer create-project --data-file project.json",],
+    },
+    "upload-bundle": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss project-deployer upload-bundle <filePath>");
+            await c.projectDeployer.uploadBundle(a[0]);
+            return { uploaded: true, };
+        },
+        usage: "dss project-deployer upload-bundle <filePath>",
+        description: "Upload a project bundle archive to the Project Deployer.",
+        examples: ["dss project-deployer upload-bundle ./v1.zip",],
+    },
+    "project-status": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss project-deployer project-status <publishedProjectKey>");
+            return c.projectDeployer.getProjectStatus(a[0]);
+        },
+        usage: "dss project-deployer project-status <publishedProjectKey>",
+        description: "Get a published project's status and available bundles.",
+        examples: ["dss project-deployer project-status MYPROJ",],
+    },
+    "list-deployments": {
+        handler: (c) => c.projectDeployer.listDeployments(),
+        usage: "dss project-deployer list-deployments",
+        description: "List Project Deployer deployments.",
+        examples: ["dss project-deployer list-deployments",],
+    },
+    "create-deployment": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (deployment settings).");
+            return c.projectDeployer.createDeployment(body);
+        },
+        usage: "dss project-deployer create-deployment (--data JSON|--data-file PATH|--stdin)",
+        description: "Create a Project Deployer deployment (bundle to infra mapping).",
+        examples: ["dss project-deployer create-deployment --data-file deployment.json",],
+    },
+    "get-deployment": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss project-deployer get-deployment <deploymentId>");
+            return c.projectDeployer.getDeployment(a[0]);
+        },
+        usage: "dss project-deployer get-deployment <deploymentId>",
+        description: "Get a Project Deployer deployment.",
+        examples: ["dss project-deployer get-deployment my-deployment",],
+    },
+    "deployment-status": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss project-deployer deployment-status <deploymentId>");
+            return c.projectDeployer.getDeploymentStatus(a[0]);
+        },
+        usage: "dss project-deployer deployment-status <deploymentId>",
+        description: "Get a Project Deployer deployment's full health/status.",
+        examples: ["dss project-deployer deployment-status my-deployment",],
+    },
+    "save-deployment-settings": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-deployer save-deployment-settings <deploymentId> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (deployment settings).");
+            await c.projectDeployer.saveDeploymentSettings(a[0], body);
+            return { saved: true, };
+        },
+        usage: "dss project-deployer save-deployment-settings <deploymentId> (--data JSON|--data-file PATH|--stdin)",
+        description: "Save a Project Deployer deployment's settings (e.g. bundleId).",
+        examples: [
+            "dss project-deployer save-deployment-settings my-deployment --data-file settings.json",
+        ],
+    },
+    deploy: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss project-deployer deploy <deploymentId>");
+            return c.projectDeployer.startUpdate(a[0]);
+        },
+        usage: "dss project-deployer deploy <deploymentId>",
+        description: "Apply a deployment to the Automation node (start update).",
+        examples: ["dss project-deployer deploy my-deployment",],
+    },
+    "delete-deployment": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss project-deployer delete-deployment <deploymentId>");
+            await c.projectDeployer.deleteDeployment(a[0]);
+            return { deleted: true, };
+        },
+        usage: "dss project-deployer delete-deployment <deploymentId>",
+        description: "Delete a Project Deployer deployment.",
+        examples: ["dss project-deployer delete-deployment my-deployment",],
+    },
+    "list-infras": {
+        handler: (c) => c.projectDeployer.listInfras(),
+        usage: "dss project-deployer list-infras",
+        description: "List Project Deployer infrastructures.",
+        examples: ["dss project-deployer list-infras",],
+    },
+    "create-infra": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (infra settings).");
+            return c.projectDeployer.createInfra(body);
+        },
+        usage: "dss project-deployer create-infra (--data JSON|--data-file PATH|--stdin)",
+        description: "Create a Project Deployer infrastructure.",
+        examples: ["dss project-deployer create-infra --data-file infra.json",],
+    },
+};

package/dist/src/cli/commands/project-library.d.ts

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