@lynx-js/lynxtron 0.0.1 → 0.0.3

package/fuses.js

@@ -0,0 +1,299 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import lynxtronBinaryPath from './lynxtron_bin.js';
+
+const FUSE_SENTINEL = Buffer.from('dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX', 'ascii');
+const FUSE_VERSION = 1;
+const MAX_SUPPORTED_SENTINELS = 2;
+const ENABLED_FUSE_VALUE = '1';
+const DISABLED_FUSE_VALUE = '0';
+
+const FUSE_SCHEMA = [
+  { key: 'runAsNode', defaultValue: true },
+  { key: 'nodeOptions', defaultValue: true },
+  { key: 'nodeCliInspect', defaultValue: true },
+  { key: 'embeddedAsarIntegrityValidation', defaultValue: false },
+  { key: 'onlyLoadAppFromAsar', defaultValue: false },
+];
+
+export const FuseVersion = Object.freeze({
+  V1: FUSE_VERSION,
+});
+
+export const FuseV1Options = Object.freeze({
+  RunAsNode: 'runAsNode',
+  EnableNodeOptionsEnvironmentVariable: 'nodeOptions',
+  EnableNodeCliInspectArguments: 'nodeCliInspect',
+  EnableEmbeddedAsarIntegrityValidation: 'embeddedAsarIntegrityValidation',
+  OnlyLoadAppFromAsar: 'onlyLoadAppFromAsar',
+});
+
+function resolveTarget(target) {
+  if (target == null) {
+    return { binary: lynxtronBinaryPath };
+  }
+
+  if (typeof target === 'string') {
+    const normalizedTarget = target.toLowerCase();
+    if (normalizedTarget.endsWith('.app')) {
+      return { app: target };
+    }
+
+    if (normalizedTarget.endsWith('.exe')) {
+      return { binary: target };
+    }
+
+    return { app: target };
+  }
+
+  if (typeof target !== 'object') {
+    throw new TypeError('target must be a path string or an options object');
+  }
+
+  return target;
+}
+
+async function pathExists(candidatePath) {
+  try {
+    await fs.access(candidatePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveAppBinaryPath(appPath) {
+  const resolvedAppPath = path.resolve(appPath);
+  const lowerCaseAppPath = resolvedAppPath.toLowerCase();
+
+  if (lowerCaseAppPath.endsWith('.app')) {
+    const frameworkBinaryPath = path.join(
+      resolvedAppPath,
+      'Contents',
+      'Frameworks',
+      'Lynxtron Framework.framework',
+      'Lynxtron Framework'
+    );
+    if (await pathExists(frameworkBinaryPath)) {
+      return frameworkBinaryPath;
+    }
+
+    return path.join(resolvedAppPath, 'Contents', 'MacOS', 'Lynxtron');
+  }
+
+  if (lowerCaseAppPath.endsWith('.exe')) {
+    return resolvedAppPath;
+  }
+
+  const macFrameworkBinaryPath = path.join(
+    resolvedAppPath,
+    'Contents',
+    'Frameworks',
+    'Lynxtron Framework.framework',
+    'Lynxtron Framework'
+  );
+  if (await pathExists(macFrameworkBinaryPath)) {
+    return macFrameworkBinaryPath;
+  }
+
+  const macBinaryPath = path.join(
+    resolvedAppPath,
+    'Contents',
+    'MacOS',
+    'Lynxtron'
+  );
+  if (await pathExists(macBinaryPath)) {
+    return macBinaryPath;
+  }
+
+  for (const candidate of ['lynxtron.dll', 'Lynxtron.dll']) {
+    const windowsBinaryPath = path.join(resolvedAppPath, candidate);
+    if (await pathExists(windowsBinaryPath)) {
+      return windowsBinaryPath;
+    }
+  }
+
+  for (const candidate of ['lynxtron.exe', 'Lynxtron.exe']) {
+    const windowsExecutablePath = path.join(resolvedAppPath, candidate);
+    if (await pathExists(windowsExecutablePath)) {
+      return windowsExecutablePath;
+    }
+  }
+
+  throw new Error(
+    `Unable to resolve a Lynxtron binary from app path: ${resolvedAppPath}`
+  );
+}
+
+async function resolveBinaryPath(target) {
+  if (target.binary && target.app) {
+    throw new Error('Provide either "binary" or "app", not both');
+  }
+
+  if (target.binary) {
+    return path.resolve(target.binary);
+  }
+
+  if (target.app) {
+    return resolveAppBinaryPath(target.app);
+  }
+
+  return path.resolve(lynxtronBinaryPath);
+}
+
+function findSentinelOffsets(buffer) {
+  const offsets = [];
+  let searchFrom = 0;
+
+  while (searchFrom < buffer.length) {
+    const offset = buffer.indexOf(FUSE_SENTINEL, searchFrom);
+    if (offset === -1) {
+      break;
+    }
+
+    offsets.push(offset);
+    searchFrom = offset + FUSE_SENTINEL.length;
+  }
+
+  if (offsets.length === 0) {
+    throw new Error('Unable to locate a Lynxtron fuse wire in the target binary');
+  }
+
+  if (offsets.length > MAX_SUPPORTED_SENTINELS) {
+    throw new Error(
+      `Unsupported Lynxtron binary: found ${offsets.length} fuse sentinels`
+    );
+  }
+
+  return offsets;
+}
+
+function getWireRecord(buffer, sentinelOffset) {
+  const versionOffset = sentinelOffset + FUSE_SENTINEL.length;
+  const wireLengthOffset = versionOffset + 1;
+  const wireOffset = wireLengthOffset + 1;
+  const version = buffer[versionOffset];
+  const wireLength = buffer[wireLengthOffset];
+
+  if (version !== FUSE_VERSION) {
+    throw new Error(
+      `Unsupported Lynxtron fuse version ${version}; expected ${FUSE_VERSION}`
+    );
+  }
+
+  if (wireLength !== FUSE_SCHEMA.length) {
+    throw new Error(
+      `Unsupported Lynxtron fuse wire length ${wireLength}; expected ${FUSE_SCHEMA.length}`
+    );
+  }
+
+  return {
+    wireOffset,
+    wireLength,
+    wire: buffer.subarray(wireOffset, wireOffset + wireLength),
+  };
+}
+
+function readWire(buffer) {
+  const records = findSentinelOffsets(buffer).map((offset) =>
+    getWireRecord(buffer, offset)
+  );
+  const referenceWire = Buffer.from(records[0].wire);
+
+  for (const record of records.slice(1)) {
+    if (!Buffer.from(record.wire).equals(referenceWire)) {
+      throw new Error('Fuse wires differ across binary slices');
+    }
+  }
+
+  return { records, wire: referenceWire };
+}
+
+function decodeWire(wire) {
+  const values = { version: FuseVersion.V1 };
+
+  for (const [index, fuse] of FUSE_SCHEMA.entries()) {
+    const rawValue = String.fromCharCode(wire[index]);
+    if (rawValue !== ENABLED_FUSE_VALUE && rawValue !== DISABLED_FUSE_VALUE) {
+      throw new Error(`Unsupported fuse value "${rawValue}" for ${fuse.key}`);
+    }
+
+    values[fuse.key] = rawValue === ENABLED_FUSE_VALUE;
+  }
+
+  return values;
+}
+
+function encodeWire(currentFuses, config) {
+  if (config.version !== FuseVersion.V1) {
+    throw new Error(
+      `Unsupported Lynxtron fuse version ${config.version}; expected ${FuseVersion.V1}`
+    );
+  }
+
+  const nextFuses = { ...currentFuses };
+
+  for (const [key, value] of Object.entries(config)) {
+    if (key === 'version') {
+      continue;
+    }
+
+    if (!Object.values(FuseV1Options).includes(key)) {
+      throw new Error(`Unknown Lynxtron fuse "${key}"`);
+    }
+
+    if (typeof value !== 'boolean') {
+      throw new TypeError(`Fuse "${key}" must be a boolean`);
+    }
+
+    nextFuses[key] = value;
+  }
+
+  const bytes = FUSE_SCHEMA.map(({ key }) =>
+    nextFuses[key] ? ENABLED_FUSE_VALUE : DISABLED_FUSE_VALUE
+  );
+
+  return { nextFuses, wire: Buffer.from(bytes.join(''), 'ascii') };
+}
+
+export async function getCurrentFuses(target) {
+  const binaryPath = await resolveBinaryPath(resolveTarget(target));
+  const buffer = await fs.readFile(binaryPath);
+  const { wire } = readWire(buffer);
+
+  return {
+    binaryPath,
+    ...decodeWire(wire),
+  };
+}
+
+export async function flipFuses(target, config) {
+  if (config == null || typeof config !== 'object') {
+    throw new TypeError('config must be an object');
+  }
+
+  const binaryPath = await resolveBinaryPath(resolveTarget(target));
+  const buffer = await fs.readFile(binaryPath);
+  const { records, wire: currentWire } = readWire(buffer);
+  const currentFuses = decodeWire(currentWire);
+  const { nextFuses, wire } = encodeWire(currentFuses, config);
+
+  for (const record of records) {
+    wire.copy(buffer, record.wireOffset);
+  }
+
+  await fs.writeFile(binaryPath, buffer);
+
+  return {
+    binaryPath,
+    ...nextFuses,
+  };
+}
+
+export function getFuseDefaults() {
+  return FUSE_SCHEMA.reduce(
+    (result, fuse) => ({ ...result, [fuse.key]: fuse.defaultValue }),
+    { version: FuseVersion.V1 }
+  );
+}

package/install.js

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { downloadBinary } from './utils/download.js';
+import { BASE_URL, VERSION, ARCH, PLATFORM, PLATFROM_EXE_PATH } from './utils/env-config.js';
+
+import extractZip from 'extract-zip';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+const LYNXTRON_PATH = path.join(__dirname, "dist", PLATFROM_EXE_PATH);
+
+const hasDownloadLynxtron = () => {
+  return fs.existsSync(LYNXTRON_PATH);
+}
+
+// if lynxtron is already installed, exit.
+if (hasDownloadLynxtron() && !process.env.npm_config_force_download) {
+  console.log("lynxtron is already installed");
+  process.exit(0);
+}
+
+const base_url = BASE_URL;
+
+let downloadUrl = ''
+if (process.env.npm_config_custom_lynxtron_binary_url) {
+  console.log(`using custom lynxtron url: ${process.env.npm_config_custom_lynxtron_binary_url}`);
+  downloadUrl = process.env.npm_config_custom_lynxtron_binary_url;
+} else {
+  if (!base_url) {
+    console.log("lynxtron base url is empty");
+    process.exit(0);
+  }
+  downloadUrl = `${base_url}/v${VERSION}/lynxtron-v${VERSION}-${PLATFORM}-${ARCH}.zip`
+}
+
+
+console.log(`downloading lynxtron from ${downloadUrl}`);
+
+const PACKAGE_DIR_PATH = path.join(__dirname, "dist");
+const PACKAGE_PATH = path.join(PACKAGE_DIR_PATH, `${VERSION}.zip`);
+if (fs.existsSync(PACKAGE_PATH)) {
+  fs.rmSync(path.join(__dirname, "dist"), { recursive: true, force: true });
+}
+fs.mkdirSync(PACKAGE_DIR_PATH, { recursive: true });
+
+await downloadBinary(downloadUrl, PACKAGE_PATH, { timeoutMs: 120000 });
+
+if (!fs.existsSync(PACKAGE_PATH)) {
+  throw new Error("lynxtron download failed");
+}
+
+// Begin extract zip file
+console.log(`Begin extract zip file: ${PACKAGE_PATH}`);
+
+try {
+  // Unzip file by extract-zip module
+  await extractZip(PACKAGE_PATH, { dir: PACKAGE_DIR_PATH });
+  console.log('Unzip completed');
+
+  // Restore macOS framework symlinks (extract-zip expands symlinks into copies)
+  if (PLATFORM === 'darwin' || PLATFORM === 'mas') {
+    try {
+      const fwBase = path.join(PACKAGE_DIR_PATH, 'lynxtron.app', 'Contents', 'Frameworks', 'Lynxtron Framework.framework');
+      const versionsDir = path.join(fwBase, 'Versions');
+      // Find the actual version directory (e.g., "1.0")
+      const versions = fs.readdirSync(versionsDir).filter(v => v !== 'Current');
+      if (versions.length === 1) {
+        const ver = versions[0];
+        const verDir = path.join(versionsDir, ver);
+        const currentLink = path.join(versionsDir, 'Current');
+        const topBinary = path.join(fwBase, 'Lynxtron Framework');
+        const topResources = path.join(fwBase, 'Resources');
+
+        // Remove duplicates and create symlinks
+        if (fs.existsSync(currentLink) && !fs.lstatSync(currentLink).isSymbolicLink()) {
+          fs.rmSync(currentLink, { recursive: true });
+          fs.symlinkSync(ver, currentLink);
+          console.log(`Restored symlink: Versions/Current → ${ver}`);
+        }
+        if (fs.existsSync(topBinary) && !fs.lstatSync(topBinary).isSymbolicLink()) {
+          fs.unlinkSync(topBinary);
+          fs.symlinkSync(path.join('Versions', 'Current', 'Lynxtron Framework'), topBinary);
+          console.log('Restored symlink: Lynxtron Framework → Versions/Current/Lynxtron Framework');
+        }
+        if (fs.existsSync(topResources) && !fs.lstatSync(topResources).isSymbolicLink()) {
+          fs.rmSync(topResources, { recursive: true });
+          fs.symlinkSync(path.join('Versions', 'Current', 'Resources'), topResources);
+          console.log('Restored symlink: Resources → Versions/Current/Resources');
+        }
+      }
+    } catch (symlinkError) {
+      console.warn('Warning: Could not restore framework symlinks:', symlinkError.message);
+      // Non-fatal — app still works with copies, just wastes disk space
+    }
+  }
+
+  // Delete original zip file after unzip to release space
+  try {
+    fs.unlinkSync(PACKAGE_PATH);
+    console.log(`Deleted temporary zip file: ${PACKAGE_PATH}`);
+  } catch (deleteError) {
+    console.warn('Error deleting zip file:', deleteError);
+    // Here we don't throw an error because unzip is already successful, and delete failure does not affect the main function
+  }
+
+  // Verify unzip success
+  if (fs.existsSync(LYNXTRON_PATH)) {
+    console.log('Install success: lynxtron has been successfully downloaded and unzipped');
+    // For macOS app, may need to set executable permission
+    if (PLATFORM === 'darwin' || PLATFORM === 'mas') {
+      try {
+        fs.chmodSync(LYNXTRON_PATH, 0o755);
+        console.log('Set executable permission successfully');
+      } catch (chmodError) {
+        console.warn('Error setting executable permission:', chmodError);
+      }
+    }
+  } else {
+    throw new Error(`Unzip failed: Expected executable file ${LYNXTRON_PATH} not found`);
+  }
+} catch (extractError) {
+  console.error('Error extracting zip file:', extractError);
+  throw new Error('Install failed: Error extracting zip file');
+}

package/lynx.js

@@ -0,0 +1 @@
+export {};

package/lynxtron.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const lynxtron = require('lynxtron');
+
+function resolveRegisterGlobalEnvModule() {
+  if (typeof lynxtron.registerGlobalEnvModule === 'function') {
+    return lynxtron.registerGlobalEnvModule;
+  }
+
+  try {
+    return process._linkedBinding('lynx_extension').registerGlobalEnvModule;
+  } catch {
+    return undefined;
+  }
+}
+
+export const app = lynxtron.app;
+export const LynxWindow = lynxtron.LynxWindow;
+export const Menu = lynxtron.Menu;
+export const MenuItem = lynxtron.MenuItem;
+export const clipboard = lynxtron.clipboard;
+export const shell = lynxtron.shell;
+export const dialog = lynxtron.dialog;
+export const devtool = lynxtron.devtool;
+export const screen = lynxtron.screen;
+export const nativeImage = lynxtron.nativeImage;
+export const protocol = lynxtron.protocol;
+export const Dock = lynxtron.Dock;
+export const CommandLine = lynxtron.CommandLine;
+export const splitPath = lynxtron.splitPath;
+export const Archive = lynxtron.Archive;
+export const registerGlobalEnvModule = resolveRegisterGlobalEnvModule();
+export const getVar = lynxtron.getVar;
+export const hasVar = lynxtron.hasVar;
+export const setVar = lynxtron.setVar;
+export const Tray = lynxtron.Tray;
+export const LynxTemplateData = lynxtron.LynxTemplateData;
+export const LynxUpdateMeta = lynxtron.LynxUpdateMeta;
+export const powerMonitor = lynxtron.powerMonitor;
+
+export const lynx = Object.freeze({});

package/lynxtron_bin.js

@@ -0,0 +1,10 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PLATFROM_EXE_PATH } from './utils/env-config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default path.join(__dirname, "dist", PLATFROM_EXE_PATH);
+
+// export default "dist/" + getPlatformPath();

package/native-paths.cjs

@@ -0,0 +1,38 @@
+const path = require('node:path');
+
+const packageRoot = __dirname;
+const distRoot = path.join(packageRoot, 'dist');
+
+function platformExecutableName() {
+  if (process.platform === 'win32') {
+    return 'lynxtron.exe';
+  }
+
+  if (process.platform === 'darwin') {
+    return path.join('lynxtron.app', 'Contents', 'MacOS', 'lynxtron');
+  }
+
+  throw new Error(
+    `lynxtron builds are not available on platform: ${process.platform}`
+  );
+}
+
+const executablePath = path.join(distRoot, platformExecutableName());
+
+const dllPath =
+  process.platform === 'win32'
+    ? path.join(distRoot, 'lynxtron.dll')
+    : undefined;
+
+const importLibraryPath =
+  process.platform === 'win32'
+    ? path.join(distRoot, 'lynxtron.dll.lib')
+    : undefined;
+
+module.exports = {
+  packageRoot,
+  distRoot,
+  executablePath,
+  dllPath,
+  importLibraryPath,
+};

package/package.json

@@ -1,8 +1,75 @@
 {
   "name": "@lynx-js/lynxtron",
-  "version": "0.0.1",
-  "description": "Lynxtron - Lynx.js desktop runtime",
-  "keywords": ["lynx", "lynxtron", "desktop"],
+  "version": "0.0.3",
+  "description": "lynxtron npm package test",
+  "type": "module",
+  "types": "./apis/lynxtron.d.ts",
+  "main": "lynxtron.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lynx-family/lynxtron.git"
+  },
+  "bin": {
+    "lynxtron": "cli.js",
+    "lynxtron-fuses": "fuses-cli.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "extract-zip": "2.0.1",
+    "node-fetch": "3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3"
+  },
   "author": "",
-  "license": "MIT"
+  "license": "ISC",
+  "keywords": [
+    "lynxtron"
+  ],
+  "files": [
+    "apis",
+    "utils",
+    "cli.js",
+    "fuses.js",
+    "fuses-cli.js",
+    "install.js",
+    "native-paths.cjs",
+    "lynx.js",
+    "lynxtron.js",
+    "lynxtron_bin.js",
+    "web-host",
+    "web-worker.js",
+    "context-bridge.js",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./apis/lynxtron.d.ts",
+      "default": "./lynxtron.js"
+    },
+    "./lynx": {
+      "types": "./apis/lynx.d.ts",
+      "default": "./lynx.js"
+    },
+    "./fuses": "./fuses.js",
+    "./native-paths": "./native-paths.cjs",
+    "./package.json": "./package.json",
+    "./context-bridge": {
+      "types": "./apis/api/context-bridge.d.ts",
+      "browser": "./web-worker.js",
+      "default": "./context-bridge.js"
+    },
+    "./web-host": {
+      "types": "./apis/web-host.d.ts",
+      "default": "./web-host/index.js"
+    },
+    "./web-worker": "./web-worker.js"
+  },
+  "engines": {
+    "node": ">=16"
+  }
 }

package/utils/download.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fetch from 'node-fetch';
+
+/**
+ * Download binary file (arrayBuffer version)
+ * @param {string} url - URL of the file to download
+ * @param {string} outputPath - Output file path
+ * @param {Object} options - Download options
+ * @param {number} options.timeoutMs - Download timeout in milliseconds
+ * @returns {Promise<void>}
+ */
+export async function downloadBinary(url, outputPath, options = {}) {
+  const { timeoutMs = 120000 } = options;
+
+   // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  await fs.promises.mkdir(outputDir, { recursive: true });
+
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, { signal });
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      throw new Error(`Download failed: HTTP ${response.status} ${response.statusText}`);
+    }
+
+     // Get content length if available
+    const contentLength = response.headers.get('content-length');
+    const totalBytes = contentLength ? parseInt(contentLength, 10) : null;
+
+    // Read to memory
+    const ab = await response.arrayBuffer();
+    const buffer = Buffer.from(ab);
+
+    // Write to file (synchronous one-time write)
+    await fs.promises.writeFile(outputPath, buffer);
+
+    // Console output progress information
+    if (totalBytes) {
+      process.stdout.write(`\nDownload completed: ${formatBytes(buffer.length)} / ${formatBytes(totalBytes)}\n`);
+    } else {
+      process.stdout.write(`\nDownload completed: ${formatBytes(buffer.length)}\n`);
+    }
+  } catch (error) {
+    clearTimeout(timeoutId);
+
+    // Clean up partially downloaded file
+    try {
+      await fs.promises.unlink(outputPath);
+    } catch (_) {
+      // Ignore cleanup failure
+    }
+
+    if (error.name === 'AbortError') {
+      throw new Error(`Download timeout: Exceeded ${timeoutMs} milliseconds`);
+    }
+    throw error;
+  }
+}
+
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}