@just-every/manager 0.1.3

package/README.md

@@ -0,0 +1,28 @@
+# @just-every/manager
+
+Installer helper for Every Manager.
+
+## Install
+
+```
+npm install -g @just-every/manager
+```
+
+## Usage
+
+```
+justevery-manager
+```
+
+Use `--download-only` to cache the installer without launching it, and
+`--print-path` to print the cached path.
+
+## Environment
+
+- `JE_AGENT_VERSION` – override the agent version.
+- `JE_AGENT_RELEASE_TAG` – override the GitHub release tag.
+- `JE_AGENT_RELEASE_BASE_URL` – primary base URL (comma-separated).
+- `JE_AGENT_FALLBACK_BASE_URL` – fallback base URLs (comma-separated).
+- `JE_AGENT_ASSET` – override the installer filename.
+- `JE_AGENT_GITHUB_TOKEN` – optional GitHub token for private releases (also supports `GH_TOKEN` / `GITHUB_TOKEN`).
+- `JE_AGENT_SKIP_DOWNLOAD=1` – skip the postinstall download/caching step.

package/bin/justevery-manager.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { ensureInstaller, launchInstaller } from '../lib/installer.js';
+
+const args = process.argv.slice(2);
+const wantsHelp = args.includes('--help') || args.includes('-h');
+const downloadOnly = args.includes('--download-only') || args.includes('--no-open');
+const printPath = args.includes('--print-path');
+
+if (wantsHelp) {
+  console.log(`Every Manager installer helper
+
+Usage:
+  justevery-manager [--download-only] [--print-path]
+
+Options:
+  --download-only   Download the installer but do not launch it.
+  --print-path      Print the installer path after download.
+  -h, --help        Show this help message.
+
+Environment:
+  JE_AGENT_VERSION           Override the agent version.
+  JE_AGENT_RELEASE_TAG       Override the GitHub release tag.
+  JE_AGENT_RELEASE_BASE_URL  Override the primary base URL (comma-separated).
+  JE_AGENT_FALLBACK_BASE_URL Add fallback base URLs (comma-separated).
+  JE_AGENT_ASSET             Override the installer filename.
+  JE_AGENT_GITHUB_TOKEN      Optional GitHub token for private releases.
+`);
+  process.exit(0);
+}
+
+try {
+  const result = await ensureInstaller({ allowDownload: true });
+  if (printPath || downloadOnly) {
+    console.log(result.path);
+  }
+  if (!downloadOnly) {
+    await launchInstaller(result.path);
+  }
+} catch (error) {
+  console.error(`Failed to prepare installer: ${error.message}`);
+  process.exit(1);
+}

package/lib/installer.js

@@ -0,0 +1,592 @@
+import {
+  chmodSync,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+} from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { arch as osArch, homedir, platform as osPlatform } from 'os';
+import { get } from 'https';
+import { spawn } from 'child_process';
+
+const OWNER_REPO = 'just-every/manager';
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const PACKAGE_JSON = resolve(PACKAGE_ROOT, 'package.json');
+const PLACEHOLDER_VERSIONS = new Set(['0.0.0', '0.0.0-dev']);
+
+const REQUEST_TIMEOUT_MS = 30_000;
+
+const GITHUB_HOSTS = new Set([
+  'github.com',
+  'api.github.com',
+  'github-releases.githubusercontent.com',
+  'release-assets.githubusercontent.com',
+  'objects.githubusercontent.com',
+  'raw.githubusercontent.com',
+]);
+
+const ARCH_ALIASES_BY_PLATFORM = {
+  darwin: {
+    arm64: ['aarch64', 'arm64'],
+    x64: ['x64', 'x86_64', 'amd64'],
+  },
+  linux: {
+    arm64: ['aarch64', 'arm64'],
+    x64: ['amd64', 'x86_64', 'x64'],
+  },
+  win32: {
+    arm64: ['arm64', 'aarch64'],
+    x64: ['x64', 'amd64', 'x86_64'],
+  },
+};
+
+const EXTENSIONS = {
+  darwin: ['.dmg'],
+  win32: ['.msi', '.exe'],
+  linux: ['.AppImage', '.appimage', '.deb'],
+};
+
+const FILE_PREFIXES = ['Every.Manager', 'JustEvery.Agent'];
+
+function readPackageVersion() {
+  const raw = readFileSync(PACKAGE_JSON, 'utf8');
+  return JSON.parse(raw).version || '0.0.0';
+}
+
+function isPlaceholderVersion(version) {
+  return PLACEHOLDER_VERSIONS.has(version);
+}
+
+function getCacheDir(version) {
+  const platform = osPlatform();
+  const home = homedir();
+  let base;
+  if (platform === 'win32') {
+    base = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+  } else if (platform === 'darwin') {
+    base = join(home, 'Library', 'Caches');
+  } else {
+    base = process.env.XDG_CACHE_HOME || join(home, '.cache');
+  }
+  const dir = join(base, 'justevery', 'manager', version);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+async function fetchLatestVersion() {
+  const url = `https://api.github.com/repos/${OWNER_REPO}/releases/latest`;
+  const response = await downloadJson(url);
+  const tag = (response.tag_name || '').trim();
+  if (!tag) {
+    throw new Error('Unable to resolve latest release tag from GitHub.');
+  }
+  return tag.replace(/^agent-v/, '').replace(/^v/, '');
+}
+
+function downloadJson(url) {
+  return new Promise((resolve, reject) => {
+    const token = getGitHubToken();
+    const headers = {
+      'User-Agent': 'justevery-manager-wrapper',
+      Accept: 'application/vnd.github+json',
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    };
+    const req = get(
+      url,
+      {
+        headers,
+      },
+      (res) => {
+        const status = res.statusCode || 0;
+        if (status < 200 || status >= 300) {
+          reject(Object.assign(new Error(`GitHub API request failed (${status}) for ${url}`), { status }));
+          res.resume();
+          return;
+        }
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          body += chunk;
+        });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      },
+    );
+    req.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      req.destroy(new Error(`Request timeout (${REQUEST_TIMEOUT_MS}ms) for ${url}`));
+    });
+    req.on('error', reject);
+  });
+}
+
+function normalizeBaseUrls(value) {
+  if (!value) return [];
+  return value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => entry.replace(/\/$/, ''));
+}
+
+function buildBaseUrls(version) {
+  const overrides = normalizeBaseUrls(process.env.JE_AGENT_RELEASE_BASE_URL || process.env.JE_AGENT_BASE_URL);
+  const tag = process.env.JE_AGENT_RELEASE_TAG || `agent-v${version}`;
+  const githubBase = `https://github.com/${OWNER_REPO}/releases/download/${tag}`;
+  const fallback = normalizeBaseUrls(process.env.JE_AGENT_FALLBACK_BASE_URL);
+  const marketingBase = `https://manager.justevery.com/marketing/agent-release/${tag}`;
+  const bases = overrides.length ? overrides : [githubBase];
+  for (const extra of [...fallback, marketingBase]) {
+    if (!bases.includes(extra)) bases.push(extra);
+  }
+  return bases;
+}
+
+function buildCandidateFiles(version) {
+  const platform = osPlatform();
+  const nodeArch = osArch();
+  const archKey = resolveArchKey(nodeArch);
+  const archCandidates = (ARCH_ALIASES_BY_PLATFORM[platform] || {})[archKey] || [nodeArch];
+  const extensions = EXTENSIONS[platform] || [];
+  const extra = (process.env.JE_AGENT_ASSET || '').trim();
+  if (extra) {
+    return [extra];
+  }
+  const files = new Set();
+  if (platform === 'win32') {
+    for (const prefix of FILE_PREFIXES) {
+      for (const arch of archCandidates) {
+        files.add(`${prefix}_${version}_${arch}_en-US.msi`);
+        files.add(`${prefix}_${version}_${arch}.msi`);
+        files.add(`${prefix}_${version}_${arch}-setup.exe`);
+        files.add(`${prefix}_${version}_${arch}.exe`);
+      }
+    }
+    return Array.from(files);
+  }
+  for (const ext of extensions) {
+    for (const prefix of FILE_PREFIXES) {
+      for (const arch of archCandidates) {
+        files.add(`${prefix}_${version}_${arch}${ext}`);
+      }
+    }
+  }
+  return Array.from(files);
+}
+
+function fileLooksValid(path) {
+  try {
+    const stat = statSync(path);
+    return stat.isFile() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function downloadWithRedirects(url, dest, redirects = 5) {
+  return new Promise((resolve, reject) => {
+    const req = get(url, { headers: { 'User-Agent': 'justevery-manager-wrapper' } }, (res) => {
+      const status = res.statusCode || 0;
+      if ([301, 302, 303, 307, 308].includes(status) && res.headers.location) {
+        if (redirects <= 0) {
+          reject(new Error(`Too many redirects for ${url}`));
+          res.resume();
+          return;
+        }
+        const next = res.headers.location.startsWith('http')
+          ? res.headers.location
+          : new URL(res.headers.location, url).toString();
+        res.resume();
+        downloadWithRedirects(next, dest, redirects - 1).then(resolve).catch(reject);
+        return;
+      }
+
+      if (status !== 200) {
+        reject(Object.assign(new Error(`Download failed (${status})`), { status }));
+        res.resume();
+        return;
+      }
+
+      const contentType = String(res.headers['content-type'] || '').toLowerCase();
+      if (contentType.includes('text/html') || contentType.includes('application/xhtml')) {
+        reject(
+          Object.assign(new Error('Download returned HTML instead of an installer.'), {
+            status: 200,
+            code: 'unexpected_html',
+            url,
+          }),
+        );
+        res.resume();
+        return;
+      }
+
+      const expectedLength = Number(res.headers['content-length'] || 0);
+      const tmp = `${dest}.tmp-${Math.random().toString(36).slice(2, 8)}`;
+      const file = createWriteStream(tmp);
+
+      res.pipe(file);
+
+      const cleanup = () => {
+        try {
+          unlinkSync(tmp);
+        } catch {}
+      };
+
+      res.on('aborted', () => {
+        cleanup();
+        reject(new Error('Download was aborted.'));
+      });
+      res.on('error', (err) => {
+        cleanup();
+        reject(err);
+      });
+
+      file.on('error', (err) => {
+        cleanup();
+        reject(err);
+      });
+
+      file.on('finish', () => {
+        file.close((closeErr) => {
+          if (closeErr) {
+            cleanup();
+            reject(closeErr);
+            return;
+          }
+
+          if (expectedLength > 0) {
+            try {
+              const stat = statSync(tmp);
+              if (stat.size !== expectedLength) {
+                cleanup();
+                reject(new Error(`Download incomplete (${stat.size}/${expectedLength} bytes).`));
+                return;
+              }
+            } catch (err) {
+              cleanup();
+              reject(err);
+              return;
+            }
+          }
+
+          resolve(tmp);
+        });
+      });
+    });
+
+    req.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      req.destroy(new Error(`Request timeout (${REQUEST_TIMEOUT_MS}ms) for ${url}`));
+    });
+    req.on('error', reject);
+  });
+}
+
+async function downloadInstaller(baseUrl, fileName, dest) {
+  const url = `${baseUrl}/${fileName}`;
+  mkdirSync(dirname(dest), { recursive: true });
+  const tmp = await downloadWithRedirects(url, dest);
+  if (!fileLooksValid(tmp)) {
+    throw new Error('Downloaded file is empty.');
+  }
+  if (existsSync(dest)) {
+    try {
+      unlinkSync(dest);
+    } catch {}
+  }
+  renameSync(tmp, dest);
+  return dest;
+}
+
+function ensureExecutable(path) {
+  if (osPlatform() !== 'linux') return;
+  if (!path.endsWith('.AppImage')) return;
+  try {
+    chmodSync(path, 0o755);
+  } catch {}
+}
+
+export async function resolveAgentVersion() {
+  if (process.env.JE_AGENT_VERSION) {
+    return process.env.JE_AGENT_VERSION.trim();
+  }
+  const version = readPackageVersion();
+  if (!isPlaceholderVersion(version)) {
+    return version;
+  }
+  return await fetchLatestVersion();
+}
+
+export async function ensureInstaller({ allowDownload = true } = {}) {
+  const version = await resolveAgentVersion();
+  const baseUrls = buildBaseUrls(version);
+  const candidates = buildCandidateFiles(version);
+  const cacheDir = getCacheDir(version);
+  let sawGitHubHtml = false;
+
+  for (const candidate of candidates) {
+    const dest = join(cacheDir, candidate);
+    if (fileLooksValid(dest)) {
+      ensureExecutable(dest);
+      return { path: dest, version, fileName: candidate, cached: true };
+    }
+    if (!allowDownload) continue;
+    for (const baseUrl of baseUrls) {
+      try {
+        await downloadInstallerWithAuth(baseUrl, version, candidate, dest);
+        ensureExecutable(dest);
+        return { path: dest, version, fileName: candidate, cached: false };
+      } catch (err) {
+        if (err && err.code === 'unexpected_html' && isGitHubDownloadBase(baseUrl)) {
+          sawGitHubHtml = true;
+        }
+        if (err && err.status && err.status === 404) {
+          continue;
+        }
+      }
+    }
+  }
+
+  const authHint = sawGitHubHtml
+    ? ' If the release is private, set JE_AGENT_GITHUB_TOKEN (or GH_TOKEN) so the wrapper can download release assets via the GitHub API.'
+    : '';
+
+  throw new Error(`Unable to locate a compatible installer for ${osPlatform()} ${osArch()}.${authHint}`);
+}
+
+export function launchInstaller(installerPath) {
+  const platform = osPlatform();
+  if (platform === 'darwin') {
+    return runCommand('open', [installerPath]);
+  }
+  if (platform === 'win32') {
+    return runCommand('cmd', ['/c', 'start', '""', installerPath]);
+  }
+  if (installerPath.endsWith('.AppImage')) {
+    return runCommand(installerPath, []);
+  }
+  return runCommand('xdg-open', [installerPath]);
+}
+
+function runCommand(command, args) {
+  const child = spawn(command, args, { stdio: 'inherit', shell: false });
+  return new Promise((resolve, reject) => {
+    child.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with ${code}`));
+    });
+    child.on('error', reject);
+  });
+}
+
+function getGitHubToken() {
+  return (
+    process.env.JE_AGENT_GITHUB_TOKEN ||
+    process.env.GH_TOKEN ||
+    process.env.GITHUB_TOKEN ||
+    process.env.GITHUB_PAT ||
+    ''
+  ).trim();
+}
+
+function resolveArchKey(nodeArch) {
+  if (nodeArch === 'x64' || nodeArch === 'arm64') return nodeArch;
+  throw new Error(
+    `Unsupported architecture ${nodeArch}. Supported architectures are x64 and arm64. ` +
+      'Set JE_AGENT_ASSET to override the installer file name if you have a custom build.',
+  );
+}
+
+function isGitHubDownloadBase(baseUrl) {
+  return baseUrl.startsWith(`https://github.com/${OWNER_REPO}/releases/download/`);
+}
+
+function releaseTagFromGitHubBase(baseUrl) {
+  try {
+    const parsed = new URL(baseUrl);
+    const parts = parsed.pathname.split('/').filter(Boolean);
+    const downloadIndex = parts.findIndex((part) => part === 'download');
+    if (downloadIndex === -1) return '';
+    return parts[downloadIndex + 1] || '';
+  } catch {
+    return '';
+  }
+}
+
+async function downloadInstallerWithAuth(baseUrl, version, fileName, dest) {
+  const token = getGitHubToken();
+
+  if (token && isGitHubDownloadBase(baseUrl)) {
+    const tag = releaseTagFromGitHubBase(baseUrl) || `agent-v${version}`;
+    try {
+      return await downloadGitHubReleaseAsset({ token, tag, fileName, dest });
+    } catch (err) {
+      if (err && err.status === 404) {
+        // Asset not present in the release; fall back to direct URL attempts.
+      } else {
+        // If the API download fails for non-404 reasons, still try other base URLs.
+      }
+    }
+  }
+
+  return await downloadInstaller(baseUrl, fileName, dest);
+}
+
+async function downloadGitHubReleaseAsset({ token, tag, fileName, dest }) {
+  const release = await downloadJson(`https://api.github.com/repos/${OWNER_REPO}/releases/tags/${tag}`);
+  const assets = Array.isArray(release.assets) ? release.assets : [];
+  const asset = assets.find((entry) => entry && entry.name === fileName);
+  if (!asset) {
+    throw Object.assign(new Error(`Release asset not found: ${fileName}`), { status: 404 });
+  }
+  if (!asset.url) {
+    throw new Error(`Release asset is missing API url: ${fileName}`);
+  }
+
+  const tmp = await downloadWithRedirectsAuthenticated(asset.url, dest, token);
+  if (!fileLooksValid(tmp)) {
+    throw new Error('Downloaded file is empty.');
+  }
+  if (existsSync(dest)) {
+    try {
+      unlinkSync(dest);
+    } catch {}
+  }
+  renameSync(tmp, dest);
+  return dest;
+}
+
+function downloadWithRedirectsAuthenticated(url, dest, token, redirects = 5) {
+  return new Promise((resolve, reject) => {
+    const headers = {
+      'User-Agent': 'justevery-manager-wrapper',
+      Accept: 'application/octet-stream',
+      Authorization: `Bearer ${token}`,
+    };
+
+    const req = get(url, { headers }, (res) => {
+      const status = res.statusCode || 0;
+
+      if ([301, 302, 303, 307, 308].includes(status) && res.headers.location) {
+        if (redirects <= 0) {
+          reject(new Error(`Too many redirects for ${url}`));
+          res.resume();
+          return;
+        }
+
+        const next = res.headers.location.startsWith('http')
+          ? res.headers.location
+          : new URL(res.headers.location, url).toString();
+
+        const nextHost = safeHost(next);
+        const currentHost = safeHost(url);
+
+        // Never forward Authorization headers to non-GitHub hosts.
+        if (nextHost && currentHost && nextHost !== currentHost && !GITHUB_HOSTS.has(nextHost)) {
+          res.resume();
+          downloadWithRedirects(next, dest, redirects - 1).then(resolve).catch(reject);
+          return;
+        }
+
+        res.resume();
+        downloadWithRedirectsAuthenticated(next, dest, token, redirects - 1).then(resolve).catch(reject);
+        return;
+      }
+
+      if (status !== 200) {
+        reject(Object.assign(new Error(`Download failed (${status})`), { status }));
+        res.resume();
+        return;
+      }
+
+      const contentType = String(res.headers['content-type'] || '').toLowerCase();
+      if (contentType.includes('text/html') || contentType.includes('application/xhtml')) {
+        reject(
+          Object.assign(new Error('Download returned HTML instead of an installer.'), {
+            status: 200,
+            code: 'unexpected_html',
+            url,
+          }),
+        );
+        res.resume();
+        return;
+      }
+
+      const expectedLength = Number(res.headers['content-length'] || 0);
+      const tmp = `${dest}.tmp-${Math.random().toString(36).slice(2, 8)}`;
+      const file = createWriteStream(tmp);
+
+      res.pipe(file);
+
+      const cleanup = () => {
+        try {
+          unlinkSync(tmp);
+        } catch {}
+      };
+
+      res.on('aborted', () => {
+        cleanup();
+        reject(new Error('Download was aborted.'));
+      });
+      res.on('error', (err) => {
+        cleanup();
+        reject(err);
+      });
+
+      file.on('error', (err) => {
+        cleanup();
+        reject(err);
+      });
+
+      file.on('finish', () => {
+        file.close((closeErr) => {
+          if (closeErr) {
+            cleanup();
+            reject(closeErr);
+            return;
+          }
+
+          if (expectedLength > 0) {
+            try {
+              const stat = statSync(tmp);
+              if (stat.size !== expectedLength) {
+                cleanup();
+                reject(new Error(`Download incomplete (${stat.size}/${expectedLength} bytes).`));
+                return;
+              }
+            } catch (err) {
+              cleanup();
+              reject(err);
+              return;
+            }
+          }
+
+          resolve(tmp);
+        });
+      });
+    });
+
+    req.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      req.destroy(new Error(`Request timeout (${REQUEST_TIMEOUT_MS}ms) for ${url}`));
+    });
+    req.on('error', reject);
+  });
+}
+
+function safeHost(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return '';
+  }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@just-every/manager",
+  "version": "0.1.3",
+  "description": "Installer wrapper for Every Manager",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "justevery-manager": "bin/justevery-manager.js",
+    "justevery-agent": "bin/justevery-manager.js"
+  },
+  "files": [
+    "bin/justevery-manager.js",
+    "lib/installer.js",
+    "postinstall.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/postinstall.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { ensureInstaller } from './lib/installer.js';
+
+const skip = process.env.JE_AGENT_SKIP_DOWNLOAD === '1';
+
+if (skip) {
+  process.exit(0);
+}
+
+try {
+  const result = await ensureInstaller({ allowDownload: true });
+  console.log(`Every Manager installer cached at ${result.path}`);
+} catch (error) {
+  console.warn(`Every Manager installer download skipped: ${error.message}`);
+}