@positronic/cli 0.0.3 → 0.0.5

package/src/commands/resources.test.ts

@@ -1,1052 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { createTestEnv, px, waitForTypesFile } from './test-utils.js';
-import path from 'path';
-import fs from 'fs';
-
-describe('CLI Integration: positronic resources types', () => {
-  it('should generate type definitions for resources', async () => {
-    const env = await createTestEnv();
-    const px = await env.start();
-    try {
-      const { waitForOutput, waitForTypesFile } = await px([
-        'resources',
-        'sync',
-      ]);
-      const isOutputRendered = await waitForOutput(/sync summary/i, 50);
-      const typesContent = await waitForTypesFile('config: TextResource;');
-      expect(isOutputRendered).toBe(true);
-      const normalizeWhitespace = (str: string) =>
-        str.replace(/\s+/g, ' ').trim();
-
-      const expectedContent = `declare module '@positronic/core' {
-        interface TextResource {
-          load(): Promise<string>;
-        }
-        interface BinaryResource {
-          load(): Promise<Buffer>;
-        }
-        interface Resources {
-          // Method signatures for loading resources by path
-          loadText(path: string): Promise<string>;
-          loadBinary(path: string): Promise<Buffer>;
-          // Resource properties accessible via dot notation
-          config: TextResource;
-          data: {
-            config: TextResource;
-            logo: BinaryResource;
-          };
-          docs: {
-            api: TextResource;
-            readme: TextResource;
-          };
-          example: TextResource;
-          readme: TextResource;
-          test: TextResource;
-        }
-      }`;
-
-      expect(normalizeWhitespace(typesContent)).toContain(
-        normalizeWhitespace(expectedContent)
-      );
-    } finally {
-      await env.stopAndCleanup();
-    }
-  });
-
-  it('should handle empty resources directory', async () => {
-    const env = await createTestEnv();
-    const px = await env.start();
-
-    try {
-      // Remove the default resources created by createMinimalProject
-      const resourcesDir = path.join(env.projectRootDir, 'resources');
-
-      // Remove all contents recursively and recreate empty directory
-      fs.rmSync(resourcesDir, { recursive: true, force: true });
-      fs.mkdirSync(resourcesDir);
-
-      // Verify directory is empty
-      expect(fs.readdirSync(resourcesDir).length).toBe(0);
-
-      // Run the sync command using cli
-      const syncElement = await px(['resources', 'sync']);
-      const isOutputRendered = await syncElement.waitForOutput(
-        /no files found in the resources directory/i
-      );
-      expect(isOutputRendered).toBe(true);
-      const typesContent = await syncElement.waitForTypesFile(
-        'loadText(path: string): Promise<string>;'
-      );
-
-      // Check if the types file was generated
-      expect(typesContent).toBeDefined();
-
-      // Should still have the basic structure
-      expect(typesContent).toContain("declare module '@positronic/core'");
-      expect(typesContent).toContain('interface Resources');
-      expect(typesContent).toContain('loadText(path: string): Promise<string>');
-      expect(typesContent).toContain(
-        'loadBinary(path: string): Promise<Buffer>'
-      );
-
-      // Run the list command
-      const listElement = await px(['resources', 'list']);
-
-      const resourceListOutput = await listElement.waitForOutput(
-        /no resources found in the project/i
-      );
-
-      expect(resourceListOutput).toBe(true);
-    } finally {
-      await env.stopAndCleanup();
-    }
-  });
-
-  it('should handle resources with special characters', async () => {
-    const env = await createTestEnv();
-
-    // Setup files with special characters
-    env.setup((dir: string) => {
-      // Create resources directory
-      const resourcesDir = path.join(dir, 'resources');
-
-      // Remove existing resources directory if it exists
-      if (fs.existsSync(resourcesDir)) {
-        fs.rmSync(resourcesDir, { recursive: true, force: true });
-      }
-
-      // Create fresh resources directory
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create files with special characters
-      fs.writeFileSync(path.join(resourcesDir, 'valid_file.txt'), 'content');
-      fs.writeFileSync(path.join(resourcesDir, '$special.txt'), 'content'); // Valid JS identifier
-      fs.writeFileSync(path.join(resourcesDir, '_underscore.txt'), 'content'); // Valid JS identifier
-      fs.writeFileSync(path.join(resourcesDir, '123invalid.txt'), 'content'); // Invalid - starts with number
-      fs.writeFileSync(
-        path.join(resourcesDir, 'special-chars!@#.txt'),
-        'content'
-      ); // Invalid
-    });
-
-    const px = await env.start();
-
-    try {
-      // Run the sync command first (types are generated as part of sync)
-      const { waitForOutput, waitForTypesFile } = await px([
-        'resources',
-        'sync',
-      ]);
-      const isOutputRendered = await waitForOutput(/sync summary/i);
-      expect(isOutputRendered).toBe(true);
-
-      // Wait for types file to be generated
-      const typesContent = await waitForTypesFile([
-        'valid_file: TextResource;',
-        '$special: TextResource;',
-        '_underscore: TextResource;',
-      ]);
-
-      // Verify the generated content
-      expect(typesContent).toBeDefined();
-
-      // Check valid identifiers are included
-      expect(typesContent).toContain('valid_file: TextResource;');
-      expect(typesContent).toContain('$special: TextResource;');
-      expect(typesContent).toContain('_underscore: TextResource;');
-
-      // Check invalid identifiers are excluded
-      expect(typesContent).not.toContain('123invalid');
-      expect(typesContent).not.toContain('special-chars');
-    } finally {
-      await env.stopAndCleanup();
-    }
-  });
-
-  it('should correctly identify text vs binary files', async () => {
-    const env = await createTestEnv();
-
-    // Setup files with various types
-    env.setup((dir: string) => {
-      // Create resources directory
-      const resourcesDir = path.join(dir, 'resources');
-
-      // Remove existing resources directory if it exists
-      if (fs.existsSync(resourcesDir)) {
-        fs.rmSync(resourcesDir, { recursive: true, force: true });
-      }
-
-      // Create fresh resources directory
-      fs.mkdirSync(resourcesDir, { recursive: true });
-
-      // Create various file types
-      fs.writeFileSync(path.join(resourcesDir, 'text.txt'), 'text');
-      fs.writeFileSync(path.join(resourcesDir, 'script.js'), 'code');
-      fs.writeFileSync(path.join(resourcesDir, 'config.json'), '{}');
-      fs.writeFileSync(path.join(resourcesDir, 'styles.css'), 'css');
-
-      // Create actual binary content for binary files
-      // JPEG magic bytes
-      const jpegHeader = Buffer.from([
-        0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46,
-      ]);
-      fs.writeFileSync(path.join(resourcesDir, 'image.jpg'), jpegHeader);
-
-      // Random binary data
-      const binaryData = Buffer.from([
-        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
-      ]);
-      fs.writeFileSync(path.join(resourcesDir, 'binary.bin'), binaryData);
-
-      // PDF magic bytes
-      const pdfHeader = Buffer.from('%PDF-1.4\n%âÌÊÓ\n');
-      fs.writeFileSync(path.join(resourcesDir, 'document.pdf'), pdfHeader);
-    });
-
-    const px = await env.start();
-
-    try {
-      // Run the sync command first (types are generated as part of sync)
-      const { waitForOutput, waitForTypesFile } = await px([
-        'resources',
-        'sync',
-      ]);
-
-      const isOutputRendered = await waitForOutput(/sync summary/i);
-      expect(isOutputRendered).toBe(true);
-
-      // Wait for types file to be generated with expected content
-      const typesContent = await waitForTypesFile([
-        'text: TextResource;',
-        'script: TextResource;',
-        'config: TextResource;',
-        'styles: TextResource;',
-        'image: BinaryResource;',
-        'binary: BinaryResource;',
-        'document: BinaryResource;',
-      ]);
-
-      // Verify the generated content
-      expect(typesContent).toBeDefined();
-
-      // Check text resources
-      expect(typesContent).toContain('text: TextResource;');
-      expect(typesContent).toContain('script: TextResource;');
-      expect(typesContent).toContain('config: TextResource;');
-      expect(typesContent).toContain('styles: TextResource;');
-
-      // Check binary resources
-      expect(typesContent).toContain('image: BinaryResource;');
-      expect(typesContent).toContain('binary: BinaryResource;');
-      expect(typesContent).toContain('document: BinaryResource;');
-    } finally {
-      await env.stopAndCleanup();
-    }
-  });
-
-  describe('resources list command', () => {
-    it('should handle empty resources', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-        const found = await waitForOutput(/No resources found in the project/);
-        expect(found).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should display resources with tree structure', async () => {
-      const env = await createTestEnv();
-
-      // Add resources with nested structure
-      env.server.addResource({
-        key: 'readme.txt',
-        type: 'text',
-        size: 1024,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'data/config.json',
-        type: 'text',
-        size: 2048,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'data/users/admin.json',
-        type: 'text',
-        size: 512,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'images/logo.png',
-        type: 'binary',
-        size: 10240,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-
-        // Check tree structure is displayed
-        const foundTree = await waitForOutput(/resources/);
-        expect(foundTree).toBe(true);
-
-        // Check for files in root
-        const foundReadme = await waitForOutput(/readme\.txt/);
-        expect(foundReadme).toBe(true);
-
-        // Check for nested directories
-        const foundData = await waitForOutput(/data/);
-        expect(foundData).toBe(true);
-
-        const foundConfig = await waitForOutput(/config\.json/);
-        expect(foundConfig).toBe(true);
-
-        // Check for deeply nested
-        const foundUsers = await waitForOutput(/users/);
-        expect(foundUsers).toBe(true);
-
-        const foundAdmin = await waitForOutput(/admin\.json/);
-        expect(foundAdmin).toBe(true);
-
-        // Check for images directory
-        const foundImages = await waitForOutput(/images/);
-        expect(foundImages).toBe(true);
-
-        const foundLogo = await waitForOutput(/logo\.png/);
-        expect(foundLogo).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should display file sizes with correct formatting', async () => {
-      const env = await createTestEnv();
-
-      // Add resources with various sizes
-      env.server.addResource({
-        key: 'small.txt',
-        type: 'text',
-        size: 500, // 500 bytes
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'medium.txt',
-        type: 'text',
-        size: 1536, // 1.5 KB
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'large.bin',
-        type: 'binary',
-        size: 1048576, // 1 MB
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'huge.bin',
-        type: 'binary',
-        size: 10485760, // 10 MB
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-
-        // Check size formatting
-        const foundSmall = await waitForOutput(/small\.txt.*500 B/);
-        expect(foundSmall).toBe(true);
-
-        const foundMedium = await waitForOutput(/medium\.txt.*1\.5 KB/);
-        expect(foundMedium).toBe(true);
-
-        const foundLarge = await waitForOutput(/large\.bin.*1\.0 MB/);
-        expect(foundLarge).toBe(true);
-
-        const foundHuge = await waitForOutput(/huge\.bin.*10\.0 MB/);
-        expect(foundHuge).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should indicate local vs remote resources', async () => {
-      const env = await createTestEnv();
-
-      // Add mix of local and remote resources
-      env.server.addResource({
-        key: 'local-file.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-      env.server.addResource({
-        key: 'remote-file.txt',
-        type: 'text',
-        size: 200,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-
-        // Check both files are listed
-        const foundLocal = await waitForOutput(/local-file\.txt/);
-        expect(foundLocal).toBe(true);
-
-        const foundRemote = await waitForOutput(/remote-file\.txt/);
-        expect(foundRemote).toBe(true);
-
-        // Remote resources should have arrow indicator
-        const foundArrow = await waitForOutput(/↗/);
-        expect(foundArrow).toBe(true);
-
-        // Should show legend for uploaded resources
-        const foundLegend = await waitForOutput(
-          /uploaded resource \(not in local filesystem\)/
-        );
-        expect(foundLegend).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should show loading state', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-
-      try {
-        // Stop server to simulate slow loading
-        env.server.stop();
-
-        const { waitForOutput, instance } = await px(['resources', 'list']);
-
-        // Should show loading message initially
-        const foundLoading = await waitForOutput(/Loading resources\.\.\./);
-        expect(foundLoading).toBe(true);
-
-        // Should eventually show error when server is down
-        const foundError = await waitForOutput(/Error connecting/);
-        expect(foundError).toBe(true);
-      } finally {
-        // Cleanup without stopping server (already stopped)
-        env.cleanup();
-      }
-    });
-
-    it('should display resource count summary', async () => {
-      const env = await createTestEnv();
-
-      // Add multiple resources
-      for (let i = 1; i <= 5; i++) {
-        env.server.addResource({
-          key: `file${i}.txt`,
-          type: 'text',
-          size: 100 * i,
-          lastModified: new Date().toISOString(),
-          local: i % 2 === 0, // Even numbers are local
-        });
-      }
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-
-        // Should show count in format "Found X resources:"
-        const foundCount = await waitForOutput(/Found 5 resources:/);
-        expect(foundCount).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should show single resource properly', async () => {
-      const env = await createTestEnv();
-
-      // Add a single resource to test singular form
-      env.server.addResource({
-        key: 'single.txt',
-        type: 'text',
-        size: 42,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'list']);
-
-        // Should show "Found 1 resource:" (singular)
-        const foundCount = await waitForOutput(/Found 1 resource:/);
-        expect(foundCount).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-  });
-
-  describe('resources delete command', () => {
-    it('should show error when resource does not exist', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          'non-existent.txt',
-        ]);
-
-        // Should show checking state
-        const foundChecking = await waitForOutput(/Checking resource\.\.\./);
-        expect(foundChecking).toBe(true);
-
-        // Should show warning for non-existent resource
-        const foundWarning = await waitForOutput(
-          /Warning: This will permanently delete/
-        );
-        expect(foundWarning).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should prevent deletion of local resources', async () => {
-      const env = await createTestEnv();
-
-      // Add a local resource
-      env.server.addResource({
-        key: 'local-file.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          'local-file.txt',
-        ]);
-
-        // Should show error about local resource
-        const foundError = await waitForOutput(/Cannot Delete Local Resource/);
-        expect(foundError).toBe(true);
-
-        // Should show explanation
-        const foundExplanation = await waitForOutput(
-          /This resource was synced from your local filesystem/
-        );
-        expect(foundExplanation).toBe(true);
-
-        // Should show instructions
-        const foundInstructions = await waitForOutput(
-          /delete the file locally and run 'px resources sync'/
-        );
-        expect(foundInstructions).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should show confirmation prompt for remote resources', async () => {
-      const env = await createTestEnv();
-
-      // Add a remote resource
-      env.server.addResource({
-        key: 'remote-file.txt',
-        type: 'text',
-        size: 200,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          'remote-file.txt',
-        ]);
-
-        // Should show warning
-        const foundWarning = await waitForOutput(
-          /Warning: This will permanently delete the following resource/
-        );
-        expect(foundWarning).toBe(true);
-
-        // Should show the resource path
-        const foundPath = await waitForOutput(/remote-file\.txt/);
-        expect(foundPath).toBe(true);
-
-        // Should show confirmation prompt
-        const foundPrompt = await waitForOutput(
-          /Type "yes" to confirm deletion:/
-        );
-        expect(foundPrompt).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should delete resource when using force flag', async () => {
-      const env = await createTestEnv();
-
-      // Add a remote resource BEFORE starting the server
-      env.server.addResource({
-        key: 'to-delete.txt',
-        type: 'text',
-        size: 300,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          '-f',
-          'to-delete.txt',
-        ]);
-
-        // Should check resource first
-        const foundChecking = await waitForOutput(/Checking resource\.\.\./);
-        expect(foundChecking).toBe(true);
-
-        // Should show success message (may skip the deleting message due to speed)
-        const foundSuccess = await waitForOutput(
-          /✅ Successfully deleted: to-delete\.txt/
-        );
-        expect(foundSuccess).toBe(true);
-
-        // Verify the resource was actually deleted
-        const calls = env.server.getLogs();
-        const deleteCall = calls.find(
-          (c) => c.method === 'deleteResource' && c.args[0] === 'to-delete.txt'
-        );
-        expect(deleteCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should still prevent deletion of local resources with force flag', async () => {
-      const env = await createTestEnv();
-
-      // Add a local resource
-      env.server.addResource({
-        key: 'local-file.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-        local: true,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          '-f',
-          'local-file.txt',
-        ]);
-
-        // Should still show error about local resource even with force flag
-        const foundError = await waitForOutput(/Cannot Delete Local Resource/);
-        expect(foundError).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle API connection errors', async () => {
-      const env = await createTestEnv();
-      // Don't start the server to simulate connection error
-
-      try {
-        const { waitForOutput } = await px(
-          ['resources', 'upload', '-d', 'any-resource.txt'],
-          { server: env.server }
-        );
-
-        // Should show checking message first
-        const foundChecking = await waitForOutput(/Checking resource\.\.\./);
-        expect(foundChecking).toBe(true);
-
-        // Should eventually show connection error
-        const foundError = await waitForOutput(/Error connecting/);
-        expect(foundError).toBe(true);
-      } finally {
-        // Just cleanup temp dir since server was never started
-      }
-    });
-
-    it('should handle nested resource paths with force flag', async () => {
-      const env = await createTestEnv();
-
-      // Add a nested resource
-      env.server.addResource({
-        key: 'folder/subfolder/nested-file.txt',
-        type: 'text',
-        size: 800,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          '-f',
-          'folder/subfolder/nested-file.txt',
-        ]);
-
-        // Should delete successfully
-        const foundSuccess = await waitForOutput(
-          /✅ Successfully deleted: folder\/subfolder\/nested-file\.txt/
-        );
-        expect(foundSuccess).toBe(true);
-
-        // Verify the resource was deleted
-        const calls = env.server.getLogs();
-        const deleteCall = calls.find(
-          (c) =>
-            c.method === 'deleteResource' &&
-            c.args[0] === 'folder/subfolder/nested-file.txt'
-        );
-        expect(deleteCall).toBeDefined();
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle nested resource paths without force flag', async () => {
-      const env = await createTestEnv();
-
-      // Add a nested resource
-      env.server.addResource({
-        key: 'folder/nested.txt',
-        type: 'text',
-        size: 400,
-        lastModified: new Date().toISOString(),
-        local: false,
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          'folder/nested.txt',
-        ]);
-
-        // Should show the full nested path in the warning
-        const foundPath = await waitForOutput(/folder\/nested\.txt/);
-        expect(foundPath).toBe(true);
-
-        // Should show confirmation prompt
-        const foundPrompt = await waitForOutput(
-          /Type "yes" to confirm deletion:/
-        );
-        expect(foundPrompt).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should show loading state while checking resource', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-
-      try {
-        // Stop server to simulate slow loading
-        env.server.stop();
-
-        const { waitForOutput } = await px([
-          'resources',
-          'upload',
-          '-d',
-          'any-file.txt',
-        ]);
-
-        // Should show checking message
-        const foundChecking = await waitForOutput(/Checking resource\.\.\./);
-        expect(foundChecking).toBe(true);
-
-        // Should eventually show error when server is down
-        const foundError = await waitForOutput(/Error/);
-        expect(foundError).toBe(true);
-      } finally {
-        // Cleanup without stopping server (already stopped)
-        env.cleanup();
-      }
-    });
-  });
-
-  describe('resources clear command', () => {
-    it('should handle empty resources gracefully', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-
-      try {
-        // TestDevServer starts with empty resources by default
-        const { waitForOutput } = await px(['resources', 'clear']);
-        const isOutputRendered = await waitForOutput(
-          /No resources to delete/,
-          20
-        );
-
-        expect(isOutputRendered).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should show warning for non-empty resources', async () => {
-      const env = await createTestEnv();
-
-      // Add some mock resources to the test server
-      env.server.addResource({
-        key: 'test.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-      });
-      env.server.addResource({
-        key: 'data/config.json',
-        type: 'text',
-        size: 200,
-        lastModified: new Date().toISOString(),
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput } = await px(['resources', 'clear']);
-
-        // Should show danger warning
-        const isWarningShown = await waitForOutput(
-          /DANGER: This will permanently delete ALL resources!/
-        );
-        expect(isWarningShown).toBe(true);
-
-        // Should show resource count (2 resources)
-        const isCountShown = await waitForOutput(
-          /This action will delete 2 resource\(s\)/
-        );
-        expect(isCountShown).toBe(true);
-
-        // Should show the selection prompt
-        const isPromptShown = await waitForOutput(
-          /Use arrow keys to select, Enter to confirm:/
-        );
-        expect(isPromptShown).toBe(true);
-
-        // Should show cancel option as selected by default
-        const isCancelSelected = await waitForOutput(
-          /▶ Cancel \(keep resources\)/
-        );
-        expect(isCancelSelected).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should navigate between options with arrow keys', async () => {
-      const env = await createTestEnv();
-
-      // Add a mock resource so we get the confirmation prompt
-      env.server.addResource({
-        key: 'test.txt',
-        type: 'text',
-        size: 100,
-        lastModified: new Date().toISOString(),
-      });
-
-      const px = await env.start();
-
-      try {
-        const { waitForOutput, instance } = await px(['resources', 'clear']);
-
-        // Wait for the prompt to appear
-        await waitForOutput(/Use arrow keys to select, Enter to confirm:/);
-
-        // Verify cancel is selected by default
-        const isCancelSelected = await waitForOutput(
-          /▶ Cancel \(keep resources\)/
-        );
-        expect(isCancelSelected).toBe(true);
-
-        // Press down arrow
-        instance.stdin.write('\u001B[B');
-
-        // Should show delete option as selected
-        const isDeleteSelected = await waitForOutput(
-          /▶ Delete all resources/,
-          30
-        );
-        expect(isDeleteSelected).toBe(true);
-
-        // Press up arrow to go back
-        instance.stdin.write('\u001B[A');
-
-        // Should show cancel option as selected again
-        const isCancelSelectedAgain = await waitForOutput(
-          /▶ Cancel \(keep resources\)/,
-          30
-        );
-        expect(isCancelSelectedAgain).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-  });
-
-  describe('resources types command', () => {
-    it('should generate resource types successfully', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const { waitForOutput } = await px(['resources', 'types']);
-        
-        // Test user-visible output
-        const foundSuccess = await waitForOutput(/Generated resource types at/i);
-        expect(foundSuccess).toBe(true);
-        
-        // Verify the types file was actually created
-        const typesPath = path.join(env.projectRootDir, 'resources.d.ts');
-        expect(fs.existsSync(typesPath)).toBe(true);
-        
-        // Verify basic content of the types file
-        const typesContent = fs.readFileSync(typesPath, 'utf-8');
-        expect(typesContent).toContain("declare module '@positronic/core'");
-        expect(typesContent).toContain('interface Resources');
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle type generation errors gracefully', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        // Make the project directory read-only to cause an error
-        const typesPath = path.join(env.projectRootDir, 'resources.d.ts');
-        
-        // Create a directory with the same name to cause a write error
-        fs.mkdirSync(typesPath);
-        
-        const { waitForOutput } = await px(['resources', 'types']);
-        
-        // Should show error message
-        const foundError = await waitForOutput(/Type Generation Failed/i);
-        expect(foundError).toBe(true);
-        
-        // Should show some error details
-        const foundDetails = await waitForOutput(/EISDIR|directory/i);
-        expect(foundDetails).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-  });
-
-  describe('resources upload command', () => {
-    // Testing the upload command's file validation behavior
-    // The actual upload requires presigned URLs which aren't available in test environment
-    
-    it('should handle non-existent file error', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        const nonExistentPath = path.join(env.projectRootDir, 'does-not-exist.txt');
-        
-        const { waitForOutput } = await px(['resources', 'upload', nonExistentPath]);
-        
-        // Should show error immediately since file check happens first
-        const foundError = await waitForOutput(/File Not Found/i);
-        expect(foundError).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should handle directory path error', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        // Try to upload a directory instead of a file
-        const dirPath = path.join(env.projectRootDir, 'resources');
-        
-        const { waitForOutput } = await px(['resources', 'upload', dirPath]);
-        
-        // Should show error
-        const foundError = await waitForOutput(/Invalid Path/i);
-        expect(foundError).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-
-    it('should validate files before attempting upload', async () => {
-      const env = await createTestEnv();
-      const px = await env.start();
-      
-      try {
-        // Create a test file
-        const testFilePath = path.join(env.projectRootDir, 'test.txt');
-        fs.writeFileSync(testFilePath, 'Hello, world!');
-        
-        const { waitForOutput } = await px(['resources', 'upload', testFilePath]);
-        
-        // The component will validate the file and attempt upload
-        // Without mocked presigned URLs, it will show an error about the API
-        const foundOutput = await waitForOutput(/Uploading test\.txt|Failed|Error/i);
-        expect(foundOutput).toBe(true);
-      } finally {
-        await env.stopAndCleanup();
-      }
-    });
-  });
-});