@rcrsr/rill 0.16.0 → 0.18.0

package/dist/ext/fs/index.js

@@ -7,8 +7,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { RuntimeError } from '../../error-classes.js';
-import { rillTypeToTypeValue, } from '../../runtime/core/values.js';
-import { resolvePath, matchesGlob, initializeMount, } from './sandbox.js';
+import { toCallable } from '../../runtime/core/callable.js';
+import { structureToTypeValue } from '../../runtime/core/values.js';
+import { resolvePath, matchesGlob, initializeMount, parseMountPath, } from './sandbox.js';
 export const configSchema = {
     mounts: { type: 'string', required: true },
 };
@@ -22,7 +23,7 @@ export const configSchema = {
  * Returns 12 functions: read, write, append, list, find, exists, remove, stat, mkdir, copy, move, mounts.
  *
  * @param config - Mount configuration and defaults
- * @returns ExtensionResult with 12 filesystem functions
+ * @returns ExtensionFactoryResult with 12 filesystem functions
  * @throws RuntimeError if mount initialization fails
  *
  * @example
@@ -75,8 +76,7 @@ export function createFsExtension(config) {
     // ctx and location not used but required by CallableFn signature
     ) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         // EC-5: Catch file not found from resolvePath
         let resolvedPath;
         try {
@@ -101,8 +101,7 @@ export function createFsExtension(config) {
      */
     const write = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         const content = args['content'];
         const resolvedPath = await resolvePath(mountName, filePath, mounts, 'write', true // createMode: resolve parent directory
         );
@@ -120,8 +119,7 @@ export function createFsExtension(config) {
      */
     const append = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         const content = args['content'];
         const resolvedPath = await resolvePath(mountName, filePath, mounts, 'write', true // createMode: allow new files
         );
@@ -157,8 +155,7 @@ export function createFsExtension(config) {
      */
     const list = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const dirPath = args['path'] ?? '';
+        const { mountName, relativePath: dirPath } = parseMountPath(args['path'], mounts);
         const resolvedPath = await resolvePath(mountName, dirPath, mounts, 'read');
         const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
         const result = [];
@@ -179,13 +176,20 @@ export function createFsExtension(config) {
      */
     const find = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
+        const { mountName, relativePath: searchBase } = parseMountPath(args['path'], mounts);
         const pattern = args['pattern'] ?? '*';
         const mount = mounts[mountName];
         if (!mount || !mount.resolvedPath) {
             throw new RuntimeError('RILL-R004', `mount "${mountName}" not configured`, undefined, { mountName });
         }
-        const basePath = mount.resolvedPath;
+        let basePath;
+        if (searchBase) {
+            // Validate searchBase through sandbox resolver to prevent path traversal
+            basePath = await resolvePath(mountName, searchBase, mounts, 'read');
+        }
+        else {
+            basePath = mount.resolvedPath;
+        }
         const results = [];
         // Recursive directory traversal
         const traverse = async (currentPath) => {
@@ -197,7 +201,7 @@ export function createFsExtension(config) {
                 }
                 else if (matchesGlob(entry.name, pattern)) {
                     // Return path relative to mount base
-                    const relativePath = path.relative(basePath, fullPath);
+                    const relativePath = path.relative(mount.resolvedPath, fullPath);
                     results.push(relativePath);
                 }
             }
@@ -211,8 +215,7 @@ export function createFsExtension(config) {
      */
     const exists = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         try {
             await resolvePath(mountName, filePath, mounts, 'read');
             return true;
@@ -231,8 +234,7 @@ export function createFsExtension(config) {
      */
     const remove = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         // Catch file not found from resolvePath
         let resolvedPath;
         try {
@@ -264,8 +266,7 @@ export function createFsExtension(config) {
      */
     const stat = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const filePath = args['path'];
+        const { mountName, relativePath: filePath } = parseMountPath(args['path'], mounts);
         // Catch file not found from resolvePath
         let resolvedPath;
         try {
@@ -294,8 +295,7 @@ export function createFsExtension(config) {
      */
     const mkdir = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const dirPath = args['path'];
+        const { mountName, relativePath: dirPath } = parseMountPath(args['path'], mounts);
         const mount = mounts[mountName];
         if (!mount || !mount.resolvedPath) {
             throw new RuntimeError('RILL-R004', `mount "${mountName}" not configured`, undefined, { mountName });
@@ -344,9 +344,13 @@ export function createFsExtension(config) {
      */
     const copy = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const srcPath = args['src'];
-        const destPath = args['dest'];
+        const { mountName: srcMountName, relativePath: srcPath } = parseMountPath(args['src'], mounts);
+        const { mountName: destMountName, relativePath: destPath } = parseMountPath(args['dest'], mounts);
+        const mountName = srcMountName;
+        // Verify same mount
+        if (srcMountName !== destMountName) {
+            throw new RuntimeError('RILL-R004', `copy requires same mount for src and dest`, undefined, { src: args['src'], dest: args['dest'] });
+        }
         const resolvedSrc = await resolvePath(mountName, srcPath, mounts, 'read');
         const resolvedDest = await resolvePath(mountName, destPath, mounts, 'write', true // createMode
         );
@@ -373,9 +377,13 @@ export function createFsExtension(config) {
      */
     const move = async (args) => {
         await ensureInitialized();
-        const mountName = args['mount'];
-        const srcPath = args['src'];
-        const destPath = args['dest'];
+        const { mountName: srcMountName, relativePath: srcPath } = parseMountPath(args['src'], mounts);
+        const { mountName: destMountName, relativePath: destPath } = parseMountPath(args['dest'], mounts);
+        const mountName = srcMountName;
+        // Verify same mount
+        if (srcMountName !== destMountName) {
+            throw new RuntimeError('RILL-R004', `move requires same mount for src and dest`, undefined, { src: args['src'], dest: args['dest'] });
+        }
         const resolvedSrc = await resolvePath(mountName, srcPath, mounts, 'read');
         const resolvedDest = await resolvePath(mountName, destPath, mounts, 'write', true // createMode
         );
@@ -412,244 +420,226 @@ export function createFsExtension(config) {
     // EXTENSION RESULT
     // ============================================================
     return {
-        read: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-            ],
-            fn: read,
-            annotations: { description: 'Read file contents' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        write: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-                {
-                    name: 'content',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Content to write' },
-                },
-            ],
-            fn: write,
-            annotations: { description: 'Write file, replacing if exists' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        append: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-                {
-                    name: 'content',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Content to append' },
-                },
-            ],
-            fn: append,
-            annotations: { description: 'Append content to file' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        list: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: '',
-                    annotations: { description: 'Directory path relative to mount' },
-                },
-            ],
-            fn: list,
-            annotations: { description: 'List directory contents' },
-            returnType: rillTypeToTypeValue({ type: 'list' }),
-        },
-        find: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'pattern',
-                    type: { type: 'string' },
-                    defaultValue: '*',
-                    annotations: { description: 'Glob pattern for filtering' },
-                },
-            ],
-            fn: find,
-            annotations: { description: 'Recursive file search' },
-            returnType: rillTypeToTypeValue({ type: 'list' }),
-        },
-        exists: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-            ],
-            fn: exists,
-            annotations: { description: 'Check file existence' },
-            returnType: rillTypeToTypeValue({ type: 'bool' }),
-        },
-        remove: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-            ],
-            fn: remove,
-            annotations: { description: 'Delete file' },
-            returnType: rillTypeToTypeValue({ type: 'bool' }),
-        },
-        stat: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'File path relative to mount' },
-                },
-            ],
-            fn: stat,
-            annotations: { description: 'Get file metadata' },
-            returnType: rillTypeToTypeValue({ type: 'dict' }),
-        },
-        mkdir: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'path',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Directory path relative to mount' },
-                },
-            ],
-            fn: mkdir,
-            annotations: { description: 'Create directory' },
-            returnType: rillTypeToTypeValue({ type: 'bool' }),
-        },
-        copy: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'src',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Source file path' },
-                },
-                {
-                    name: 'dest',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Destination file path' },
-                },
-            ],
-            fn: copy,
-            annotations: { description: 'Copy file within mount' },
-            returnType: rillTypeToTypeValue({ type: 'bool' }),
-        },
-        move: {
-            params: [
-                {
-                    name: 'mount',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Mount name' },
-                },
-                {
-                    name: 'src',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Source file path' },
-                },
-                {
-                    name: 'dest',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Destination file path' },
-                },
-            ],
-            fn: move,
-            annotations: { description: 'Move file within mount' },
-            returnType: rillTypeToTypeValue({ type: 'bool' }),
-        },
-        mounts: {
-            params: [],
-            fn: mountsList,
-            annotations: { description: 'List configured mounts' },
-            returnType: rillTypeToTypeValue({ type: 'list' }),
+        value: {
+            read: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                ],
+                fn: read,
+                annotations: { description: 'Read file contents' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            write: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                    {
+                        name: 'content',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Content to write' },
+                    },
+                ],
+                fn: write,
+                annotations: { description: 'Write file, replacing if exists' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            append: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                    {
+                        name: 'content',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Content to append' },
+                    },
+                ],
+                fn: append,
+                annotations: { description: 'Append content to file' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            list: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed directory path (e.g. "/mount/subdir")',
+                        },
+                    },
+                ],
+                fn: list,
+                annotations: { description: 'List directory contents' },
+                returnType: structureToTypeValue({
+                    kind: 'list',
+                    element: {
+                        kind: 'dict',
+                        fields: {
+                            name: { type: { kind: 'string' } },
+                            type: { type: { kind: 'string' } },
+                            size: { type: { kind: 'number' } },
+                        },
+                    },
+                }),
+            }),
+            find: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed base path (e.g. "/mount" or "/mount/subdir")',
+                        },
+                    },
+                    {
+                        name: 'pattern',
+                        type: { kind: 'string' },
+                        defaultValue: '*',
+                        annotations: { description: 'Glob pattern for filtering' },
+                    },
+                ],
+                fn: find,
+                annotations: { description: 'Recursive file search' },
+                returnType: structureToTypeValue({
+                    kind: 'list',
+                    element: { kind: 'string' },
+                }),
+            }),
+            exists: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                ],
+                fn: exists,
+                annotations: { description: 'Check file existence' },
+                returnType: structureToTypeValue({ kind: 'bool' }),
+            }),
+            remove: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                ],
+                fn: remove,
+                annotations: { description: 'Delete file' },
+                returnType: structureToTypeValue({ kind: 'bool' }),
+            }),
+            stat: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed file path (e.g. "/mount/file.txt")',
+                        },
+                    },
+                ],
+                fn: stat,
+                annotations: { description: 'Get file metadata' },
+                returnType: structureToTypeValue({
+                    kind: 'dict',
+                    fields: {
+                        name: { type: { kind: 'string' } },
+                        type: { type: { kind: 'string' } },
+                        size: { type: { kind: 'number' } },
+                        created: { type: { kind: 'string' } },
+                        modified: { type: { kind: 'string' } },
+                    },
+                }),
+            }),
+            mkdir: toCallable({
+                params: [
+                    {
+                        name: 'path',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: {
+                            description: 'Mount-prefixed directory path (e.g. "/mount/subdir")',
+                        },
+                    },
+                ],
+                fn: mkdir,
+                annotations: { description: 'Create directory' },
+                returnType: structureToTypeValue({ kind: 'bool' }),
+            }),
+            copy: toCallable({
+                params: [
+                    {
+                        name: 'src',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Mount-prefixed source path' },
+                    },
+                    {
+                        name: 'dest',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Mount-prefixed destination path' },
+                    },
+                ],
+                fn: copy,
+                annotations: { description: 'Copy file within mount' },
+                returnType: structureToTypeValue({ kind: 'bool' }),
+            }),
+            move: toCallable({
+                params: [
+                    {
+                        name: 'src',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Mount-prefixed source path' },
+                    },
+                    {
+                        name: 'dest',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Mount-prefixed destination path' },
+                    },
+                ],
+                fn: move,
+                annotations: { description: 'Move file within mount' },
+                returnType: structureToTypeValue({ kind: 'bool' }),
+            }),
+            mounts: toCallable({
+                params: [],
+                fn: mountsList,
+                annotations: { description: 'List configured mounts' },
+                returnType: structureToTypeValue({ kind: 'list' }),
+            }),
         },
     };
 }