@boba-cli/machine 0.1.0-alpha.1

package/dist/browser/index.js

@@ -0,0 +1,686 @@
+// src/style/index.ts
+var ESC = "\x1B[";
+var CODES = {
+  // Modifiers (open, close)
+  bold: ["1", "22"],
+  dim: ["2", "22"],
+  italic: ["3", "23"],
+  underline: ["4", "24"],
+  inverse: ["7", "27"],
+  hidden: ["8", "28"],
+  strikethrough: ["9", "29"],
+  // Basic foreground colors (30-37)
+  black: ["30", "39"],
+  red: ["31", "39"],
+  green: ["32", "39"],
+  yellow: ["33", "39"],
+  blue: ["34", "39"],
+  magenta: ["35", "39"],
+  cyan: ["36", "39"],
+  white: ["37", "39"],
+  // Bright foreground colors (90-97)
+  blackBright: ["90", "39"],
+  redBright: ["91", "39"],
+  greenBright: ["92", "39"],
+  yellowBright: ["93", "39"],
+  blueBright: ["94", "39"],
+  magentaBright: ["95", "39"],
+  cyanBright: ["96", "39"],
+  whiteBright: ["97", "39"],
+  // Basic background colors (40-47)
+  bgBlack: ["40", "49"],
+  bgRed: ["41", "49"],
+  bgGreen: ["42", "49"],
+  bgYellow: ["43", "49"],
+  bgBlue: ["44", "49"],
+  bgMagenta: ["45", "49"],
+  bgCyan: ["46", "49"],
+  bgWhite: ["47", "49"],
+  // Bright background colors (100-107)
+  bgBlackBright: ["100", "49"],
+  bgRedBright: ["101", "49"],
+  bgGreenBright: ["102", "49"],
+  bgYellowBright: ["103", "49"],
+  bgBlueBright: ["104", "49"],
+  bgMagentaBright: ["105", "49"],
+  bgCyanBright: ["106", "49"],
+  bgWhiteBright: ["107", "49"]
+};
+function applyStyle(text, open, close) {
+  const openSeq = `${ESC}${open}m`;
+  const closeSeq = `${ESC}${close}m`;
+  const replaced = text.replace(
+    new RegExp(closeSeq.replace(/[[\](){}|^$+*?.\\]/g, "\\$&"), "g"),
+    closeSeq + openSeq
+  );
+  return openSeq + replaced + closeSeq;
+}
+function hexToRgb(hex) {
+  const clean = hex.replace(/^#/, "");
+  const num = parseInt(clean, 16);
+  if (clean.length === 3) {
+    const r2 = (num >> 8 & 15) * 17;
+    const g2 = (num >> 4 & 15) * 17;
+    const b2 = (num & 15) * 17;
+    return [r2, g2, b2];
+  }
+  const r = num >> 16 & 255;
+  const g = num >> 8 & 255;
+  const b = num & 255;
+  return [r, g, b];
+}
+function createStyle(colorSupport) {
+  function build(stack) {
+    const fn = (text) => {
+      if (stack.length === 0) {
+        return text;
+      }
+      let result = text;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const [open, close] = stack[i];
+        result = applyStyle(result, open, close);
+      }
+      return result;
+    };
+    const codeNames = Object.keys(CODES);
+    for (const name of codeNames) {
+      const [open, close] = CODES[name];
+      Object.defineProperty(fn, name, {
+        get() {
+          return build([...stack, [open, close]]);
+        }
+      });
+    }
+    Object.defineProperty(fn, "gray", {
+      get() {
+        const [open, close] = CODES.blackBright;
+        return build([...stack, [open, close]]);
+      }
+    });
+    Object.defineProperty(fn, "grey", {
+      get() {
+        const [open, close] = CODES.blackBright;
+        return build([...stack, [open, close]]);
+      }
+    });
+    Object.defineProperty(fn, "hex", {
+      value: (color) => {
+        const [r, g, b] = hexToRgb(color);
+        return build([...stack, [`38;2;${r};${g};${b}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "rgb", {
+      value: (r, g, b) => {
+        return build([...stack, [`38;2;${r};${g};${b}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgHex", {
+      value: (color) => {
+        const [r, g, b] = hexToRgb(color);
+        return build([...stack, [`48;2;${r};${g};${b}`, "49"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgRgb", {
+      value: (r, g, b) => {
+        return build([...stack, [`48;2;${r};${g};${b}`, "49"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "ansi256", {
+      value: (code) => {
+        return build([...stack, [`38;5;${code}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgAnsi256", {
+      value: (code) => {
+        return build([...stack, [`48;5;${code}`, "49"]]);
+      },
+      writable: true
+    });
+    return fn;
+  }
+  return build([]);
+}
+function createAlwaysEnabledStyle() {
+  return createStyle();
+}
+
+// src/browser/archive.ts
+var BrowserArchiveAdapter = class {
+  /**
+   * Check if archive operations are available.
+   * @returns Always false in browser environments
+   */
+  isAvailable() {
+    return false;
+  }
+  /**
+   * Create a zip archive from a directory.
+   * @param _sourceDir - Source directory to archive
+   * @param _destPath - Destination path for the zip file
+   * @throws Error - Always throws as archiving is not available in browser
+   */
+  async zip(_sourceDir, _destPath) {
+    throw new Error("Archive operations not available in browser environment");
+  }
+  /**
+   * Extract a zip archive to a directory.
+   * @param _archivePath - Path to the zip file
+   * @param _destDir - Destination directory for extraction
+   * @throws Error - Always throws as archiving is not available in browser
+   */
+  async unzip(_archivePath, _destDir) {
+    throw new Error("Archive operations not available in browser environment");
+  }
+};
+
+// src/browser/clipboard.ts
+var BrowserClipboardAdapter = class {
+  async read() {
+    if (!this.isAvailable()) {
+      throw new Error("Clipboard API not available");
+    }
+    try {
+      return await navigator.clipboard.readText();
+    } catch (error) {
+      throw new Error(
+        `Failed to read from clipboard: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async write(text) {
+    if (!this.isAvailable()) {
+      throw new Error("Clipboard API not available");
+    }
+    try {
+      await navigator.clipboard.writeText(text);
+    } catch (error) {
+      throw new Error(
+        `Failed to write to clipboard: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  isAvailable() {
+    return typeof navigator !== "undefined" && typeof navigator.clipboard !== "undefined" && typeof navigator.clipboard.readText === "function" && typeof navigator.clipboard.writeText === "function";
+  }
+};
+
+// src/browser/environment.ts
+var BrowserEnvironmentAdapter = class {
+  envOverrides;
+  colorSupportCached = null;
+  backgroundCached = null;
+  /**
+   * Create a new browser environment adapter.
+   * @param envOverrides - Optional environment variable overrides
+   */
+  constructor(envOverrides = {}) {
+    this.envOverrides = new Map(Object.entries(envOverrides));
+  }
+  get(name) {
+    if (this.envOverrides.has(name)) {
+      return this.envOverrides.get(name);
+    }
+    return void 0;
+  }
+  /**
+   * Set an environment variable override.
+   * @param name - Variable name
+   * @param value - Variable value
+   */
+  set(name, value) {
+    this.envOverrides.set(name, value);
+    this.colorSupportCached = null;
+    this.backgroundCached = null;
+  }
+  getColorSupport() {
+    if (this.colorSupportCached) {
+      return this.colorSupportCached;
+    }
+    const support = {
+      level: 3,
+      hasBasic: true,
+      has256: true,
+      has16m: true
+    };
+    this.colorSupportCached = support;
+    return support;
+  }
+  getTerminalBackground() {
+    if (this.backgroundCached) {
+      return this.backgroundCached;
+    }
+    const override = this.envOverrides.get("TERM_BACKGROUND")?.toLowerCase();
+    if (override === "dark" || override === "light") {
+      this.backgroundCached = override;
+      return override;
+    }
+    if (typeof window !== "undefined" && window.matchMedia) {
+      const darkQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      if (darkQuery.matches) {
+        this.backgroundCached = "dark";
+        return "dark";
+      }
+      const lightQuery = window.matchMedia("(prefers-color-scheme: light)");
+      if (lightQuery.matches) {
+        this.backgroundCached = "light";
+        return "light";
+      }
+    }
+    this.backgroundCached = "unknown";
+    return "unknown";
+  }
+};
+
+// src/browser/filesystem.ts
+var BrowserFileSystemAdapter = class {
+  async readdir(_path, _options) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async stat(_path) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async readFile(_path, _encoding) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async writeFile(_path, _content) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async exists(_path) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async mkdir(_path, _options) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async unlink(_path) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async rmdir(_path, _options) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async rename(_src, _dst) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  async copyFile(_src, _dst) {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  cwd() {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+  homedir() {
+    throw new Error("FileSystem operations are not available in browser environments");
+  }
+};
+
+// src/browser/path.ts
+var BrowserPathAdapter = class {
+  sep = "/";
+  join(...segments) {
+    if (segments.length === 0) {
+      return ".";
+    }
+    const filtered = segments.filter((seg) => seg.length > 0);
+    if (filtered.length === 0) {
+      return ".";
+    }
+    const joined = filtered.join("/");
+    return this.normalizeForResolve(joined);
+  }
+  dirname(path) {
+    if (path.length === 0) {
+      return ".";
+    }
+    const trimmed = path.replace(/\/+$/, "");
+    if (trimmed.length === 0) {
+      return "/";
+    }
+    const lastSlash = trimmed.lastIndexOf("/");
+    if (lastSlash === -1) {
+      return ".";
+    }
+    if (lastSlash === 0) {
+      return "/";
+    }
+    return trimmed.slice(0, lastSlash);
+  }
+  basename(path, ext) {
+    if (path.length === 0) {
+      return "";
+    }
+    const trimmed = path.replace(/\/+$/, "");
+    if (trimmed.length === 0) {
+      return "";
+    }
+    const lastSlash = trimmed.lastIndexOf("/");
+    let base = lastSlash === -1 ? trimmed : trimmed.slice(lastSlash + 1);
+    if (ext && base.endsWith(ext)) {
+      base = base.slice(0, -ext.length);
+    }
+    return base;
+  }
+  extname(path) {
+    if (path.length === 0) {
+      return "";
+    }
+    const base = this.basename(path);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === 0 || lastDot === base.length - 1) {
+      return "";
+    }
+    return base.slice(lastDot);
+  }
+  resolve(...segments) {
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    for (let i = segments.length - 1; i >= 0 && !resolvedAbsolute; i--) {
+      const segment = segments[i];
+      if (!segment || segment.length === 0) {
+        continue;
+      }
+      resolvedPath = resolvedPath.length > 0 ? `${segment}/${resolvedPath}` : segment;
+      resolvedAbsolute = segment[0] === "/";
+    }
+    if (!resolvedAbsolute) {
+      resolvedPath = resolvedPath.length > 0 ? `/${resolvedPath}` : "/";
+    }
+    const normalized = this.normalizeForResolve(resolvedPath);
+    return normalized === "" ? "/" : normalized;
+  }
+  /**
+   * Normalize path specifically for resolve (never preserves trailing slash).
+   * @param path - Path to normalize
+   * @returns Normalized path without trailing slash
+   */
+  normalizeForResolve(path) {
+    if (path.length === 0) {
+      return "/";
+    }
+    const isAbsolute = path[0] === "/";
+    const segments = path.split("/").filter((seg) => seg.length > 0 && seg !== ".");
+    const normalized = [];
+    for (const segment of segments) {
+      if (segment === "..") {
+        if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+          normalized.pop();
+        } else if (!isAbsolute) {
+          normalized.push("..");
+        }
+      } else {
+        normalized.push(segment);
+      }
+    }
+    let result = normalized.join("/");
+    if (isAbsolute) {
+      result = `/${result}`;
+    } else if (result.length === 0) {
+      result = ".";
+    }
+    return result;
+  }
+  isAbsolute(path) {
+    return path.length > 0 && path[0] === "/";
+  }
+  normalize(path) {
+    if (path.length === 0) {
+      return ".";
+    }
+    const isAbsolute = path[0] === "/";
+    const trailingSlash = path[path.length - 1] === "/";
+    const segments = path.split("/").filter((seg) => seg.length > 0 && seg !== ".");
+    const normalized = [];
+    for (const segment of segments) {
+      if (segment === "..") {
+        if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+          normalized.pop();
+        } else if (!isAbsolute) {
+          normalized.push("..");
+        }
+      } else {
+        normalized.push(segment);
+      }
+    }
+    let result = normalized.join("/");
+    if (isAbsolute) {
+      result = `/${result}`;
+    } else if (result.length === 0) {
+      result = ".";
+    }
+    if (trailingSlash && result !== "/" && result.length > 0) {
+      result += "/";
+    }
+    return result;
+  }
+};
+
+// src/browser/signals.ts
+var BrowserSignalAdapter = class {
+  interruptHandlers = /* @__PURE__ */ new Set();
+  terminateHandlers = /* @__PURE__ */ new Set();
+  disposed = false;
+  boundBeforeUnload = null;
+  boundPageHide = null;
+  handleBeforeUnload = (e) => {
+    for (const handler of this.interruptHandlers) {
+      handler();
+    }
+    if (this.interruptHandlers.size > 0) {
+      e.preventDefault();
+    }
+  };
+  handlePageHide = () => {
+    for (const handler of this.terminateHandlers) {
+      handler();
+    }
+  };
+  onInterrupt(handler) {
+    if (this.interruptHandlers.size === 0 && typeof window !== "undefined") {
+      this.boundBeforeUnload = this.handleBeforeUnload;
+      window.addEventListener("beforeunload", this.boundBeforeUnload);
+    }
+    this.interruptHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.interruptHandlers.delete(handler);
+        if (this.interruptHandlers.size === 0 && this.boundBeforeUnload && typeof window !== "undefined") {
+          window.removeEventListener("beforeunload", this.boundBeforeUnload);
+          this.boundBeforeUnload = null;
+        }
+      }
+    };
+  }
+  onTerminate(handler) {
+    if (this.terminateHandlers.size === 0 && typeof window !== "undefined") {
+      this.boundPageHide = this.handlePageHide;
+      window.addEventListener("pagehide", this.boundPageHide);
+    }
+    this.terminateHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.terminateHandlers.delete(handler);
+        if (this.terminateHandlers.size === 0 && this.boundPageHide && typeof window !== "undefined") {
+          window.removeEventListener("pagehide", this.boundPageHide);
+          this.boundPageHide = null;
+        }
+      }
+    };
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (typeof window !== "undefined") {
+      if (this.boundBeforeUnload) {
+        window.removeEventListener("beforeunload", this.boundBeforeUnload);
+      }
+      if (this.boundPageHide) {
+        window.removeEventListener("pagehide", this.boundPageHide);
+      }
+    }
+    this.interruptHandlers.clear();
+    this.terminateHandlers.clear();
+  }
+};
+
+// src/bytes.ts
+var encoder = new TextEncoder();
+new TextDecoder("utf-8");
+function encodeString(text) {
+  return encoder.encode(text);
+}
+
+// src/browser/terminal.ts
+var XtermTerminalAdapter = class {
+  /**
+   * Create a new xterm.js terminal adapter.
+   * @param terminal - xterm.js Terminal instance
+   */
+  constructor(terminal) {
+    this.terminal = terminal;
+  }
+  disposed = false;
+  inputHandlers = /* @__PURE__ */ new Set();
+  resizeHandlers = /* @__PURE__ */ new Set();
+  dataDisposable = null;
+  resizeDisposable = null;
+  onInput(handler) {
+    if (this.inputHandlers.size === 0) {
+      this.dataDisposable = this.terminal.onData((data) => {
+        const bytes = encodeString(data);
+        for (const h of this.inputHandlers) {
+          h(bytes);
+        }
+      });
+    }
+    this.inputHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.inputHandlers.delete(handler);
+        if (this.inputHandlers.size === 0 && this.dataDisposable) {
+          this.dataDisposable.dispose();
+          this.dataDisposable = null;
+        }
+      }
+    };
+  }
+  onResize(handler) {
+    if (this.resizeHandlers.size === 0) {
+      this.resizeDisposable = this.terminal.onResize((size) => {
+        const terminalSize = {
+          columns: size.cols,
+          rows: size.rows
+        };
+        for (const h of this.resizeHandlers) {
+          h(terminalSize);
+        }
+      });
+    }
+    this.resizeHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.resizeHandlers.delete(handler);
+        if (this.resizeHandlers.size === 0 && this.resizeDisposable) {
+          this.resizeDisposable.dispose();
+          this.resizeDisposable = null;
+        }
+      }
+    };
+  }
+  write(data) {
+    if (data.length === 0) {
+      return;
+    }
+    const normalized = data.replace(/(?<!\r)\n/g, "\r\n");
+    this.terminal.write(normalized);
+  }
+  getSize() {
+    return {
+      columns: this.terminal.cols,
+      rows: this.terminal.rows
+    };
+  }
+  enableRawMode() {
+  }
+  disableRawMode() {
+  }
+  isTTY() {
+    return true;
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    if (this.dataDisposable) {
+      this.dataDisposable.dispose();
+      this.dataDisposable = null;
+    }
+    if (this.resizeDisposable) {
+      this.resizeDisposable.dispose();
+      this.resizeDisposable = null;
+    }
+    this.inputHandlers.clear();
+    this.resizeHandlers.clear();
+  }
+};
+
+// src/browser/index.ts
+var BrowserPlatformAdapter = class {
+  terminal;
+  signals;
+  clipboard;
+  environment;
+  filesystem;
+  path;
+  archive;
+  style;
+  disposed = false;
+  disposables = [];
+  /**
+   * Create a new browser platform adapter.
+   * @param options - Configuration options (requires xterm.js Terminal)
+   */
+  constructor(options) {
+    const terminalAdapter = new XtermTerminalAdapter(options.terminal);
+    const signalAdapter = new BrowserSignalAdapter();
+    const clipboardAdapter = new BrowserClipboardAdapter();
+    const environmentAdapter = new BrowserEnvironmentAdapter(options.env);
+    const filesystemAdapter = new BrowserFileSystemAdapter();
+    const pathAdapter = new BrowserPathAdapter();
+    const archiveAdapter = new BrowserArchiveAdapter();
+    const styleAdapter = {
+      style: createAlwaysEnabledStyle(),
+      enabled: true,
+      level: 3
+    };
+    this.terminal = terminalAdapter;
+    this.signals = signalAdapter;
+    this.clipboard = clipboardAdapter;
+    this.environment = environmentAdapter;
+    this.filesystem = filesystemAdapter;
+    this.path = pathAdapter;
+    this.archive = archiveAdapter;
+    this.style = styleAdapter;
+    this.disposables.push(terminalAdapter, signalAdapter);
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    for (const disposable of this.disposables) {
+      disposable.dispose();
+    }
+  }
+};
+function createBrowserPlatform(options) {
+  return new BrowserPlatformAdapter(options);
+}
+
+export { BrowserArchiveAdapter, BrowserClipboardAdapter, BrowserEnvironmentAdapter, BrowserFileSystemAdapter, BrowserPathAdapter, BrowserPlatformAdapter, BrowserSignalAdapter, XtermTerminalAdapter, createBrowserPlatform };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map