web-a2e 1.0.0

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

@@ -0,0 +1,222 @@
+/*
+ * main-tools.js - Main emulator control tools
+ *
+ * Written by
+ *  Shawn Bullock <shawn@agenticexpert.ai>
+ */
+
+/**
+ * Parse address or length value from hex ($xxxx) or decimal format
+ * @param {string|number} value - Value to parse
+ * @param {string} paramName - Parameter name for error messages
+ * @returns {number} Parsed integer value
+ */
+function parseHexOrDecimal(value, paramName) {
+  if (value === undefined || value === null) {
+    throw new Error(`${paramName} parameter is required`);
+  }
+
+  // If already a number, use it directly
+  if (typeof value === "number") {
+    return Math.floor(value);
+  }
+
+  // If string, check for hex prefix
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+
+    // Hex format: $xxxx or 0xXXXX
+    if (trimmed.startsWith("$")) {
+      const parsed = parseInt(trimmed.substring(1), 16);
+      if (isNaN(parsed)) {
+        throw new Error(`Invalid hex ${paramName}: ${value}`);
+      }
+      return parsed;
+    }
+
+    if (trimmed.toLowerCase().startsWith("0x")) {
+      const parsed = parseInt(trimmed, 16);
+      if (isNaN(parsed)) {
+        throw new Error(`Invalid hex ${paramName}: ${value}`);
+      }
+      return parsed;
+    }
+
+    // Decimal format
+    const parsed = parseInt(trimmed, 10);
+    if (isNaN(parsed)) {
+      throw new Error(`Invalid decimal ${paramName}: ${value}`);
+    }
+    return parsed;
+  }
+
+  throw new Error(`${paramName} must be a number or string`);
+}
+
+export const mainTools = {
+  /**
+   * Power control
+   */
+  emulatorPower: async (args) => {
+    const { action = "toggle" } = args;
+
+    const emulator = window.emulator;
+    if (!emulator) {
+      throw new Error("Emulator not available");
+    }
+
+    if (action === "on" && !emulator.running) {
+      emulator.start();
+    } else if (action === "off" && emulator.running) {
+      emulator.stop();
+    } else if (action === "toggle") {
+      if (emulator.running) {
+        emulator.stop();
+      } else {
+        emulator.start();
+      }
+    }
+
+    return {
+      success: true,
+      running: emulator.running,
+      message: `Emulator is now ${emulator.running ? "running" : "stopped"}`,
+    };
+  },
+
+  /**
+   * Ctrl-Reset (warm reset)
+   */
+  emulatorCtrlReset: async (args) => {
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("Emulator not available");
+    }
+
+    wasmModule._warmReset();
+
+    return {
+      success: true,
+      message: "Ctrl-Reset executed (warm reset)",
+    };
+  },
+
+  /**
+   * Reboot (cold reset)
+   */
+  emulatorReboot: async (args) => {
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("Emulator not available");
+    }
+
+    wasmModule._reset();
+
+    return {
+      success: true,
+      message: "Reboot executed (cold reset)",
+    };
+  },
+
+  /**
+   * Load binary data into memory at a specific address
+   */
+  directLoadBinaryAt: async (args) => {
+    const { address, contentBase64 } = args;
+
+    if (!contentBase64) {
+      throw new Error("contentBase64 parameter is required");
+    }
+
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Parse address (supports $xxxx hex or decimal)
+    const addr = parseHexOrDecimal(address, "address");
+
+    // Decode base64 to binary
+    const binaryString = atob(contentBase64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+
+    // Pause emulator while writing to ensure clean state
+    const wasPaused = wasmModule._isPaused();
+    wasmModule._setPaused(true);
+
+    // Write bytes using writeMemory (like assembler does)
+    for (let i = 0; i < bytes.length; i++) {
+      wasmModule._writeMemory((addr + i) & 0xffff, bytes[i]);
+    }
+
+    // Restore paused state
+    wasmModule._setPaused(wasPaused);
+
+    const addrHex = "$" + addr.toString(16).toUpperCase().padStart(4, "0");
+    const endAddr = (addr + bytes.length - 1) & 0xffff;
+    const endHex = "$" + endAddr.toString(16).toUpperCase().padStart(4, "0");
+
+    return {
+      success: true,
+      address: addr,
+      addressHex: addrHex,
+      size: bytes.length,
+      endAddress: endAddr,
+      endAddressHex: endHex,
+      message: `Loaded ${bytes.length} bytes to ${addrHex}-${endHex}`,
+    };
+  },
+
+  /**
+   * Save binary data from memory range to base64
+   */
+  directSaveBinaryRangeTo: async (args) => {
+    const { address, length } = args;
+
+    const wasmModule = window.emulator?.wasmModule;
+    if (!wasmModule) {
+      throw new Error("WASM module not available");
+    }
+
+    // Parse address and length (supports $xxxx hex or decimal)
+    const addr = parseHexOrDecimal(address, "address");
+    const len = parseHexOrDecimal(length, "length");
+
+    if (len <= 0) {
+      throw new Error("length must be > 0");
+    }
+
+    // Read bytes using peekMemory (no side effects)
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = wasmModule._peekMemory((addr + i) & 0xffff);
+    }
+
+    // Encode to base64
+    let binaryString = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binaryString += String.fromCharCode(bytes[i]);
+    }
+    const contentBase64 = btoa(binaryString);
+
+    const addrHex = "$" + addr.toString(16).toUpperCase().padStart(4, "0");
+    const lengthHex = "$" + len.toString(16).toUpperCase().padStart(4, "0");
+    const endAddr = (addr + len - 1) & 0xffff;
+    const endHex = "$" + endAddr.toString(16).toUpperCase().padStart(4, "0");
+
+    return {
+      success: true,
+      address: addr,
+      addressHex: addrHex,
+      length: len,
+      lengthHex: lengthHex,
+      endAddress: endAddr,
+      endAddressHex: endHex,
+      contentBase64: contentBase64,
+      message: `Read ${len} bytes (${lengthHex}) from ${addrHex}-${endHex}`,
+    };
+  },
+};

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

@@ -0,0 +1,303 @@
+/*
+ * slot-tools.js - Expansion slot management tools
+ *
+ * Written by
+ *  Shawn Bullock <shawn@agenticexpert.ai>
+ */
+
+// Slot metadata (matches slot-configuration-window.js)
+const SLOT_CONFIG = [
+  { slot: 1, compatible: [], fixed: false },
+  { slot: 2, compatible: ["smartport"], fixed: false },
+  { slot: 3, compatible: [], fixed: true },
+  { slot: 4, compatible: ["mockingboard", "mouse", "smartport"], fixed: false },
+  { slot: 5, compatible: ["thunderclock", "smartport"], fixed: false },
+  { slot: 6, compatible: ["disk2"], fixed: false },
+  { slot: 7, compatible: ["thunderclock", "smartport"], fixed: false },
+];
+
+const ALL_CARDS = ["disk2", "mockingboard", "thunderclock", "mouse", "smartport"];
+
+function getWasm() {
+  const wasmModule = window.emulator?.wasmModule;
+  if (!wasmModule) {
+    throw new Error("WASM module not available");
+  }
+  return wasmModule;
+}
+
+function getSlotCard(wasmModule, slot) {
+  const ptr = wasmModule._getSlotCard(slot);
+  return ptr ? wasmModule.UTF8ToString(ptr) : "empty";
+}
+
+function getSlotConfig(slot) {
+  return SLOT_CONFIG.find(cfg => cfg.slot === slot);
+}
+
+function setSlotCardWasm(wasmModule, slot, cardId) {
+  const cardIdPtr = wasmModule._malloc(cardId.length + 1);
+  wasmModule.stringToUTF8(cardId, cardIdPtr, cardId.length + 1);
+  wasmModule._setSlotCard(slot, cardIdPtr);
+  wasmModule._free(cardIdPtr);
+}
+
+function persistSlotConfig(wasmModule) {
+  try {
+    const config = {};
+    for (const cfg of SLOT_CONFIG) {
+      if (!cfg.fixed) {
+        config[cfg.slot] = getSlotCard(wasmModule, cfg.slot);
+      }
+    }
+    localStorage.setItem("a2e-slot-config", JSON.stringify(config));
+  } catch (e) {
+    // Non-fatal
+  }
+
+  // Refresh the slot configuration window UI if it exists
+  const slotWindow = window.emulator?.windowManager?.getWindow("slot-configuration");
+  if (slotWindow) {
+    slotWindow.loadSettings();
+    slotWindow.updateDisabledOptions();
+  }
+}
+
+export const slotTools = {
+  /**
+   * List all expansion slots with current card and available options
+   */
+  slotsListAll: async () => {
+    const wasmModule = getWasm();
+
+    // Get current card in every slot
+    const slotState = SLOT_CONFIG.map(cfg => ({
+      slot: cfg.slot,
+      currentCard: cfg.fixed ? "80col" : getSlotCard(wasmModule, cfg.slot),
+      fixed: cfg.fixed,
+      compatible: cfg.compatible,
+    }));
+
+    // Collect all cards currently installed
+    const installedCards = {};
+    for (const s of slotState) {
+      if (!s.fixed && s.currentCard !== "empty") {
+        installedCards[s.currentCard] = s.slot;
+      }
+    }
+
+    // For each slot, determine which compatible cards are available to install
+    const slots = slotState.map(s => {
+      const available = s.fixed
+        ? []
+        : s.compatible.filter(card => {
+          return !installedCards[card] || installedCards[card] === s.slot;
+        });
+
+      return {
+        slot: s.slot,
+        currentCard: s.currentCard,
+        fixed: s.fixed,
+        compatible: s.compatible,
+        available,
+      };
+    });
+
+    const uninstalled = ALL_CARDS.filter(card => !installedCards[card]);
+
+    return {
+      success: true,
+      slots,
+      installedCards,
+      uninstalledCards: uninstalled,
+      message: `${Object.keys(installedCards).length} card(s) installed, ${uninstalled.length} available`,
+    };
+  },
+
+  /**
+   * Install a card into a slot (auto-removes from previous slot if needed)
+   */
+  slotsInstallCard: async (args) => {
+    const { slot, card } = args;
+
+    if (slot === undefined || slot === null) {
+      throw new Error("slot parameter is required");
+    }
+    if (!card) {
+      throw new Error("card parameter is required");
+    }
+    if (!ALL_CARDS.includes(card)) {
+      throw new Error(`Unknown card: ${card}. Valid cards: ${ALL_CARDS.join(", ")}`);
+    }
+
+    const cfg = getSlotConfig(slot);
+    if (!cfg) {
+      throw new Error(`Invalid slot: ${slot}. Valid slots: 1-7`);
+    }
+    if (cfg.fixed) {
+      throw new Error(`Slot ${slot} is fixed and cannot be changed`);
+    }
+    if (!cfg.compatible.includes(card)) {
+      throw new Error(
+        `${card} is not compatible with slot ${slot}. Compatible: ${cfg.compatible.join(", ") || "none"}`
+      );
+    }
+
+    const wasmModule = getWasm();
+    const currentCard = getSlotCard(wasmModule, slot);
+
+    // Already installed in this slot
+    if (currentCard === card) {
+      return {
+        success: true,
+        slot,
+        card,
+        message: `${card} is already installed in slot ${slot}`,
+        reset: false,
+      };
+    }
+
+    // If the card is installed in another slot, remove it from there
+    let movedFrom = null;
+    for (const c of SLOT_CONFIG) {
+      if (!c.fixed && c.slot !== slot && getSlotCard(wasmModule, c.slot) === card) {
+        setSlotCardWasm(wasmModule, c.slot, "empty");
+        movedFrom = c.slot;
+        break;
+      }
+    }
+
+    // Install the card
+    setSlotCardWasm(wasmModule, slot, card);
+    persistSlotConfig(wasmModule);
+    wasmModule._reset();
+
+    const displaced = currentCard !== "empty" ? currentCard : null;
+    let message = `${card} installed in slot ${slot}. Emulator reset.`;
+    if (movedFrom) {
+      message = `${card} moved from slot ${movedFrom} to slot ${slot}. Emulator reset.`;
+    }
+    if (displaced && displaced !== card) {
+      message += ` Displaced ${displaced}.`;
+    }
+
+    return {
+      success: true,
+      slot,
+      card,
+      displaced,
+      movedFrom,
+      message,
+      reset: true,
+    };
+  },
+
+  /**
+   * Remove a card from a slot (set to empty)
+   */
+  slotsRemoveCard: async (args) => {
+    const { slot } = args;
+
+    if (slot === undefined || slot === null) {
+      throw new Error("slot parameter is required");
+    }
+
+    const cfg = getSlotConfig(slot);
+    if (!cfg) {
+      throw new Error(`Invalid slot: ${slot}. Valid slots: 1-7`);
+    }
+    if (cfg.fixed) {
+      throw new Error(`Slot ${slot} is fixed and cannot be changed`);
+    }
+
+    const wasmModule = getWasm();
+    const currentCard = getSlotCard(wasmModule, slot);
+
+    if (currentCard === "empty") {
+      return {
+        success: true,
+        slot,
+        message: `Slot ${slot} is already empty`,
+        reset: false,
+      };
+    }
+
+    setSlotCardWasm(wasmModule, slot, "empty");
+    persistSlotConfig(wasmModule);
+    wasmModule._reset();
+
+    return {
+      success: true,
+      slot,
+      removed: currentCard,
+      message: `Removed ${currentCard} from slot ${slot}. Emulator reset.`,
+      reset: true,
+    };
+  },
+
+  /**
+   * Move a card from one slot to another
+   */
+  slotsMoveCard: async (args) => {
+    const { fromSlot, toSlot } = args;
+
+    if (fromSlot === undefined || fromSlot === null) {
+      throw new Error("fromSlot parameter is required");
+    }
+    if (toSlot === undefined || toSlot === null) {
+      throw new Error("toSlot parameter is required");
+    }
+    if (fromSlot === toSlot) {
+      throw new Error("fromSlot and toSlot must be different");
+    }
+
+    const fromCfg = getSlotConfig(fromSlot);
+    const toCfg = getSlotConfig(toSlot);
+    if (!fromCfg) {
+      throw new Error(`Invalid fromSlot: ${fromSlot}. Valid slots: 1-7`);
+    }
+    if (!toCfg) {
+      throw new Error(`Invalid toSlot: ${toSlot}. Valid slots: 1-7`);
+    }
+    if (fromCfg.fixed) {
+      throw new Error(`Slot ${fromSlot} is fixed and cannot be changed`);
+    }
+    if (toCfg.fixed) {
+      throw new Error(`Slot ${toSlot} is fixed and cannot be changed`);
+    }
+
+    const wasmModule = getWasm();
+    const card = getSlotCard(wasmModule, fromSlot);
+
+    if (card === "empty") {
+      throw new Error(`Slot ${fromSlot} is empty — nothing to move`);
+    }
+
+    if (!toCfg.compatible.includes(card)) {
+      throw new Error(
+        `${card} is not compatible with slot ${toSlot}. Compatible: ${toCfg.compatible.join(", ") || "none"}`
+      );
+    }
+
+    const occupant = getSlotCard(wasmModule, toSlot);
+    if (occupant !== "empty") {
+      throw new Error(
+        `Slot ${toSlot} is occupied by ${occupant}. Remove it first with slotsRemoveCard.`
+      );
+    }
+
+    setSlotCardWasm(wasmModule, fromSlot, "empty");
+    setSlotCardWasm(wasmModule, toSlot, card);
+    persistSlotConfig(wasmModule);
+    wasmModule._reset();
+
+    return {
+      success: true,
+      card,
+      fromSlot,
+      toSlot,
+      message: `Moved ${card} from slot ${fromSlot} to slot ${toSlot}. Emulator reset.`,
+      reset: true,
+    };
+  },
+};