dataiku-sdk 0.10.1 → 0.11.0

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

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

@@ -0,0 +1,197 @@
+import { readFileSync, writeFileSync, } from "node:fs";
+import { readStdinText, } from "../coerce.js";
+import { encodedProjectEndpoint, planResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+const PROJECT_LIBRARY_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
+function normalizeLibraryPath(path) {
+    const normalized = path.replace(/^\/+/, "");
+    if (!normalized)
+        throw new Error("Project library path is required");
+    return normalized;
+}
+function normalizeLibraryDestinationPath(path) {
+    if (path === "/")
+        return "/";
+    return `/${normalizeLibraryPath(path)}`;
+}
+function encodeLibraryPath(path) {
+    return normalizeLibraryPath(path)
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+function projectLibraryContentsEndpoint(client, projectKey, path) {
+    return encodedProjectEndpoint(client, projectKey, `/libraries/contents/${encodeLibraryPath(path)}`);
+}
+function projectLibraryFolderEndpoint(client, projectKey, path) {
+    return encodedProjectEndpoint(client, projectKey, `/libraries/folders/${encodeLibraryPath(path)}`);
+}
+function projectLibraryActionEndpoint(client, projectKey, action) {
+    return encodedProjectEndpoint(client, projectKey, `/libraries/contents-actions/${action}`);
+}
+function projectLibraryPutPayload(flags) {
+    if (typeof flags["content"] === "string")
+        return { contentSource: "flag", };
+    if (typeof flags["file"] === "string")
+        return { contentSource: "file", file: flags["file"], };
+    return { contentSource: "stdin", };
+}
+function projectLibraryPlan(action, options) {
+    return planResult("project-library", action, {
+        ...options,
+        asyncKind: "none",
+        exitCodesOnFailure: PROJECT_LIBRARY_EXIT_CODES,
+        idempotency: "none",
+        plannedAndDryRun: true,
+    });
+}
+export const projectLibraryCommands = {
+    list: {
+        handler: (c, _a, f) => c.projectLibrary.listContents(f["project-key"]),
+        usage: "dss project-library list [--project-key KEY]",
+        description: "List the project code library (lib/) contents.",
+        examples: ["dss project-library list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss project-library get <path> [--project-key KEY]");
+            return c.projectLibrary.getFile(a[0], f["project-key"]);
+        },
+        usage: "dss project-library get <path> [--project-key KEY]",
+        description: "Print the text content of a project library file.",
+        examples: ["dss project-library get python/mylib/utils.py",],
+    },
+    "get-bytes": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-library get-bytes <path> --output PATH [--project-key KEY]");
+            const out = f["output"];
+            if (!out)
+                throw new UsageError("--output PATH is required.", "missing_required_flag");
+            const bytes = await c.projectLibrary.getFileBytes(a[0], f["project-key"]);
+            writeFileSync(out, bytes);
+            return { path: out, bytes: bytes.length, };
+        },
+        usage: "dss project-library get-bytes <path> --output PATH [--project-key KEY]",
+        description: "Download a project library file's raw bytes to a local file.",
+        examples: ["dss project-library get-bytes static/logo.png --output ./logo.png",],
+    },
+    "create-file": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-library create-file <path> [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("create-file", {
+                    method: "POST",
+                    endpoint: projectLibraryContentsEndpoint(c, pk, a[0]),
+                    identifiers: { path: a[0], },
+                });
+            }
+            await c.projectLibrary.addFile(a[0], pk);
+            return { created: a[0], };
+        },
+        usage: "dss project-library create-file <path> [--dry-run] [--project-key KEY]",
+        description: "Create an empty file in the project library.",
+        examples: ["dss project-library create-file python/mylib/new.py",],
+    },
+    "create-folder": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-library create-folder <path> [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("create-folder", {
+                    method: "POST",
+                    endpoint: projectLibraryFolderEndpoint(c, pk, a[0]),
+                    identifiers: { path: a[0], },
+                });
+            }
+            await c.projectLibrary.addFolder(a[0], pk);
+            return { created: a[0], };
+        },
+        usage: "dss project-library create-folder <path> [--dry-run] [--project-key KEY]",
+        description: "Create a folder in the project library.",
+        examples: ["dss project-library create-folder python/mylib",],
+    },
+    put: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-library put <path> (--content TEXT|--file PATH|--stdin) [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("put", {
+                    method: "POST",
+                    endpoint: projectLibraryContentsEndpoint(c, pk, a[0]),
+                    identifiers: { path: a[0], },
+                    payload: projectLibraryPutPayload(f),
+                });
+            }
+            const content = typeof f["content"] === "string"
+                ? f["content"]
+                : typeof f["file"] === "string"
+                    ? readFileSync(f["file"], "utf-8")
+                    : await readStdinText();
+            await c.projectLibrary.addOrUpdateFile(a[0], content, pk);
+            return { updated: a[0], };
+        },
+        usage: "dss project-library put <path> (--content TEXT|--file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Create or overwrite a project library file with raw text content.",
+        examples: ["dss project-library put python/mylib/utils.py --file ./utils.py",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss project-library delete <path> [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("delete", {
+                    method: "DELETE",
+                    endpoint: projectLibraryContentsEndpoint(c, pk, a[0]),
+                    identifiers: { path: a[0], },
+                });
+            }
+            await c.projectLibrary.deleteFile(a[0], pk);
+            return { deleted: a[0], };
+        },
+        usage: "dss project-library delete <path> [--dry-run] [--project-key KEY]",
+        description: "Delete a project library file or folder.",
+        examples: ["dss project-library delete python/mylib/old.py",],
+    },
+    rename: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss project-library rename <path> <new-name> [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("rename", {
+                    method: "POST",
+                    endpoint: projectLibraryActionEndpoint(c, pk, "rename/"),
+                    identifiers: { path: a[0], newName: a[1], },
+                    payload: { oldPath: `/${normalizeLibraryPath(a[0])}`, newName: a[1], },
+                });
+            }
+            await c.projectLibrary.rename(a[0], a[1], pk);
+            return { renamed: a[0], to: a[1], };
+        },
+        usage: "dss project-library rename <path> <new-name> [--dry-run] [--project-key KEY]",
+        description: "Rename a project library file or folder within its parent.",
+        examples: ["dss project-library rename python/mylib/old.py new.py",],
+    },
+    move: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss project-library move <path> <destination-folder> [--dry-run] [--project-key KEY]");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                return projectLibraryPlan("move", {
+                    method: "POST",
+                    endpoint: projectLibraryActionEndpoint(c, pk, "move"),
+                    identifiers: { path: a[0], destinationFolder: a[1], },
+                    payload: {
+                        oldPath: `/${normalizeLibraryPath(a[0])}`,
+                        newPath: normalizeLibraryDestinationPath(a[1]),
+                    },
+                });
+            }
+            await c.projectLibrary.move(a[0], a[1], pk);
+            return { moved: a[0], to: a[1], };
+        },
+        usage: "dss project-library move <path> <destination-folder> [--dry-run] [--project-key KEY]",
+        description: "Move a project library file or folder into another folder.",
+        examples: ["dss project-library move python/old.py python/mylib",],
+    },
+};

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

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