get-codex-lost-world 1.0.3

package/README.md

@@ -0,0 +1,105 @@
+# Get Codex Lost World - Codex for Desktop
+
+Bring Codex to **Intel Mac** and **Windows** with a simple CLI workflow for build, download, and packaging. 🚀
+
+[![Build](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/0x0a0d/get-codex-lost-world)
+[![Version](https://img.shields.io/badge/version-1.0.3-blue)](https://github.com/0x0a0d/get-codex-lost-world)
+[![License: ISC](https://img.shields.io/badge/license-ISC-lightgrey)](./LICENSE)
+[![GitHub Stars](https://img.shields.io/github/stars/0x0a0d/get-codex-lost-world?style=social)](https://github.com/0x0a0d/get-codex-lost-world)
+
+![Get Codex Lost World Screenshot](./codex.png)
+
+## Introduction
+
+**Get Codex** is a desktop-focused toolchain that helps users on platforms often left behind by official releases:
+
+- macOS Intel (`.dmg`)
+- Windows x64 / arm64 (`.zip`)
+
+It automates artifact resolution, local build flow, and optional signing steps.
+
+## Features
+
+- ⚡ Build mode for Intel Mac and Windows targets
+- 📦 Cache/download mode for latest release artifacts
+- 🪟 Windows ZIP output (x64, arm64)
+- 🍎 macOS Intel DMG output
+- 🔐 Optional signing flow for macOS artifacts
+- 🧩 Simple CLI flags for platform, arch, format, and workdir
+
+## Tech Stack
+
+- **Runtime:** Node.js
+- **Language:** JavaScript (CommonJS)
+- **Testing:** Node.js built-in test runner (`node --test`)
+- **Packaging Scripts:** Custom Node scripts for macOS/Windows build artifacts
+
+## Installation
+
+### Option 1: Run directly with NPX
+
+```bash
+npx get-codex-lost-world --help
+```
+
+### Option 2: Clone and run locally
+
+```bash
+git clone https://github.com/0x0a0d/get-codex-lost-world.git
+cd get-codex-lost-world
+npm install
+npm test
+```
+
+## Usage
+
+### Show help
+
+```bash
+npx get-codex-lost-world --help
+```
+
+### Build mode (default)
+
+```bash
+npx get-codex-lost-world
+```
+
+```bash
+npx get-codex-lost-world --build --workdir /absolute/path/to/workdir
+```
+
+### Build for Windows arm64 ZIP
+
+```bash
+npx get-codex-lost-world --build --platform windows --arch arm64 --format zip --workdir /absolute/path/to/workdir
+```
+
+### Cache/download mode
+
+```bash
+npx get-codex-lost-world --cache --platform windows --arch x64 --format zip
+```
+
+### Sign mode
+
+```bash
+npx get-codex-lost-world --sign /Applications/Codex.app
+```
+
+## Contributing
+
+Contributions are welcome! 🙌
+
+```bash
+git checkout -b feat/your-feature
+npm test
+git commit -m "feat: add your feature"
+git push origin feat/your-feature
+```
+
+Then open a Pull Request.
+
+## License
+
+Licensed under the **ISC** License.

package/bin/get-codex-lost-world.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+'use strict';
+
+const { runMain, usage } = require('../lib/get-codex-lost-world/main');
+
+function printTargetShortcuts() {
+  const message = [
+    '',
+    'Target shortcuts:',
+    '  --mac-silicon      Build/download for Apple Silicon Mac (default source: original Codex.dmg on macOS arm64 host)',
+    '  --mac-intel        Build/download for Intel Mac (.dmg)',
+    '  --windows-x64      Build/download for Windows x64 (.zip)',
+    '  --windows-arm64    Build/download for Windows arm64 (.zip)',
+    '',
+    'Example:',
+    '  npx get-codex-lost-world --windows-x64 --workdir /tmp/codex',
+  ].join('\n');
+
+  process.stdout.write(`${message}\n`);
+}
+
+function remapShortcutArgs(argv = []) {
+  const targetShortcuts = {
+    '--mac-silicon': ['--platform', 'mac', '--format', 'dmg'],
+    '--mac-intel': ['--platform', 'mac', '--arch', 'x64', '--format', 'dmg'],
+    '--windows-x64': ['--platform', 'windows', '--arch', 'x64', '--format', 'zip'],
+    '--windows-arm64': ['--platform', 'windows', '--arch', 'arm64', '--format', 'zip'],
+  };
+
+  const selectedShortcuts = argv.filter((arg) => Object.prototype.hasOwnProperty.call(targetShortcuts, arg));
+  if (selectedShortcuts.length > 1) {
+    throw new Error(`Target shortcut conflict: ${selectedShortcuts.join(', ')}`);
+  }
+
+  const selected = selectedShortcuts[0];
+  const withoutShortcuts = argv.filter((arg) => !Object.prototype.hasOwnProperty.call(targetShortcuts, arg));
+
+  if (!selected) {
+    return withoutShortcuts;
+  }
+
+  return [...withoutShortcuts, ...targetShortcuts[selected]];
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--target-help')) {
+    process.stdout.write(`${usage()}\n`);
+    printTargetShortcuts();
+    return;
+  }
+
+  const remapped = remapShortcutArgs(argv);
+  await runMain(remapped);
+}
+
+main().catch((error) => {
+  const message = error && error.message ? error.message : String(error);
+  process.stderr.write(`${message}\n\n${usage()}\n`);
+  process.stderr.write('Use --target-help to see target shortcuts.\n');
+  process.exit(1);
+});

package/lib/ci/state.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function shouldBuild({ incomingLastModified, cachedLastModified, force }) {
+  if (force === true) {
+    return true;
+  }
+
+  if (incomingLastModified === cachedLastModified) {
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = {
+  shouldBuild,
+};

package/lib/get-codex-lost-world/args.js

@@ -0,0 +1,124 @@
+'use strict';
+
+function parseArgs(argv = []) {
+  const modeFlags = [];
+  let signPath;
+  let workdir;
+  let platform;
+  let arch;
+  let format;
+  let help = false;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '--help' || arg === '-h') {
+      help = true;
+      continue;
+    }
+
+    if (arg === '--cache' || arg === '-c') {
+      modeFlags.push('cache');
+      continue;
+    }
+
+    if (arg === '--build' || arg === '-b') {
+      modeFlags.push('build');
+      continue;
+    }
+
+    if (arg === '--sign' || arg === '-s') {
+      modeFlags.push('sign');
+      const candidate = argv[i + 1];
+      if (typeof candidate !== 'string' || candidate.trim() === '' || candidate.startsWith('-')) {
+        throw new Error('--sign requires a path');
+      }
+      signPath = candidate;
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--workdir' || arg === '-w') {
+      const candidate = argv[i + 1];
+      if (typeof candidate !== 'string' || candidate.trim() === '' || candidate.startsWith('-')) {
+        throw new Error('--workdir requires a path');
+      }
+      workdir = candidate;
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--platform') {
+      const candidate = argv[i + 1];
+      if (typeof candidate !== 'string' || candidate.trim() === '' || candidate.startsWith('-')) {
+        throw new Error('--platform requires a value');
+      }
+      platform = candidate;
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--arch') {
+      const candidate = argv[i + 1];
+      if (typeof candidate !== 'string' || candidate.trim() === '' || candidate.startsWith('-')) {
+        throw new Error('--arch requires a value');
+      }
+      arch = candidate;
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--format') {
+      const candidate = argv[i + 1];
+      if (typeof candidate !== 'string' || candidate.trim() === '' || candidate.startsWith('-')) {
+        throw new Error('--format requires a value');
+      }
+      format = candidate;
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+
+  const uniqueModes = [...new Set(modeFlags)];
+  if (uniqueModes.length > 1) {
+    throw new Error('mode flag conflict');
+  }
+
+  if (help) {
+    return { mode: 'help' };
+  }
+
+  const mode = uniqueModes[0] || 'build';
+  const result = { mode };
+
+  if (typeof platform === 'string') {
+    result.platform = platform;
+  }
+
+  if (typeof arch === 'string') {
+    result.arch = arch;
+  }
+
+  if (typeof format === 'string') {
+    result.format = format;
+  }
+
+  if (typeof workdir === 'string') {
+    result.workdir = workdir;
+  }
+
+  if (mode === 'sign') {
+    result.signPath = signPath;
+    return result;
+  }
+
+  return result;
+}
+
+module.exports = {
+  parseArgs,
+};

package/lib/get-codex-lost-world/build.js

@@ -0,0 +1,31 @@
+'use strict';
+
+function sanitizeVersion(version) {
+  return String(version || '')
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^0-9A-Za-z._-]/g, '-');
+}
+
+function makeOutputName(version) {
+  return `CodexIntelMac_${sanitizeVersion(version)}.dmg`;
+}
+
+function makeOutputNameForTarget({ version, platform, arch, format }) {
+  const safeVersion = sanitizeVersion(version);
+  const normalizedPlatform = String(platform || '').trim().toLowerCase();
+  const normalizedArch = String(arch || '').trim().toLowerCase();
+  const normalizedFormat = String(format || '').trim().toLowerCase();
+
+  if (normalizedPlatform === 'windows') {
+    return `CodexWindows_${normalizedArch || 'x64'}_${safeVersion}.${normalizedFormat || 'zip'}`;
+  }
+
+  return `CodexIntelMac_${safeVersion}.${normalizedFormat || 'dmg'}`;
+}
+
+module.exports = {
+  sanitizeVersion,
+  makeOutputName,
+  makeOutputNameForTarget,
+};

package/lib/get-codex-lost-world/cache-download.js

@@ -0,0 +1,21 @@
+'use strict';
+
+function resolveCacheDownload(location) {
+  const normalized = typeof location === 'string' ? location.trim() : '';
+
+  if (!normalized) {
+    return {
+      shouldDownload: false,
+      location: '',
+    };
+  }
+
+  return {
+    shouldDownload: true,
+    location: normalized,
+  };
+}
+
+module.exports = {
+  resolveCacheDownload,
+};

package/lib/get-codex-lost-world/local-builder.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function createLocalBuilder(overrides = {}) {
+  const builderEntry = overrides.builderEntry || path.resolve(__dirname, '../../scripts/build-intel-dmg.js');
+  const windowsBuilderEntry = overrides.windowsBuilderEntry || path.resolve(__dirname, '../../scripts/build-windows-zip.js');
+  const fsApi = overrides.fsApi || fs;
+  const spawnSyncFn = overrides.spawnSync || spawnSync;
+  const nodeExecPath = overrides.nodeExecPath || process.execPath;
+
+  return {
+    async run({ location, downloadedPath, outputName, target }) {
+      const normalizedLocation = typeof location === 'string' ? location.trim() : '';
+      const normalizedSource = typeof downloadedPath === 'string' ? downloadedPath.trim() : '';
+      const normalizedOutputName = typeof outputName === 'string' ? outputName.trim() : '';
+
+      if (!normalizedLocation) {
+        throw new Error('build output location is required');
+      }
+      if (!normalizedSource) {
+        throw new Error('source Codex.dmg path is required to run the builder');
+      }
+      if (!normalizedOutputName) {
+        throw new Error('build output filename is required');
+      }
+      const platform = String(target && target.platform ? target.platform : 'mac').trim().toLowerCase();
+      const selectedEntry = platform === 'windows' ? windowsBuilderEntry : builderEntry;
+
+      if (!fsApi.existsSync(selectedEntry)) {
+        throw new Error(`Local builder entrypoint (${path.basename(selectedEntry)}) was not found`);
+      }
+
+      fsApi.mkdirSync(normalizedLocation, { recursive: true });
+      const outputPath = path.join(normalizedLocation, normalizedOutputName);
+      const result = spawnSyncFn(nodeExecPath, [
+        selectedEntry,
+        '--output',
+        outputPath,
+        normalizedSource,
+      ], {
+        stdio: 'inherit',
+      });
+
+      if (result.error) {
+        throw result.error;
+      }
+
+      if (result.status !== 0) {
+        throw new Error('Local builder failed (see logs above for details)');
+      }
+
+      return { outputPath };
+    },
+  };
+}
+
+module.exports = {
+  createLocalBuilder,
+};