get-codex-lost-world 1.0.5 → 1.0.7

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

@@ -9,11 +9,9 @@ function printTargetShortcuts() {
     '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',
+    '  npx get-codex-lost-world -w ~/Downloads',
   ].join('\n');
 
   process.stdout.write(`${message}\n`);
@@ -23,8 +21,6 @@ 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));
@@ -59,4 +55,4 @@ main().catch((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/get-codex-lost-world/build.js

@@ -11,16 +11,10 @@ function makeOutputName(version) {
   return `CodexIntelMac_${sanitizeVersion(version)}.dmg`;
 }
 
-function makeOutputNameForTarget({ version, platform, arch, format }) {
+function makeOutputNameForTarget({ version, 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'}`;
 }
 

package/lib/get-codex-lost-world/github-release-html.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const https = require('node:https');
+
+const DEFAULT_HEADERS = {
+  'User-Agent': 'get-codex-lost-world',
+  Accept: 'text/html,application/xhtml+xml',
+  // Avoid having to handle gzip/brotli in Node core without extra deps.
+  'Accept-Encoding': 'identity',
+};
+
+function fetchTextOnce(url, { headers = {} } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { headers: { ...DEFAULT_HEADERS, ...headers } }, (res) => {
+      const statusCode = res.statusCode || 0;
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        resolve({
+          statusCode,
+          headers: res.headers || {},
+          body: Buffer.concat(chunks).toString('utf8'),
+        });
+      });
+      res.on('error', reject);
+    });
+
+    req.on('error', reject);
+  });
+}
+
+async function fetchTextWithRedirects(url, { headers = {}, maxRedirects = 10 } = {}) {
+  let currentUrl = url;
+
+  for (let i = 0; i <= maxRedirects; i += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    const res = await fetchTextOnce(currentUrl, { headers });
+
+    const status = res.statusCode;
+    const location = res.headers && res.headers.location;
+    if ([301, 302, 303, 307, 308].includes(status) && location) {
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+
+    if (status < 200 || status >= 300) {
+      throw new Error(`Request failed (${status}): ${currentUrl}`);
+    }
+
+    return {
+      finalUrl: currentUrl,
+      statusCode: status,
+      body: res.body,
+    };
+  }
+
+  throw new Error(`Too many redirects: ${url}`);
+}
+
+function extractReleaseTagFromUrl(finalUrl) {
+  const input = String(finalUrl || '').trim();
+  if (!input) {
+    throw new Error('finalUrl is required to extract release tag');
+  }
+
+  const match = input.match(/\/releases\/tag\/([^/?#]+)/);
+  if (!match || !match[1]) {
+    throw new Error(`Unable to extract release tag from url: ${finalUrl}`);
+  }
+
+  return decodeURIComponent(match[1]);
+}
+
+function parseExpandedAssetsHtml(html, { repo } = {}) {
+  const body = String(html || '');
+  const assets = [];
+  const baseUrl = 'https://github.com/';
+
+  const liRegex = /<li[^>]*class="Box-row[^"]*"[^>]*>([\s\S]*?)<\/li>/g;
+  let liMatch;
+  while ((liMatch = liRegex.exec(body))) {
+    const block = liMatch[1];
+
+    const linkMatch = block.match(/<a[^>]*href="([^"]+)"[^>]*class="Truncate"[\s\S]*?<span[^>]*class="Truncate-text text-bold"[^>]*>([^<]+)<\/span>/i);
+    if (!linkMatch) {
+      continue;
+    }
+
+    const href = linkMatch[1];
+    const name = String(linkMatch[2] || '').trim();
+    if (!name) {
+      continue;
+    }
+
+    const timeMatch = block.match(/<relative-time[^>]*datetime="([^"]+)"/i);
+    const updated_at = timeMatch ? String(timeMatch[1] || '').trim() : '';
+
+    const shaMatch = block.match(/sha256:([0-9a-f]{64})/i);
+    const sha256 = shaMatch ? `sha256:${shaMatch[1].toLowerCase()}` : '';
+
+    const sizeMatch = block.match(/>\s*([0-9.]+\s*(?:B|KB|MB|GB|TB))\s*<\/span>\s*<span[^>]*>\s*<relative-time/i);
+    const size = sizeMatch ? String(sizeMatch[1] || '').trim() : '';
+
+    const browser_download_url = new URL(href, baseUrl).toString();
+
+    assets.push({
+      name,
+      browser_download_url,
+      updated_at,
+      size,
+      sha256,
+      // For compatibility with GitHub API shape
+      url: browser_download_url,
+    });
+  }
+
+  // If we didn't get any Box-row matches (GitHub markup change), fail loudly.
+  if (assets.length === 0) {
+    const repoLabel = repo ? ` for ${repo}` : '';
+    throw new Error(`No assets parsed from expanded_assets HTML${repoLabel}`);
+  }
+
+  return assets;
+}
+
+function maxIsoDatetime(values) {
+  let best = '';
+  let bestTime = 0;
+
+  for (const value of values) {
+    const time = Date.parse(value);
+    if (!Number.isFinite(time)) {
+      continue;
+    }
+    if (time > bestTime) {
+      bestTime = time;
+      best = value;
+    }
+  }
+
+  return best;
+}
+
+async function getLatestReleaseFromGithubHtml({ repo } = {}) {
+  const normalizedRepo = String(repo || '').trim();
+  if (!normalizedRepo) {
+    throw new Error('repo is required');
+  }
+
+  const latestUrl = `https://github.com/${normalizedRepo}/releases/latest`;
+  const latestRes = await fetchTextWithRedirects(latestUrl);
+  const tag = extractReleaseTagFromUrl(latestRes.finalUrl);
+
+  const assetsUrl = `https://github.com/${normalizedRepo}/releases/expanded_assets/${encodeURIComponent(tag)}`;
+  const assetsRes = await fetchTextWithRedirects(assetsUrl);
+  const assets = parseExpandedAssetsHtml(assetsRes.body, { repo: normalizedRepo });
+
+  const published_at = maxIsoDatetime(assets.map((asset) => asset.updated_at));
+
+  return {
+    tag_name: tag,
+    published_at,
+    assets,
+  };
+}
+
+module.exports = {
+  fetchTextWithRedirects,
+  extractReleaseTagFromUrl,
+  parseExpandedAssetsHtml,
+  getLatestReleaseFromGithubHtml,
+};

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

@@ -8,6 +8,7 @@ const { spawnSync } = require('node:child_process');
 const readline = require('node:readline');
 const { parseArgs } = require('./args');
 const { summarizeRelease, pickLatestAssetForTarget } = require('./release');
+const { getLatestReleaseFromGithubHtml } = require('./github-release-html');
 const { createLocalBuilder } = require('./local-builder');
 const { normalizeTarget } = require('./targets');
 
@@ -226,7 +227,22 @@ function getDefaultDeps(overrides = {}) {
           headers.Authorization = `Bearer ${githubToken}`;
         }
 
-        return getJson(url, headers);
+        try {
+          return await getJson(url, headers);
+        } catch (error) {
+          try {
+            return await getLatestReleaseFromGithubHtml({ repo: githubRepo });
+          } catch (fallbackError) {
+            const apiMessage = error instanceof Error ? error.message : String(error);
+            const htmlMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+            const combined = new Error(
+              `GitHub release lookup failed via API and HTML fallback. API error: ${apiMessage}. HTML error: ${htmlMessage}`
+            );
+            combined.apiError = error;
+            combined.htmlError = fallbackError;
+            throw combined;
+          }
+        }
       },
     },
     io,
@@ -287,7 +303,8 @@ function getDefaultDownloadsLocation(env) {
 }
 
 function getDefaultBuildLocation(env) {
-  return getDefaultDownloadsLocation(env);
+  const pwdFromEnv = typeof env?.PWD === 'string' ? env.PWD.trim() : '';
+  return pwdFromEnv || process.cwd();
 }
 
 function usage() {
@@ -300,9 +317,9 @@ function usage() {
     '  -c, --cache          Show latest release info and optionally download/sign it',
     '  -s, --sign <path>    Ad-hoc sign a local app/dmg path',
     '  -w, --workdir <path> Build working directory (download source + write Intel DMG)',
-    '      --platform <p>   Target platform: mac | windows',
-    '      --arch <a>       Target arch: x64 | arm64 (windows)',
-    '      --format <f>     Target format: dmg | zip',
+    '      --platform <p>   Target platform: mac',
+    '      --arch <a>       Target arch: x64',
+    '      --format <f>     Target format: dmg',
     '',
     'Other options:',
     '  -h, --help           Show this help message',
@@ -315,32 +332,16 @@ function usage() {
   ].join('\n');
 }
 
-function mapHostArchToTargetArch(hostArch) {
-  const normalized = String(hostArch || '').trim().toLowerCase();
-  if (normalized === 'arm64') {
-    return 'arm64';
-  }
-
-  return 'x64';
-}
-
-function resolveDefaultTargetInput(parsed, env) {
-  const runtimePlatform = String((env && env.RUNTIME_PLATFORM) || process.platform || '').trim().toLowerCase();
-  const runtimeArch = String((env && env.RUNTIME_ARCH) || process.arch || '').trim().toLowerCase();
-
-  const inferredPlatform = runtimePlatform === 'win32' ? 'windows' : 'mac';
+function resolveDefaultTargetInput(parsed, _env) {
   const selectedPlatform = typeof parsed.platform === 'string' && parsed.platform.trim() !== ''
     ? parsed.platform
-    : inferredPlatform;
-
-  const normalizedPlatform = String(selectedPlatform).trim().toLowerCase();
-  const inferredArch = normalizedPlatform === 'windows' ? mapHostArchToTargetArch(runtimeArch) : 'x64';
+    : 'mac';
   const selectedArch = typeof parsed.arch === 'string' && parsed.arch.trim() !== ''
     ? parsed.arch
-    : inferredArch;
+    : 'x64';
   const selectedFormat = typeof parsed.format === 'string' && parsed.format.trim() !== ''
     ? parsed.format
-    : (normalizedPlatform === 'windows' ? 'zip' : 'dmg');
+    : 'dmg';
 
   return {
     platform: selectedPlatform,
@@ -389,15 +390,6 @@ async function runCacheMode(parsed, deps) {
     : (downloadResult && downloadResult.path) || fallbackPath;
   deps.io.log(`Download done: ${downloadedPath}`);
 
-  if (target.platform === 'windows') {
-    return {
-      mode: 'cache',
-      downloaded: true,
-      signed: false,
-      path: downloadedPath,
-      target,
-    };
-  }
 
   const signAnswer = await deps.io.prompt('Sign downloaded file? (Y/n)', 'Y');
   let signed = false;

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

@@ -18,34 +18,20 @@ function pickLatestAssetForTarget(release, target = {}) {
   const assets = Array.isArray(release?.assets) ? release.assets : [];
   const platform = String(target.platform || 'mac').trim().toLowerCase();
   const arch = String(target.arch || 'x64').trim().toLowerCase();
-  const format = String(target.format || (platform === 'windows' ? 'zip' : 'dmg')).trim().toLowerCase();
-
-  const candidates = assets.filter((asset) => typeof asset?.name === 'string' && asset.name.toLowerCase().endsWith(`.${format}`));
+  const format = String(target.format || 'dmg').trim().toLowerCase();
+
+  const candidates = assets
+    .filter((asset) => typeof asset?.name === 'string' && asset.name.toLowerCase().endsWith(`.${format}`))
+    .sort((a, b) => {
+      const aTime = Number.isFinite(Date.parse(a.updated_at)) ? Date.parse(a.updated_at) : 0;
+      const bTime = Number.isFinite(Date.parse(b.updated_at)) ? Date.parse(b.updated_at) : 0;
+      return bTime - aTime;
+    });
   if (candidates.length === 0) {
     throw new Error(`No .${format} asset found in release assets`);
   }
 
-  if (platform === 'windows') {
-    const strictMatch = candidates.find((asset) => {
-      const name = asset.name.toLowerCase();
-      return name.includes('windows') && name.includes(arch);
-    });
-
-    if (strictMatch) {
-      ensureAssetUrl(strictMatch, `.${format}`);
-      return strictMatch;
-    }
-
-    const archMatch = candidates.find((asset) => asset.name.toLowerCase().includes(arch));
-    if (archMatch) {
-      ensureAssetUrl(archMatch, `.${format}`);
-      return archMatch;
-    }
-
-    throw new Error(`No .${format} asset found for windows/${arch}`);
-  }
-
-  const preferred = candidates.find((asset) => /^CodexIntelMac_.*\.dmg$/i.test(asset.name));
+  const preferred = candidates.find((asset) => /^(?:CodexIntelMac_|CodexMacIntel_).+\.dmg$/i.test(asset.name));
   const selected = preferred || candidates[0];
   ensureAssetUrl(selected, `.${format}`);
   return selected;

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

@@ -1,15 +1,13 @@
 'use strict';
 
-const SUPPORTED_PLATFORMS = ['mac', 'windows'];
+const SUPPORTED_PLATFORMS = ['mac'];
 
 const SUPPORTED_ARCHES_BY_PLATFORM = {
   mac: ['x64'],
-  windows: ['x64', 'arm64'],
 };
 
 const SUPPORTED_FORMATS_BY_PLATFORM = {
   mac: ['dmg'],
-  windows: ['zip'],
 };
 
 function normalizeValue(value) {
@@ -19,7 +17,7 @@ function normalizeValue(value) {
 function normalizeTarget(input = {}) {
   const platform = normalizeValue(input.platform) || 'mac';
   const arch = normalizeValue(input.arch) || 'x64';
-  const format = normalizeValue(input.format) || (platform === 'windows' ? 'zip' : 'dmg');
+  const format = normalizeValue(input.format) || 'dmg';
   const target = { platform, arch, format };
   validateTarget(target);
   return target;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "get-codex-lost-world",
-  "version": "1.0.5",
-  "description": "CLI to download/build Codex Mac Intel DMG and Windows ZIP artifacts from upstream Codex.dmg.",
+  "version": "1.0.7",
+  "description": "CLI to download/build Codex Mac Intel DMG artifacts from upstream Codex.dmg.",
   "main": "lib/get-codex-lost-world/main.js",
   "bin": {
     "get-codex-lost-world": "bin/get-codex-lost-world.js"
@@ -17,9 +17,7 @@
     "codex",
     "intel",
     "build",
-    "mac",
-    "windows",
-    "zip"
+    "mac"
   ],
   "author": "0x0a0d",
   "license": "ISC",