@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/workspace.js

@@ -0,0 +1,795 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function workspaceDirFrom(props) {
+    return String(props.workspace_dir ?? process.cwd());
+}
+export function ensureWorkspacePath(workspaceDir, relativePath) {
+    if (!relativePath) {
+        throw new Error("Path cannot be empty");
+    }
+    if (path.isAbsolute(relativePath)) {
+        throw new Error("Absolute paths are not allowed. Use relative paths within workspace.");
+    }
+    if (relativePath.split(/[\\/]/).includes("..")) {
+        throw new Error("Parent directory traversal (..) is not allowed");
+    }
+    const full = path.resolve(workspaceDir, relativePath);
+    const root = path.resolve(workspaceDir);
+    if (!full.startsWith(root)) {
+        throw new Error("Path must be within workspace directory");
+    }
+    return full;
+}
+function formatTimestampedName(name) {
+    const now = new Date();
+    const pad = (v) => String(v).padStart(2, "0");
+    return name
+        .replaceAll("%Y", String(now.getFullYear()))
+        .replaceAll("%m", pad(now.getMonth() + 1))
+        .replaceAll("%d", pad(now.getDate()))
+        .replaceAll("%H", pad(now.getHours()))
+        .replaceAll("%M", pad(now.getMinutes()))
+        .replaceAll("%S", pad(now.getSeconds()));
+}
+function wildcardToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^${escaped.replaceAll("*", ".*")}$`);
+}
+async function walk(dir, recursive) {
+    const out = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        out.push(full);
+        if (recursive && entry.isDirectory()) {
+            out.push(...(await walk(full, true)));
+        }
+    }
+    return out;
+}
+function fileUri(fullPath) {
+    return `file://${fullPath}`;
+}
+function bytesFromUnknown(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (Array.isArray(value) && value.every((x) => Number.isInteger(x))) {
+        return new Uint8Array(value);
+    }
+    if (typeof value === "string") {
+        return Uint8Array.from(Buffer.from(value, "base64"));
+    }
+    return new Uint8Array();
+}
+export class GetWorkspaceDirNode extends BaseNode {
+    static nodeType = "nodetool.workspace.GetWorkspaceDir";
+    static title = "Get Workspace Dir";
+    static description = "Get the current workspace directory path.\n    workspace, directory, path";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        return { output: workspaceDirFrom(this.serialize()) };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Workspace Dir",
+        description: "The workspace directory"
+    })
+], GetWorkspaceDirNode.prototype, "workspace_dir", void 0);
+export class ListWorkspaceFilesNode extends BaseNode {
+    static nodeType = "nodetool.workspace.ListWorkspaceFiles";
+    static title = "List Workspace Files";
+    static description = "List files in the workspace directory matching a pattern.\n    workspace, files, list, directory";
+    static metadataOutputTypes = {
+        file: "str",
+        files: "list"
+    };
+    static isStreamingOutput = true;
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? ".");
+        const pattern = String(this.pattern ?? "*");
+        const recursive = Boolean(this.recursive ?? false);
+        const root = ensureWorkspacePath(workspace, relative);
+        const regex = wildcardToRegExp(pattern);
+        const all = await walk(root, recursive);
+        const results = [];
+        for (const item of all) {
+            if (regex.test(path.basename(item))) {
+                results.push(path.relative(workspace, item));
+            }
+        }
+        return {
+            file: results[0] ?? "",
+            files: results
+        };
+    }
+    async *genProcess() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? ".");
+        const pattern = String(this.pattern ?? "*");
+        const recursive = Boolean(this.recursive ?? false);
+        const root = ensureWorkspacePath(workspace, relative);
+        const regex = wildcardToRegExp(pattern);
+        const all = await walk(root, recursive);
+        const results = [];
+        for (const item of all) {
+            if (regex.test(path.basename(item))) {
+                const rel = path.relative(workspace, item);
+                results.push(rel);
+                yield { file: rel };
+            }
+        }
+        yield { files: results };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: ".",
+        title: "Path",
+        description: "Relative path within workspace (use . for workspace root)"
+    })
+], ListWorkspaceFilesNode.prototype, "path", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "*",
+        title: "Pattern",
+        description: "File pattern to match (e.g. *.txt, *.json)"
+    })
+], ListWorkspaceFilesNode.prototype, "pattern", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Recursive",
+        description: "Search subdirectories recursively"
+    })
+], ListWorkspaceFilesNode.prototype, "recursive", void 0);
+export class ReadTextFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.ReadTextFile";
+    static title = "Read Text File";
+    static description = "Read a text file from the workspace.\n    workspace, file, read, text";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const encoding = String(this.encoding ?? this.encoding ?? "utf-8");
+        const full = ensureWorkspacePath(workspace, relative);
+        const text = await fs.readFile(full, { encoding });
+        return { output: text };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], ReadTextFileNode.prototype, "path", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "utf-8",
+        title: "Encoding",
+        description: "Text encoding (utf-8, ascii, etc.)"
+    })
+], ReadTextFileNode.prototype, "encoding", void 0);
+export class WriteTextFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.WriteTextFile";
+    static title = "Write Text File";
+    static description = "Write text to a file in the workspace.\n    workspace, file, write, text, save";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const content = String(this.content ?? this.content ?? "");
+        const append = Boolean(this.append ?? this.append ?? false);
+        const encoding = String(this.encoding ?? this.encoding ?? "utf-8");
+        const full = ensureWorkspacePath(workspace, relative);
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        if (append) {
+            await fs.appendFile(full, content, { encoding });
+        }
+        else {
+            await fs.writeFile(full, content, { encoding });
+        }
+        return { output: relative };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], WriteTextFileNode.prototype, "path", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Content",
+        description: "Text content to write"
+    })
+], WriteTextFileNode.prototype, "content", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "utf-8",
+        title: "Encoding",
+        description: "Text encoding (utf-8, ascii, etc.)"
+    })
+], WriteTextFileNode.prototype, "encoding", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Append",
+        description: "Append to file instead of overwriting"
+    })
+], WriteTextFileNode.prototype, "append", void 0);
+export class ReadBinaryFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.ReadBinaryFile";
+    static title = "Read Binary File";
+    static description = "Read a binary file from the workspace as base64-encoded string.\n    workspace, file, read, binary";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        const data = await fs.readFile(full);
+        return { output: Buffer.from(data).toString("base64") };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], ReadBinaryFileNode.prototype, "path", void 0);
+export class WriteBinaryFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.WriteBinaryFile";
+    static title = "Write Binary File";
+    static description = "Write binary data (base64-encoded) to a file in the workspace.\n    workspace, file, write, binary, save";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const content = String(this.content ?? this.content ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        await fs.writeFile(full, Buffer.from(content, "base64"));
+        return { output: relative };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], WriteBinaryFileNode.prototype, "path", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Content",
+        description: "Base64-encoded binary content to write"
+    })
+], WriteBinaryFileNode.prototype, "content", void 0);
+export class DeleteWorkspaceFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.DeleteWorkspaceFile";
+    static title = "Delete Workspace File";
+    static description = "Delete a file or directory from the workspace.\n    workspace, file, delete, remove";
+    static metadataOutputTypes = {
+        output: "none"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const recursive = Boolean(this.recursive ?? this.recursive ?? false);
+        const full = ensureWorkspacePath(workspace, relative);
+        const stat = await fs.stat(full);
+        if (stat.isDirectory()) {
+            if (!recursive) {
+                throw new Error("Path is a directory. Set recursive=true to delete.");
+            }
+            await fs.rm(full, { recursive: true, force: false });
+        }
+        else {
+            await fs.unlink(full);
+        }
+        return { output: null };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file or directory within workspace"
+    })
+], DeleteWorkspaceFileNode.prototype, "path", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Recursive",
+        description: "Delete directories recursively"
+    })
+], DeleteWorkspaceFileNode.prototype, "recursive", void 0);
+export class CreateWorkspaceDirectoryNode extends BaseNode {
+    static nodeType = "nodetool.workspace.CreateWorkspaceDirectory";
+    static title = "Create Workspace Directory";
+    static description = "Create a directory in the workspace.\n    workspace, directory, create, folder";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        await fs.mkdir(full, { recursive: true });
+        return { output: relative };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to directory within workspace"
+    })
+], CreateWorkspaceDirectoryNode.prototype, "path", void 0);
+export class WorkspaceFileExistsNode extends BaseNode {
+    static nodeType = "nodetool.workspace.WorkspaceFileExists";
+    static title = "Workspace File Exists";
+    static description = "Check if a file or directory exists in the workspace.\n    workspace, file, exists, check";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        try {
+            await fs.access(full);
+            return { output: true };
+        }
+        catch {
+            return { output: false };
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path within workspace to check"
+    })
+], WorkspaceFileExistsNode.prototype, "path", void 0);
+export class GetWorkspaceFileInfoNode extends BaseNode {
+    static nodeType = "nodetool.workspace.GetWorkspaceFileInfo";
+    static title = "Get Workspace File Info";
+    static description = "Get information about a file in the workspace.\n    workspace, file, info, metadata";
+    static metadataOutputTypes = {
+        output: "dict"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        const stats = await fs.stat(full);
+        return {
+            output: {
+                path: relative,
+                name: path.basename(relative),
+                size: stats.size,
+                is_file: stats.isFile(),
+                is_directory: stats.isDirectory(),
+                created: new Date(stats.birthtimeMs).toISOString(),
+                modified: new Date(stats.mtimeMs).toISOString(),
+                accessed: new Date(stats.atimeMs).toISOString()
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], GetWorkspaceFileInfoNode.prototype, "path", void 0);
+export class CopyWorkspaceFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.CopyWorkspaceFile";
+    static title = "Copy Workspace File";
+    static description = "Copy a file within the workspace.\n    workspace, file, copy, duplicate";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const source = ensureWorkspacePath(workspace, String(this.source ?? this.source ?? ""));
+        const destRelative = String(this.destination ?? this.destination ?? "");
+        const destination = ensureWorkspacePath(workspace, destRelative);
+        await fs.mkdir(path.dirname(destination), { recursive: true });
+        await fs.cp(source, destination, { recursive: true });
+        return { output: destRelative };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Source",
+        description: "Relative source path within workspace"
+    })
+], CopyWorkspaceFileNode.prototype, "source", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Destination",
+        description: "Relative destination path within workspace"
+    })
+], CopyWorkspaceFileNode.prototype, "destination", void 0);
+export class MoveWorkspaceFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.MoveWorkspaceFile";
+    static title = "Move Workspace File";
+    static description = "Move or rename a file within the workspace.\n    workspace, file, move, rename";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const source = ensureWorkspacePath(workspace, String(this.source ?? this.source ?? ""));
+        const destRelative = String(this.destination ?? this.destination ?? "");
+        const destination = ensureWorkspacePath(workspace, destRelative);
+        await fs.mkdir(path.dirname(destination), { recursive: true });
+        await fs.rename(source, destination);
+        return { output: destRelative };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Source",
+        description: "Relative source path within workspace"
+    })
+], MoveWorkspaceFileNode.prototype, "source", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Destination",
+        description: "Relative destination path within workspace"
+    })
+], MoveWorkspaceFileNode.prototype, "destination", void 0);
+export class GetWorkspaceFileSizeNode extends BaseNode {
+    static nodeType = "nodetool.workspace.GetWorkspaceFileSize";
+    static title = "Get Workspace File Size";
+    static description = "Get file size in bytes for a workspace file.\n    workspace, file, size, bytes";
+    static metadataOutputTypes = {
+        output: "int"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        const stats = await fs.stat(full);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${relative}`);
+        }
+        return { output: stats.size };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path to file within workspace"
+    })
+], GetWorkspaceFileSizeNode.prototype, "path", void 0);
+export class IsWorkspaceFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.IsWorkspaceFile";
+    static title = "Is Workspace File";
+    static description = "Check if a path in the workspace is a file.\n    workspace, file, check, type";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        try {
+            const stats = await fs.stat(full);
+            return { output: stats.isFile() };
+        }
+        catch {
+            return { output: false };
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path within workspace to check"
+    })
+], IsWorkspaceFileNode.prototype, "path", void 0);
+export class IsWorkspaceDirectoryNode extends BaseNode {
+    static nodeType = "nodetool.workspace.IsWorkspaceDirectory";
+    static title = "Is Workspace Directory";
+    static description = "Check if a path in the workspace is a directory.\n    workspace, directory, check, type";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const relative = String(this.path ?? this.path ?? "");
+        const full = ensureWorkspacePath(workspace, relative);
+        try {
+            const stats = await fs.stat(full);
+            return { output: stats.isDirectory() };
+        }
+        catch {
+            return { output: false };
+        }
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Path",
+        description: "Relative path within workspace to check"
+    })
+], IsWorkspaceDirectoryNode.prototype, "path", void 0);
+export class JoinWorkspacePathsNode extends BaseNode {
+    static nodeType = "nodetool.workspace.JoinWorkspacePaths";
+    static title = "Join Workspace Paths";
+    static description = "Join path components relative to workspace.\n    workspace, path, join, combine";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const parts = Array.isArray(this.paths ?? this.paths)
+            ? (this.paths ?? this.paths)
+            : [];
+        if (parts.length === 0) {
+            throw new Error("paths cannot be empty");
+        }
+        // Workspace-relative paths are part of the workflow contract and must
+        // be portable across operating systems. Always emit POSIX separators
+        // and use the OS-native form only for the worktree validation below.
+        const joined = path.posix.join(...parts.map((p) => String(p)));
+        ensureWorkspacePath(workspace, joined);
+        return { output: joined };
+    }
+}
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Paths",
+        description: "Path components to join (relative to workspace)"
+    })
+], JoinWorkspacePathsNode.prototype, "paths", void 0);
+export class SaveImageFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.SaveImageFile";
+    static title = "Save Image File";
+    static description = "Save an image to a file in the workspace.\n    workspace, image, save, file, output";
+    static metadataOutputTypes = {
+        output: "image"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const image = (this.image ?? this.image ?? {});
+        const folder = String(this.folder ?? this.folder ?? ".");
+        const filename = formatTimestampedName(String(this.filename ?? this.filename ?? "image.png"));
+        const overwrite = Boolean(this.overwrite ?? this.overwrite ?? false);
+        let relative = path.join(folder, filename);
+        let full = ensureWorkspacePath(workspace, relative);
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        if (!overwrite) {
+            let count = 1;
+            while (true) {
+                try {
+                    await fs.access(full);
+                    const ext = path.extname(filename);
+                    const base = filename.slice(0, Math.max(0, filename.length - ext.length));
+                    const next = `${base}_${count}${ext}`;
+                    relative = path.join(folder, next);
+                    full = ensureWorkspacePath(workspace, relative);
+                    count += 1;
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        const bytes = bytesFromUnknown(image.data);
+        await fs.writeFile(full, bytes);
+        return {
+            output: {
+                uri: fileUri(full),
+                data: Buffer.from(bytes).toString("base64")
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "image",
+        default: {
+            type: "image",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Image",
+        description: "The image to save"
+    })
+], SaveImageFileNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: ".",
+        title: "Folder",
+        description: "Relative folder path within workspace (use . for workspace root)"
+    })
+], SaveImageFileNode.prototype, "folder", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "image.png",
+        title: "Filename",
+        description: "\n        The name of the image file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
+    })
+], SaveImageFileNode.prototype, "filename", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Overwrite",
+        description: "Overwrite the file if it already exists, otherwise file will be renamed"
+    })
+], SaveImageFileNode.prototype, "overwrite", void 0);
+export class SaveVideoFileNode extends BaseNode {
+    static nodeType = "nodetool.workspace.SaveVideoFile";
+    static title = "Save Video File";
+    static description = "Save a video file to the workspace.\n    workspace, video, save, file, output\n\n    The filename can include time and date variables:\n    %Y - Year, %m - Month, %d - Day\n    %H - Hour, %M - Minute, %S - Second";
+    static metadataOutputTypes = {
+        output: "video"
+    };
+    async process() {
+        const workspace = workspaceDirFrom(this.serialize());
+        const video = (this.video ?? this.video ?? {});
+        const folder = String(this.folder ?? this.folder ?? ".");
+        const filename = formatTimestampedName(String(this.filename ?? this.filename ?? "video.mp4"));
+        const overwrite = Boolean(this.overwrite ?? this.overwrite ?? false);
+        let relative = path.join(folder, filename);
+        let full = ensureWorkspacePath(workspace, relative);
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        if (!overwrite) {
+            let count = 1;
+            while (true) {
+                try {
+                    await fs.access(full);
+                    const ext = path.extname(filename);
+                    const base = filename.slice(0, Math.max(0, filename.length - ext.length));
+                    const next = `${base}_${count}${ext}`;
+                    relative = path.join(folder, next);
+                    full = ensureWorkspacePath(workspace, relative);
+                    count += 1;
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        const bytes = bytesFromUnknown(video.data);
+        await fs.writeFile(full, bytes);
+        return {
+            output: {
+                uri: fileUri(full),
+                data: Buffer.from(bytes).toString("base64")
+            }
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "video",
+        default: {
+            type: "video",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null,
+            duration: null,
+            format: null
+        },
+        title: "Video",
+        description: "The video to save"
+    })
+], SaveVideoFileNode.prototype, "video", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: ".",
+        title: "Folder",
+        description: "Relative folder path within workspace (use . for workspace root)"
+    })
+], SaveVideoFileNode.prototype, "folder", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "video.mp4",
+        title: "Filename",
+        description: "\n        Name of the file to save.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
+    })
+], SaveVideoFileNode.prototype, "filename", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Overwrite",
+        description: "Overwrite the file if it already exists, otherwise file will be renamed"
+    })
+], SaveVideoFileNode.prototype, "overwrite", void 0);
+export const WORKSPACE_NODES = [
+    GetWorkspaceDirNode,
+    ListWorkspaceFilesNode,
+    ReadTextFileNode,
+    WriteTextFileNode,
+    ReadBinaryFileNode,
+    WriteBinaryFileNode,
+    DeleteWorkspaceFileNode,
+    CreateWorkspaceDirectoryNode,
+    WorkspaceFileExistsNode,
+    GetWorkspaceFileInfoNode,
+    CopyWorkspaceFileNode,
+    MoveWorkspaceFileNode,
+    GetWorkspaceFileSizeNode,
+    IsWorkspaceFileNode,
+    IsWorkspaceDirectoryNode,
+    JoinWorkspacePathsNode,
+    SaveImageFileNode,
+    SaveVideoFileNode
+];
+//# sourceMappingURL=workspace.js.map