web-a2e 1.0.0

package/src/js/agent/disk-tools.js

@@ -0,0 +1,417 @@
+/*
+ * disk-tools.js - Disk drive operation tools
+ *
+ * Written by
+ *  Shawn Bullock <shawn@agenticexpert.ai>
+ */
+
+import { loadDiskFromData } from "../disk-manager/disk-operations.js";
+import { getRecentDisks, loadRecentDisk, clearRecentDisks } from "../disk-manager/disk-persistence.js";
+
+export const diskTools = {
+  /**
+   * Insert a disk image into a drive by path
+   */
+  driveInsertDisc: async (args) => {
+    const { driveNum = 1, path } = args;
+
+    if (!path) {
+      throw new Error("path parameter is required");
+    }
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Validate disk format
+    const supportedFormats = ['.dsk', '.do', '.po', '.nib', '.woz'];
+    const extension = path.toLowerCase().match(/\.(dsk|do|po|nib|woz)$/);
+
+    if (!extension) {
+      throw new Error(
+        `Unsupported disk format. Supported formats: ${supportedFormats.join(', ')}`
+      );
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    // Get disk manager and WASM module
+    const diskManager = window.emulator?.diskManager;
+    const wasmModule = window.emulator?.wasmModule;
+
+    if (!diskManager) {
+      throw new Error("Disk manager not available");
+    }
+
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Get drive state
+    const drive = diskManager.drives[driveIndex];
+    if (!drive) {
+      throw new Error(`Drive ${driveNum} not found`);
+    }
+
+    try {
+      // Call MCP tool to load disk image from filesystem
+      const agentManager = window.emulator?.agentManager;
+      if (!agentManager) {
+        throw new Error("Agent manager not available");
+      }
+
+      const result = await agentManager.callMCPTool("load_disk_image", { path });
+
+      if (!result || !result.success) {
+        throw new Error(result?.error || "Failed to load disk image");
+      }
+
+      // Decode base64 to Uint8Array
+      const binaryString = atob(result.data);
+      const data = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        data[i] = binaryString.charCodeAt(i);
+      }
+
+      // Use filename from MCP result
+      const filename = result.filename;
+
+      // Load disk using the disk operations helper
+      return new Promise((resolve, reject) => {
+        loadDiskFromData({
+          wasmModule,
+          drive,
+          driveNum: driveIndex,
+          filename,
+          data,
+          onSuccess: (loadedFilename) => {
+            // Update UI
+            diskManager.setDiskName(driveIndex, loadedFilename);
+
+            // Notify if callback exists
+            if (diskManager.onDiskLoaded) {
+              diskManager.onDiskLoaded(driveIndex, loadedFilename);
+            }
+
+            resolve({
+              success: true,
+              drive: driveNum,
+              filename: loadedFilename,
+              size: data.length,
+              message: `Disk inserted into drive ${driveNum}: ${loadedFilename}`,
+            });
+          },
+          onError: (error) => {
+            reject(new Error(`Failed to insert disk: ${error}`));
+          },
+        });
+      });
+    } catch (error) {
+      throw new Error(`Error loading disk image: ${error.message}`);
+    }
+  },
+
+  /**
+   * Get list of recent disks for a drive
+   */
+  driveRecentsList: async (args) => {
+    const { driveNum = 1 } = args;
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    try {
+      // Get recent disks from IndexedDB
+      const recentDisks = await getRecentDisks(driveIndex);
+
+      // Return list of filenames with access times
+      const diskList = recentDisks.map(disk => ({
+        filename: disk.filename,
+        accessedAt: disk.accessedAt,
+        id: disk.id,
+      }));
+
+      return {
+        success: true,
+        drive: driveNum,
+        count: diskList.length,
+        disks: diskList,
+        message: `Found ${diskList.length} recent disk(s) for drive ${driveNum}`,
+      };
+
+    } catch (error) {
+      throw new Error(`Error getting recent disks: ${error.message}`);
+    }
+  },
+
+  /**
+   * Insert a recent disk by name
+   */
+  driveInsertRecent: async (args) => {
+    const { driveNum = 1, name } = args;
+
+    if (!name) {
+      throw new Error("name parameter is required");
+    }
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    // Get disk manager and WASM module
+    const diskManager = window.emulator?.diskManager;
+    const wasmModule = window.emulator?.wasmModule;
+
+    if (!diskManager) {
+      throw new Error("Disk manager not available");
+    }
+
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Get drive state
+    const drive = diskManager.drives[driveIndex];
+    if (!drive) {
+      throw new Error(`Drive ${driveNum} not found`);
+    }
+
+    try {
+      // Get recent disks list
+      const recentDisks = await getRecentDisks(driveIndex);
+
+      // Find the disk by filename
+      const diskEntry = recentDisks.find(d => d.filename === name);
+      if (!diskEntry) {
+        throw new Error(`Disk "${name}" not found in recent list for drive ${driveNum}`);
+      }
+
+      // Load the disk data from IndexedDB
+      const diskData = await loadRecentDisk(diskEntry.id);
+      if (!diskData) {
+        throw new Error(`Failed to load disk data for "${name}"`);
+      }
+
+      // Load disk using the disk operations helper
+      return new Promise((resolve, reject) => {
+        loadDiskFromData({
+          wasmModule,
+          drive,
+          driveNum: driveIndex,
+          filename: diskData.filename,
+          data: diskData.data,
+          onSuccess: (loadedFilename) => {
+            // Update UI
+            diskManager.setDiskName(driveIndex, loadedFilename);
+
+            // Notify if callback exists
+            if (diskManager.onDiskLoaded) {
+              diskManager.onDiskLoaded(driveIndex, loadedFilename);
+            }
+
+            resolve({
+              success: true,
+              drive: driveNum,
+              filename: loadedFilename,
+              size: diskData.data.length,
+              message: `Recent disk inserted into drive ${driveNum}: ${loadedFilename}`,
+            });
+          },
+          onError: (error) => {
+            reject(new Error(`Failed to insert disk: ${error}`));
+          },
+        });
+      });
+
+    } catch (error) {
+      throw new Error(`Error inserting recent disk: ${error.message}`);
+    }
+  },
+
+  /**
+   * Load a recent disk by filename
+   */
+  driveLoadRecent: async (args) => {
+    const { driveNum = 1, file } = args;
+
+    if (!file) {
+      throw new Error("file parameter is required");
+    }
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    // Get disk manager and WASM module
+    const diskManager = window.emulator?.diskManager;
+    const wasmModule = window.emulator?.wasmModule;
+
+    if (!diskManager) {
+      throw new Error("Disk manager not available");
+    }
+
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Get drive state
+    const drive = diskManager.drives[driveIndex];
+    if (!drive) {
+      throw new Error(`Drive ${driveNum} not found`);
+    }
+
+    try {
+      // Get recent disks list
+      const recentDisks = await getRecentDisks(driveIndex);
+
+      // Find the disk by filename
+      const diskEntry = recentDisks.find(d => d.filename === file);
+      if (!diskEntry) {
+        throw new Error(`Disk "${file}" not found in recent list for drive ${driveNum}`);
+      }
+
+      // Load the disk data from IndexedDB
+      const diskData = await loadRecentDisk(diskEntry.id);
+      if (!diskData) {
+        throw new Error(`Failed to load disk data for "${file}"`);
+      }
+
+      // Load disk using the disk operations helper
+      return new Promise((resolve, reject) => {
+        loadDiskFromData({
+          wasmModule,
+          drive,
+          driveNum: driveIndex,
+          filename: diskData.filename,
+          data: diskData.data,
+          onSuccess: (loadedFilename) => {
+            // Update UI
+            diskManager.setDiskName(driveIndex, loadedFilename);
+
+            // Notify if callback exists
+            if (diskManager.onDiskLoaded) {
+              diskManager.onDiskLoaded(driveIndex, loadedFilename);
+            }
+
+            resolve({
+              success: true,
+              drive: driveNum,
+              filename: loadedFilename,
+              size: diskData.data.length,
+              message: `Recent disk loaded into drive ${driveNum}: ${loadedFilename}`,
+            });
+          },
+          onError: (error) => {
+            reject(new Error(`Failed to insert disk: ${error}`));
+          },
+        });
+      });
+
+    } catch (error) {
+      throw new Error(`Error loading recent disk: ${error.message}`);
+    }
+  },
+
+  /**
+   * Clear all recent disks for a drive
+   */
+  drivesClearRecent: async (args) => {
+    const { driveNum = 1 } = args;
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    try {
+      // Clear recent disks from IndexedDB
+      await clearRecentDisks(driveIndex);
+
+      return {
+        success: true,
+        drive: driveNum,
+        message: `Cleared all recent disks for drive ${driveNum}`,
+      };
+
+    } catch (error) {
+      throw new Error(`Error clearing recent disks: ${error.message}`);
+    }
+  },
+
+  /**
+   * Eject a disk from a drive
+   */
+  diskDriveEject: async (args) => {
+    const { driveNum = 1 } = args;
+
+    // Validate driveNum (1 or 2)
+    if (driveNum !== 1 && driveNum !== 2) {
+      throw new Error("driveNum must be 1 or 2");
+    }
+
+    // Convert to 0-based index
+    const driveIndex = driveNum - 1;
+
+    // Get disk manager and WASM module
+    const diskManager = window.emulator?.diskManager;
+    const wasmModule = window.emulator?.wasmModule;
+
+    if (!diskManager) {
+      throw new Error("Disk manager not available");
+    }
+
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Check if a disk is inserted
+    const isDiskInserted = wasmModule._isDiskInserted(driveIndex);
+    if (!isDiskInserted) {
+      return {
+        success: true,
+        drive: driveNum,
+        message: `No disk in drive ${driveNum}`,
+      };
+    }
+
+    try {
+      // Eject disk via WASM
+      wasmModule._ejectDisk(driveIndex);
+
+      // Update UI
+      diskManager.setDiskName(driveIndex, null);
+
+      // Notify if callback exists
+      if (diskManager.onDiskEjected) {
+        diskManager.onDiskEjected(driveIndex);
+      }
+
+      return {
+        success: true,
+        drive: driveNum,
+        message: `Disk ejected from drive ${driveNum}`,
+      };
+
+    } catch (error) {
+      throw new Error(`Error ejecting disk: ${error.message}`);
+    }
+  },
+};

package/src/js/agent/file-explorer-tools.js

@@ -0,0 +1,269 @@
+/*
+ * file-explorer-tools.js - File Explorer window tools
+ *
+ * Written by
+ *  Shawn Bullock <shawn@agenticexpert.ai>
+ */
+
+export const fileExplorerTools = {
+  /**
+   * List files in a disk drive
+   */
+  listDiskFiles: async (args) => {
+    const { drive = 0 } = args;
+
+    if (drive !== 0 && drive !== 1) {
+      throw new Error("drive must be 0 or 1");
+    }
+
+    const windowManager = window.emulator?.windowManager;
+    if (!windowManager) {
+      throw new Error("Window manager not available");
+    }
+
+    const feWindow = windowManager.getWindow("file-explorer-window");
+    if (!feWindow) {
+      throw new Error("File explorer window not found");
+    }
+
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Check if disk is inserted
+    if (!wasmModule._isDiskInserted(drive)) {
+      return {
+        success: false,
+        drive: drive,
+        format: null,
+        files: [],
+        message: `No disk in drive ${drive + 1}`,
+      };
+    }
+
+    // Get disk data
+    const sizePtr = wasmModule._malloc(4);
+    const dataPtr = wasmModule._getDiskSectorData(drive, sizePtr);
+    const size = new Uint32Array(wasmModule.HEAPU8.buffer, sizePtr, 1)[0];
+    wasmModule._free(sizePtr);
+
+    if (!dataPtr || size === 0) {
+      return {
+        success: false,
+        drive: drive,
+        format: null,
+        files: [],
+        message: "Cannot read disk data",
+      };
+    }
+
+    // Detect format and read catalog
+    let format = null;
+    let files = [];
+    let volumeName = null;
+
+    if (wasmModule._isProDOSFormat(dataPtr, size)) {
+      format = "prodos";
+      wasmModule._getProDOSVolumeInfo(dataPtr, size);
+      volumeName = wasmModule.UTF8ToString(wasmModule._getProDOSVolumeName());
+
+      const count = wasmModule._getProDOSCatalog(dataPtr, size);
+      for (let i = 0; i < count; i++) {
+        const fileType = wasmModule._getProDOSEntryFileType(i);
+        const isDirectory = wasmModule._getProDOSEntryIsDirectory(i);
+
+        files.push({
+          filename: wasmModule.UTF8ToString(
+            wasmModule._getProDOSEntryFilename(i),
+          ),
+          path: wasmModule.UTF8ToString(wasmModule._getProDOSEntryPath(i)),
+          type: fileType,
+          typeName: wasmModule.UTF8ToString(
+            wasmModule._getProDOSEntryFileTypeName(i),
+          ),
+          isDirectory: isDirectory,
+          isLocked: wasmModule._getProDOSEntryIsLocked(i),
+          size: wasmModule._getProDOSEntryEOF(i),
+          blocks: wasmModule._getProDOSEntryBlocksUsed(i),
+          index: i,
+        });
+      }
+    } else if (wasmModule._isDOS33Format(dataPtr, size)) {
+      format = "dos33";
+
+      const count = wasmModule._getDOS33Catalog(dataPtr, size);
+      for (let i = 0; i < count; i++) {
+        const fileType = wasmModule._getDOS33EntryFileType(i);
+
+        files.push({
+          filename: wasmModule.UTF8ToString(
+            wasmModule._getDOS33EntryFilename(i),
+          ),
+          type: fileType,
+          typeName: wasmModule.UTF8ToString(
+            wasmModule._getDOS33EntryFileTypeName(i),
+          ),
+          isLocked: wasmModule._getDOS33EntryIsLocked(i),
+          sectors: wasmModule._getDOS33EntrySectorCount(i),
+          index: i,
+        });
+      }
+    }
+
+    return {
+      success: true,
+      drive: drive,
+      format: format,
+      volumeName: volumeName,
+      fileCount: files.length,
+      files: files,
+      message: `Found ${files.length} file(s) on ${format ? format.toUpperCase() : "Unknown"} disk in drive ${drive + 1}`,
+    };
+  },
+
+  /**
+   * Get file content from disk
+   */
+  getDiskFileContent: async (args) => {
+    const { drive = 0, filename, isBinary = true } = args;
+
+    if (!filename) {
+      throw new Error("filename parameter is required");
+    }
+
+    if (drive !== 0 && drive !== 1) {
+      throw new Error("drive must be 0 or 1");
+    }
+
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Check if disk is inserted
+    if (!wasmModule._isDiskInserted(drive)) {
+      throw new Error(`No disk in drive ${drive + 1}`);
+    }
+
+    // Get disk data
+    const sizePtr = wasmModule._malloc(4);
+    const dataPtr = wasmModule._getDiskSectorData(drive, sizePtr);
+    const size = new Uint32Array(wasmModule.HEAPU8.buffer, sizePtr, 1)[0];
+    wasmModule._free(sizePtr);
+
+    if (!dataPtr || size === 0) {
+      throw new Error("Cannot read disk data");
+    }
+
+    // Detect format and find file
+    let format = null;
+    let fileIndex = -1;
+    let fileData = null;
+
+    if (wasmModule._isProDOSFormat(dataPtr, size)) {
+      format = "prodos";
+      const count = wasmModule._getProDOSCatalog(dataPtr, size);
+
+      // Find file by name or path
+      for (let i = 0; i < count; i++) {
+        const name = wasmModule.UTF8ToString(
+          wasmModule._getProDOSEntryFilename(i),
+        );
+        const path = wasmModule.UTF8ToString(
+          wasmModule._getProDOSEntryPath(i),
+        );
+
+        if (name === filename || path === filename) {
+          fileIndex = i;
+          break;
+        }
+      }
+
+      if (fileIndex === -1) {
+        throw new Error(`File not found: ${filename}`);
+      }
+
+      // Read file
+      const bytesRead = wasmModule._readProDOSFile(dataPtr, size, fileIndex);
+      if (bytesRead === 0) {
+        throw new Error("Failed to read file");
+      }
+
+      const bufPtr = wasmModule._getProDOSFileBuffer();
+      fileData = new Uint8Array(bytesRead);
+      fileData.set(new Uint8Array(wasmModule.HEAPU8.buffer, bufPtr, bytesRead));
+    } else if (wasmModule._isDOS33Format(dataPtr, size)) {
+      format = "dos33";
+      const count = wasmModule._getDOS33Catalog(dataPtr, size);
+
+      // Find file by name
+      for (let i = 0; i < count; i++) {
+        const name = wasmModule.UTF8ToString(
+          wasmModule._getDOS33EntryFilename(i),
+        );
+        if (name === filename) {
+          fileIndex = i;
+          break;
+        }
+      }
+
+      if (fileIndex === -1) {
+        throw new Error(`File not found: ${filename}`);
+      }
+
+      // Read file
+      const bytesRead = wasmModule._readDOS33File(dataPtr, size, fileIndex);
+      if (bytesRead === 0) {
+        throw new Error("Failed to read file");
+      }
+
+      const bufPtr = wasmModule._getDOS33FileBuffer();
+      fileData = new Uint8Array(bytesRead);
+      fileData.set(new Uint8Array(wasmModule.HEAPU8.buffer, bufPtr, bytesRead));
+    } else {
+      throw new Error("Unknown disk format");
+    }
+
+    // Return either base64 (binary) or plain text
+    if (isBinary) {
+      const base64 = btoa(String.fromCharCode(...fileData));
+      return {
+        success: true,
+        filename: filename,
+        drive: drive,
+        format: format,
+        size: fileData.length,
+        isBinary: true,
+        contentBase64: base64,
+        message: `Read ${fileData.length} bytes from ${filename}`,
+      };
+    } else {
+      // Decode as text (assuming ASCII/high-bit ASCII)
+      let text = "";
+      for (let i = 0; i < fileData.length; i++) {
+        const byte = fileData[i];
+        // Handle carriage return (0x0D) as newline
+        if (byte === 0x0d) {
+          text += "\n";
+        } else if (byte === 0x00) {
+          // Skip null bytes
+          continue;
+        } else {
+          // Strip high bit for high-bit ASCII
+          text += String.fromCharCode(byte & 0x7f);
+        }
+      }
+      return {
+        success: true,
+        filename: filename,
+        drive: drive,
+        format: format,
+        size: fileData.length,
+        isBinary: false,
+        content: text,
+        message: `Read ${fileData.length} bytes from ${filename}`,
+      };
+    }
+  },
+};

package/src/js/agent/index.js

@@ -0,0 +1,13 @@
+/*
+ * index.js - Agent module exports
+ *
+ * Written by
+ *  Shawn Bullock <shawn@agenticexpert.ai>
+ */
+
+export { AgentManager } from "./agent-manager.js";
+export { executeAgentTool, getAvailableTools } from "./agent-tools.js";
+export { windowTools } from "./window-tools.js";
+export { basicProgramTools } from "./basic-program-tools.js";
+export { mainTools } from "./main-tools.js";
+export { diskTools } from "./disk-tools.js";