@general-liquidity/gordon-cli 0.8.25 → 0.9.0-friends.7

package/README.md

@@ -1,126 +1,126 @@
-<h1 align="center">Gordon CLI</h1>
-
-<p align="center">
-  The Frontier Trading Agent
-</p>
-
-<p align="center">
-  <a href="https://www.npmjs.com/package/@general-liquidity/gordon-cli">npm</a> •
-  <a href="https://gordoncli.com">Website</a> •
-  <a href="https://docs.gordon.trade">Docs</a> •
-  <a href="https://github.com/general-liquidity/gordon-cli-dist/releases">Downloads</a>
-</p>
-
-## Install
-
-`npm`:
-
-```bash
-npm install -g @general-liquidity/gordon-cli
-```
-
-If global npm install fails with `EACCES` / permission errors on Linux or macOS, use the user-local npm path instead:
-
-```bash
-npx @general-liquidity/gordon-cli@latest install
-```
-
-That installs Gordon into a user-writable bin directory without `sudo`.
-
-`bun`:
-
-```bash
-bun add -g @general-liquidity/gordon-cli
-```
-
-`Homebrew`:
-
-```bash
-brew tap general-liquidity/gordon-cli-dist https://github.com/general-liquidity/gordon-cli-dist
-brew install general-liquidity/gordon-cli-dist/gordon
-```
-
-`Scoop`:
-
-```powershell
-scoop bucket add gordon https://github.com/general-liquidity/gordon-cli-dist
-scoop install gordon/gordon
-```
-
-Standalone install script:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/general-liquidity/gordon-cli-dist/main/install.sh | sh
-```
-
-Windows PowerShell:
-
-```powershell
-irm https://raw.githubusercontent.com/general-liquidity/gordon-cli-dist/main/install.ps1 | iex
-```
-
-The npm package is a thin wrapper. It downloads the matching prebuilt binary for your platform during install.
-
-## npm Permission Fallback
-
-Global `npm install -g` can fail on Unix machines when the npm global prefix is root-owned. Gordon now supports a universal npm fallback:
-
-```bash
-npx @general-liquidity/gordon-cli@latest install
-```
-
-If the chosen install directory is not already on `PATH`, Gordon prints the exact command to add it.
-
-## Upgrades
-
-Once installed, Gordon can upgrade itself with:
-
-```bash
-gordon --upgrade
-```
-
-That now resolves through the active install channel for npm, the user-local `npx` installer, Homebrew, Scoop, and the standalone install scripts.
-
-## Supported binaries
-
-- macOS arm64
-- macOS x64
-- Linux arm64
-- Linux x64
-- Windows x64
-
-Release binaries and package manager manifests are published at:
-
-- `https://github.com/general-liquidity/gordon-cli-dist/releases`
-
-## Setup
-
-Set one LLM provider key before first launch:
-
-```bash
-export OPENAI_API_KEY="sk-..."
-```
-
-or
-
-```bash
-export DEDALUS_API_KEY="dd-..."
-```
-
-or
-
-```bash
-export INCEPTION_API_KEY="..."
-```
-
-Then run:
-
-```bash
-gordon
-```
-
-## Docs
-
-- Website: `https://gordoncli.com`
-- Docs: `https://docs.gordon.trade`
-- Public distribution repo: `https://github.com/general-liquidity/gordon-cli-dist`
+<h1 align="center">Gordon CLI</h1>
+
+<p align="center">
+  The Frontier Trading Agent
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@general-liquidity/gordon-cli">npm</a> •
+  <a href="https://gordoncli.com">Website</a> •
+  <a href="https://docs.gordon.trade">Docs</a> •
+  <a href="https://github.com/general-liquidity/gordon-cli-dist/releases">Downloads</a>
+</p>
+
+## Install
+
+`npm`:
+
+```bash
+npm install -g @general-liquidity/gordon-cli
+```
+
+If global npm install fails with `EACCES` / permission errors on Linux or macOS, use the user-local npm path instead:
+
+```bash
+npx @general-liquidity/gordon-cli@latest install
+```
+
+That installs Gordon into a user-writable bin directory without `sudo`.
+
+`bun`:
+
+```bash
+bun add -g @general-liquidity/gordon-cli
+```
+
+`Homebrew`:
+
+```bash
+brew tap general-liquidity/gordon-cli-dist https://github.com/general-liquidity/gordon-cli-dist
+brew install general-liquidity/gordon-cli-dist/gordon
+```
+
+`Scoop`:
+
+```powershell
+scoop bucket add gordon https://github.com/general-liquidity/gordon-cli-dist
+scoop install gordon/gordon
+```
+
+Standalone install script:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/general-liquidity/gordon-cli-dist/main/install.sh | sh
+```
+
+Windows PowerShell:
+
+```powershell
+irm https://raw.githubusercontent.com/general-liquidity/gordon-cli-dist/main/install.ps1 | iex
+```
+
+The npm package is a thin wrapper. It downloads the matching prebuilt binary for your platform during install.
+
+## npm Permission Fallback
+
+Global `npm install -g` can fail on Unix machines when the npm global prefix is root-owned. Gordon now supports a universal npm fallback:
+
+```bash
+npx @general-liquidity/gordon-cli@latest install
+```
+
+If the chosen install directory is not already on `PATH`, Gordon prints the exact command to add it.
+
+## Upgrades
+
+Once installed, Gordon can upgrade itself with:
+
+```bash
+gordon --upgrade
+```
+
+That now resolves through the active install channel for npm, the user-local `npx` installer, Homebrew, Scoop, and the standalone install scripts.
+
+## Supported binaries
+
+- macOS arm64
+- macOS x64
+- Linux arm64
+- Linux x64
+- Windows x64
+
+Release binaries and package manager manifests are published at:
+
+- `https://github.com/general-liquidity/gordon-cli-dist/releases`
+
+## Setup
+
+Set one LLM provider key before first launch:
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+or
+
+```bash
+export DEDALUS_API_KEY="dd-..."
+```
+
+or
+
+```bash
+export INCEPTION_API_KEY="..."
+```
+
+Then run:
+
+```bash
+gordon
+```
+
+## Docs
+
+- Website: `https://gordoncli.com`
+- Docs: `https://docs.gordon.trade`
+- Public distribution repo: `https://github.com/general-liquidity/gordon-cli-dist`

package/bin/gordon.cjs

@@ -1,52 +1,52 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-const { spawn } = require("child_process");
-const { getInstalledBinaryPath } = require("../lib/platform.cjs");
-const { runSelfInstall } = require("../lib/self-install.cjs");
-
-const packageRoot = path.resolve(__dirname, "..");
-const args = process.argv.slice(2);
-
-if (args[0] === "install") {
-  runSelfInstall(args.slice(1), { packageRoot }).then(
-    (code) => process.exit(code || 0),
-    (error) => {
-      console.error(`[gordon] ${error.message}`);
-      process.exit(1);
-    }
-  );
-  return;
-}
-
-let binaryPath;
-try {
-  binaryPath = getInstalledBinaryPath(packageRoot);
-} catch (error) {
-  console.error(`[gordon] ${error.message}`);
-  process.exit(1);
-}
-
-if (!fs.existsSync(binaryPath)) {
-  console.error(
-    "[gordon] The Gordon binary is missing. Reinstall with `npm install -g @general-liquidity/gordon-cli` or run `npx @general-liquidity/gordon-cli@latest install` for a user-local install."
-  );
-  process.exit(1);
-}
-
-const child = spawn(binaryPath, args, { stdio: "inherit" });
-
-child.on("error", (error) => {
-  console.error(`[gordon] Failed to launch ${path.basename(binaryPath)}: ${error.message}`);
-  process.exit(1);
-});
-
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
-
-  process.exit(code ?? 1);
-});
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+const { getInstalledBinaryPath } = require("../lib/platform.cjs");
+const { runSelfInstall } = require("../lib/self-install.cjs");
+
+const packageRoot = path.resolve(__dirname, "..");
+const args = process.argv.slice(2);
+
+if (args[0] === "install") {
+  runSelfInstall(args.slice(1), { packageRoot }).then(
+    (code) => process.exit(code || 0),
+    (error) => {
+      console.error(`[gordon] ${error.message}`);
+      process.exit(1);
+    }
+  );
+  return;
+}
+
+let binaryPath;
+try {
+  binaryPath = getInstalledBinaryPath(packageRoot);
+} catch (error) {
+  console.error(`[gordon] ${error.message}`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(binaryPath)) {
+  console.error(
+    "[gordon] The Gordon binary is missing. Reinstall with `npm install -g @general-liquidity/gordon-cli` or run `npx @general-liquidity/gordon-cli@latest install` for a user-local install."
+  );
+  process.exit(1);
+}
+
+const child = spawn(binaryPath, args, { stdio: "inherit" });
+
+child.on("error", (error) => {
+  console.error(`[gordon] Failed to launch ${path.basename(binaryPath)}: ${error.message}`);
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 1);
+});

package/lib/platform.cjs

@@ -1,53 +1,78 @@
-const path = require("path");
-
-const SUPPORTED_TARGETS = {
-  "darwin:arm64": { assetName: "gordon-darwin-arm64", binaryName: "gordon" },
-  "darwin:x64": { assetName: "gordon-darwin-x64", binaryName: "gordon" },
-  "linux:arm64": { assetName: "gordon-linux-arm64", binaryName: "gordon" },
-  "linux:x64": { assetName: "gordon-linux-x64", binaryName: "gordon" },
-  "win32:arm64": {
-    assetName: "gordon-windows-x64.exe",
-    binaryName: "gordon.exe",
-    note: "Using the Windows x64 binary on arm64."
-  },
-  "win32:x64": { assetName: "gordon-windows-x64.exe", binaryName: "gordon.exe" }
-};
-
-function getTarget(platform = process.platform, arch = process.arch) {
-  const key = `${platform}:${arch}`;
-  const target = SUPPORTED_TARGETS[key];
-  if (target) {
-    return target;
-  }
-
-  const supported = Object.keys(SUPPORTED_TARGETS)
-    .sort()
-    .join(", ");
-  throw new Error(`Unsupported platform ${platform}/${arch}. Supported targets: ${supported}`);
-}
-
-function getInstallDirectory(packageRoot = path.resolve(__dirname, "..")) {
-  return path.join(packageRoot, "vendor");
-}
-
-function getInstalledBinaryPath(packageRoot = path.resolve(__dirname, ".."), platform, arch) {
-  const { binaryName } = getTarget(platform, arch);
-  return path.join(getInstallDirectory(packageRoot), binaryName);
-}
-
-function getDownloadUrl(version, platform = process.platform, arch = process.arch) {
-  const { assetName } = getTarget(platform, arch);
-  const cleanVersion = String(version).replace(/^v/, "");
-  const distRepo = process.env.GORDON_BINARY_DIST_REPO || "general-liquidity/gordon-cli-dist";
-  const baseUrl =
-    process.env.GORDON_BINARY_BASE_URL || `https://github.com/${distRepo}/releases/download/v${cleanVersion}`;
-  return `${baseUrl.replace(/\/$/, "")}/${assetName}`;
-}
-
-module.exports = {
-  SUPPORTED_TARGETS,
-  getDownloadUrl,
-  getInstallDirectory,
-  getInstalledBinaryPath,
-  getTarget
-};
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Detect whether we're running on a musl libc Linux distro (Alpine,
+ * Void, etc). musl binaries are ABI-incompatible with glibc binaries —
+ * shipping the wrong one crashes immediately at startup.
+ */
+function isMuslLinux() {
+  if (process.platform !== "linux") return false;
+  // Heuristic 1: Alpine and Void leave a marker file
+  if (fs.existsSync("/etc/alpine-release")) return true;
+  // Heuristic 2: ldd prints the libc path
+  try {
+    const { execFileSync } = require("child_process");
+    const out = execFileSync("ldd", ["--version"], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+    if (/musl/i.test(out)) return true;
+  } catch {
+    // ldd missing — fall through
+  }
+  return false;
+}
+
+const SUPPORTED_TARGETS = {
+  "darwin:arm64": { assetName: "gordon-darwin-arm64", binaryName: "gordon" },
+  "darwin:x64": { assetName: "gordon-darwin-x64", binaryName: "gordon" },
+  "linux:arm64": { assetName: "gordon-linux-arm64", binaryName: "gordon" },
+  "linux:x64": { assetName: "gordon-linux-x64", binaryName: "gordon" },
+  "linux:arm64:musl": { assetName: "gordon-linux-arm64-musl", binaryName: "gordon" },
+  "linux:x64:musl": { assetName: "gordon-linux-x64-musl", binaryName: "gordon" },
+  "win32:arm64": { assetName: "gordon-windows-arm64.exe", binaryName: "gordon.exe" },
+  "win32:x64": { assetName: "gordon-windows-x64.exe", binaryName: "gordon.exe" }
+};
+
+function getTarget(platform = process.platform, arch = process.arch) {
+  // Linux gets a musl variant — pick the right one based on the host libc
+  let key = `${platform}:${arch}`;
+  if (platform === "linux" && isMuslLinux()) {
+    const muslKey = `${platform}:${arch}:musl`;
+    if (SUPPORTED_TARGETS[muslKey]) key = muslKey;
+  }
+
+  const target = SUPPORTED_TARGETS[key];
+  if (target) {
+    return target;
+  }
+
+  const supported = Object.keys(SUPPORTED_TARGETS)
+    .sort()
+    .join(", ");
+  throw new Error(`Unsupported platform ${platform}/${arch}. Supported targets: ${supported}`);
+}
+
+function getInstallDirectory(packageRoot = path.resolve(__dirname, "..")) {
+  return path.join(packageRoot, "vendor");
+}
+
+function getInstalledBinaryPath(packageRoot = path.resolve(__dirname, ".."), platform, arch) {
+  const { binaryName } = getTarget(platform, arch);
+  return path.join(getInstallDirectory(packageRoot), binaryName);
+}
+
+function getDownloadUrl(version, platform = process.platform, arch = process.arch) {
+  const { assetName } = getTarget(platform, arch);
+  const cleanVersion = String(version).replace(/^v/, "");
+  const distRepo = process.env.GORDON_BINARY_DIST_REPO || "general-liquidity/gordon-cli-dist";
+  const baseUrl =
+    process.env.GORDON_BINARY_BASE_URL || `https://github.com/${distRepo}/releases/download/v${cleanVersion}`;
+  return `${baseUrl.replace(/\/$/, "")}/${assetName}`;
+}
+
+module.exports = {
+  SUPPORTED_TARGETS,
+  getDownloadUrl,
+  getInstallDirectory,
+  getInstalledBinaryPath,
+  getTarget
+};

package/lib/self-install.cjs

@@ -1,343 +1,343 @@
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const https = require("https");
-const { pipeline } = require("stream/promises");
-const { getDownloadUrl, getInstalledBinaryPath, getTarget } = require("./platform.cjs");
-const pkg = require("../package.json");
-const INSTALL_METADATA_FILENAME = "gordon-install.json";
-
-function log(message) {
-  console.log(`[gordon] ${message}`);
-}
-
-function parseArgs(args) {
-  const options = {
-    help: false,
-    targetDir: null
-  };
-
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--help" || arg === "-h") {
-      options.help = true;
-      continue;
-    }
-
-    if ((arg === "--target-dir" || arg === "--dir") && args[index + 1]) {
-      options.targetDir = path.resolve(args[index + 1]);
-      index += 1;
-      continue;
-    }
-
-    throw new Error(`Unknown install option: ${arg}`);
-  }
-
-  return options;
-}
-
-function printHelp() {
-  console.log(`gordon install
-
-Install Gordon into a user-writable bin directory without requiring \`npm install -g\`.
-
-Usage:
-  npx @general-liquidity/gordon-cli@latest install
-  gordon install --target-dir <directory>
-
-Options:
-  --target-dir <dir>   Override the install directory
-  -h, --help           Show this help
-`);
-}
-
-function normalizeForCompare(value) {
-  const resolved = path.resolve(value);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-
-function splitPathEntries(envPath = process.env.PATH || "") {
-  return envPath.split(path.delimiter).filter(Boolean);
-}
-
-function pathContainsDirectory(directory, env = process.env) {
-  const target = normalizeForCompare(directory);
-  return splitPathEntries(env.PATH).some((entry) => {
-    try {
-      return normalizeForCompare(entry) === target;
-    } catch {
-      return false;
-    }
-  });
-}
-
-function uniqueDirectories(values) {
-  const seen = new Set();
-  const result = [];
-  for (const value of values) {
-    if (!value) {
-      continue;
-    }
-
-    const normalized = normalizeForCompare(value);
-    if (seen.has(normalized)) {
-      continue;
-    }
-
-    seen.add(normalized);
-    result.push(path.resolve(value));
-  }
-  return result;
-}
-
-async function isWritableDirectory(directory, { create } = { create: false }) {
-  try {
-    if (create) {
-      await fs.promises.mkdir(directory, { recursive: true });
-    } else {
-      const stats = await fs.promises.stat(directory);
-      if (!stats.isDirectory()) {
-        return false;
-      }
-    }
-
-    const probePath = path.join(directory, `.gordon-write-test-${process.pid}-${Date.now()}`);
-    await fs.promises.writeFile(probePath, "");
-    await fs.promises.rm(probePath, { force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveInstallDirectory(explicitTargetDir = null, env = process.env) {
-  if (explicitTargetDir) {
-    return {
-      directory: explicitTargetDir,
-      inPath: pathContainsDirectory(explicitTargetDir, env)
-    };
-  }
-
-  const homeDirectory = os.homedir();
-  const pathEntries = splitPathEntries(env.PATH);
-  const standardCandidates = [];
-  const pathCandidates = [];
-
-  if (process.platform === "win32") {
-    if (env.APPDATA) {
-      standardCandidates.push(path.join(env.APPDATA, "npm"));
-    }
-    if (env.LOCALAPPDATA) {
-      standardCandidates.push(path.join(env.LOCALAPPDATA, "Microsoft", "WinGet", "Links"));
-      standardCandidates.push(path.join(env.LOCALAPPDATA, "gordon"));
-    }
-
-    for (const entry of pathEntries) {
-      const resolvedEntry = path.resolve(entry);
-      const normalizedEntry = normalizeForCompare(resolvedEntry);
-      const userRoots = uniqueDirectories([
-        env.USERPROFILE,
-        env.LOCALAPPDATA,
-        env.APPDATA,
-        homeDirectory
-      ]);
-      const withinUserRoot = userRoots.some((root) => {
-        const normalizedRoot = normalizeForCompare(root);
-        return normalizedEntry === normalizedRoot || normalizedEntry.startsWith(`${normalizedRoot}${path.sep}`);
-      });
-      if (
-        withinUserRoot
-        && !normalizedEntry.includes(`${path.sep}node_modules${path.sep}`)
-      ) {
-        pathCandidates.push(resolvedEntry);
-      }
-    }
-  } else {
-    standardCandidates.push(path.join(homeDirectory, ".local", "bin"));
-    standardCandidates.push(path.join(homeDirectory, "bin"));
-
-    for (const entry of pathEntries) {
-      const resolvedEntry = path.resolve(entry);
-      const normalizedEntry = normalizeForCompare(resolvedEntry);
-      const normalizedHome = `${normalizeForCompare(homeDirectory)}${path.sep}`;
-      if (
-        normalizedEntry.startsWith(normalizedHome)
-        && !normalizedEntry.includes(`${path.sep}node_modules${path.sep}`)
-      ) {
-        pathCandidates.push(resolvedEntry);
-      }
-    }
-  }
-
-  const orderedCandidates = uniqueDirectories([
-    ...standardCandidates.filter((candidate) => pathContainsDirectory(candidate, env)),
-    ...pathCandidates,
-    ...standardCandidates
-  ]);
-
-  for (const candidate of orderedCandidates) {
-    const create = standardCandidates.some((standardCandidate) => normalizeForCompare(standardCandidate) === normalizeForCompare(candidate));
-    if (await isWritableDirectory(candidate, { create })) {
-      return {
-        directory: candidate,
-        inPath: pathContainsDirectory(candidate, env)
-      };
-    }
-  }
-
-  throw new Error("Could not find a writable user install directory.");
-}
-
-async function downloadBinary(url, destinationPath, redirectCount = 0) {
-  if (redirectCount > 5) {
-    throw new Error(`Too many redirects while downloading ${url}`);
-  }
-
-  await new Promise((resolve, reject) => {
-    const request = https.get(
-      url,
-      { headers: { "User-Agent": "gordon-npm-installer" } },
-      async (response) => {
-        if (
-          response.statusCode &&
-          response.statusCode >= 300 &&
-          response.statusCode < 400 &&
-          response.headers.location
-        ) {
-          response.resume();
-          try {
-            await downloadBinary(response.headers.location, destinationPath, redirectCount + 1);
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-          return;
-        }
-
-        if (response.statusCode !== 200) {
-          response.resume();
-          reject(new Error(`Download failed with status ${response.statusCode} for ${url}`));
-          return;
-        }
-
-        const fileStream = fs.createWriteStream(destinationPath);
-        pipeline(response, fileStream).then(resolve, reject);
-      }
-    );
-
-    request.on("error", reject);
-  });
-}
-
-async function finalizeBinary(tempPath, targetPath) {
-  if (process.platform !== "win32") {
-    await fs.promises.chmod(tempPath, 0o755);
-  }
-
-  await fs.promises.rm(targetPath, { force: true });
-  await fs.promises.rename(tempPath, targetPath);
-}
-
-async function writeInstallMetadata(targetDirectory, version, channel) {
-  const metadataPath = path.join(targetDirectory, INSTALL_METADATA_FILENAME);
-  const payload = {
-    channel,
-    installDir: targetDirectory,
-    version,
-    installedAt: new Date().toISOString()
-  };
-  await fs.promises.writeFile(metadataPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-
-function getUnixPathHint(directory, env = process.env) {
-  const shell = env.SHELL || "";
-  if (shell.includes("fish")) {
-    return {
-      profile: "~/.config/fish/config.fish",
-      command: `fish_add_path ${directory.replace(os.homedir(), "$HOME")}`
-    };
-  }
-
-  if (shell.includes("zsh")) {
-    return {
-      profile: "~/.zshrc",
-      command: `echo 'export PATH=\"${directory.replace(os.homedir(), "$HOME")}:$PATH\"' >> ~/.zshrc`
-    };
-  }
-
-  return {
-    profile: "~/.bashrc",
-    command: `echo 'export PATH=\"${directory.replace(os.homedir(), "$HOME")}:$PATH\"' >> ~/.bashrc`
-  };
-}
-
-function printPathGuidance(directory) {
-  if (process.platform === "win32") {
-    log(`Add ${directory} to your user PATH, then open a new terminal.`);
-    return;
-  }
-
-  const hint = getUnixPathHint(directory);
-  log(`Add ${directory} to PATH if your shell cannot find \`gordon\` yet.`);
-  console.log(`      ${hint.command}`);
-  console.log(`      # then restart your shell or source ${hint.profile}`);
-}
-
-async function installBinary({ targetDirectory, sourceBinaryPath, version }) {
-  const { binaryName, assetName } = getTarget();
-  await fs.promises.mkdir(targetDirectory, { recursive: true });
-
-  const installPath = path.join(targetDirectory, binaryName);
-  const tempPath = `${installPath}.tmp`;
-  await fs.promises.rm(tempPath, { force: true });
-
-  if (sourceBinaryPath && fs.existsSync(sourceBinaryPath)) {
-    log(`Copying ${path.basename(sourceBinaryPath)} to ${installPath}`);
-    await fs.promises.copyFile(sourceBinaryPath, tempPath);
-  } else {
-    const downloadUrl = getDownloadUrl(version);
-    log(`Downloading ${assetName} from ${downloadUrl}`);
-    await downloadBinary(downloadUrl, tempPath);
-  }
-
-  await finalizeBinary(tempPath, installPath);
-  return installPath;
-}
-
-async function runSelfInstall(args, options = {}) {
-  const parsed = parseArgs(args);
-  if (parsed.help) {
-    printHelp();
-    return 0;
-  }
-
-  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
-  const version = String(options.version || pkg.version).replace(/^v/, "");
-  const bundledBinaryPath = options.sourceBinaryPath || getInstalledBinaryPath(packageRoot);
-  const sourceBinaryPath = fs.existsSync(bundledBinaryPath) ? bundledBinaryPath : null;
-  const { directory, inPath } = await resolveInstallDirectory(parsed.targetDir);
-  const installPath = await installBinary({
-    targetDirectory: directory,
-    sourceBinaryPath,
-    version
-  });
-  await writeInstallMetadata(directory, version, options.channel || "npx");
-
-  console.log("");
-  log(`Installed Gordon v${version} to ${installPath}`);
-  if (!inPath) {
-    printPathGuidance(directory);
-  }
-  console.log("");
-  console.log("Next steps:");
-  console.log("  gordon --help");
-  console.log("  gordon");
-
-  return 0;
-}
-
-module.exports = {
-  parseArgs,
-  resolveInstallDirectory,
-  runSelfInstall
-};
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const { pipeline } = require("stream/promises");
+const { getDownloadUrl, getInstalledBinaryPath, getTarget } = require("./platform.cjs");
+const pkg = require("../package.json");
+const INSTALL_METADATA_FILENAME = "gordon-install.json";
+
+function log(message) {
+  console.log(`[gordon] ${message}`);
+}
+
+function parseArgs(args) {
+  const options = {
+    help: false,
+    targetDir: null
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if ((arg === "--target-dir" || arg === "--dir") && args[index + 1]) {
+      options.targetDir = path.resolve(args[index + 1]);
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown install option: ${arg}`);
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log(`gordon install
+
+Install Gordon into a user-writable bin directory without requiring \`npm install -g\`.
+
+Usage:
+  npx @general-liquidity/gordon-cli@latest install
+  gordon install --target-dir <directory>
+
+Options:
+  --target-dir <dir>   Override the install directory
+  -h, --help           Show this help
+`);
+}
+
+function normalizeForCompare(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function splitPathEntries(envPath = process.env.PATH || "") {
+  return envPath.split(path.delimiter).filter(Boolean);
+}
+
+function pathContainsDirectory(directory, env = process.env) {
+  const target = normalizeForCompare(directory);
+  return splitPathEntries(env.PATH).some((entry) => {
+    try {
+      return normalizeForCompare(entry) === target;
+    } catch {
+      return false;
+    }
+  });
+}
+
+function uniqueDirectories(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    if (!value) {
+      continue;
+    }
+
+    const normalized = normalizeForCompare(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+
+    seen.add(normalized);
+    result.push(path.resolve(value));
+  }
+  return result;
+}
+
+async function isWritableDirectory(directory, { create } = { create: false }) {
+  try {
+    if (create) {
+      await fs.promises.mkdir(directory, { recursive: true });
+    } else {
+      const stats = await fs.promises.stat(directory);
+      if (!stats.isDirectory()) {
+        return false;
+      }
+    }
+
+    const probePath = path.join(directory, `.gordon-write-test-${process.pid}-${Date.now()}`);
+    await fs.promises.writeFile(probePath, "");
+    await fs.promises.rm(probePath, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveInstallDirectory(explicitTargetDir = null, env = process.env) {
+  if (explicitTargetDir) {
+    return {
+      directory: explicitTargetDir,
+      inPath: pathContainsDirectory(explicitTargetDir, env)
+    };
+  }
+
+  const homeDirectory = os.homedir();
+  const pathEntries = splitPathEntries(env.PATH);
+  const standardCandidates = [];
+  const pathCandidates = [];
+
+  if (process.platform === "win32") {
+    if (env.APPDATA) {
+      standardCandidates.push(path.join(env.APPDATA, "npm"));
+    }
+    if (env.LOCALAPPDATA) {
+      standardCandidates.push(path.join(env.LOCALAPPDATA, "Microsoft", "WinGet", "Links"));
+      standardCandidates.push(path.join(env.LOCALAPPDATA, "gordon"));
+    }
+
+    for (const entry of pathEntries) {
+      const resolvedEntry = path.resolve(entry);
+      const normalizedEntry = normalizeForCompare(resolvedEntry);
+      const userRoots = uniqueDirectories([
+        env.USERPROFILE,
+        env.LOCALAPPDATA,
+        env.APPDATA,
+        homeDirectory
+      ]);
+      const withinUserRoot = userRoots.some((root) => {
+        const normalizedRoot = normalizeForCompare(root);
+        return normalizedEntry === normalizedRoot || normalizedEntry.startsWith(`${normalizedRoot}${path.sep}`);
+      });
+      if (
+        withinUserRoot
+        && !normalizedEntry.includes(`${path.sep}node_modules${path.sep}`)
+      ) {
+        pathCandidates.push(resolvedEntry);
+      }
+    }
+  } else {
+    standardCandidates.push(path.join(homeDirectory, ".local", "bin"));
+    standardCandidates.push(path.join(homeDirectory, "bin"));
+
+    for (const entry of pathEntries) {
+      const resolvedEntry = path.resolve(entry);
+      const normalizedEntry = normalizeForCompare(resolvedEntry);
+      const normalizedHome = `${normalizeForCompare(homeDirectory)}${path.sep}`;
+      if (
+        normalizedEntry.startsWith(normalizedHome)
+        && !normalizedEntry.includes(`${path.sep}node_modules${path.sep}`)
+      ) {
+        pathCandidates.push(resolvedEntry);
+      }
+    }
+  }
+
+  const orderedCandidates = uniqueDirectories([
+    ...standardCandidates.filter((candidate) => pathContainsDirectory(candidate, env)),
+    ...pathCandidates,
+    ...standardCandidates
+  ]);
+
+  for (const candidate of orderedCandidates) {
+    const create = standardCandidates.some((standardCandidate) => normalizeForCompare(standardCandidate) === normalizeForCompare(candidate));
+    if (await isWritableDirectory(candidate, { create })) {
+      return {
+        directory: candidate,
+        inPath: pathContainsDirectory(candidate, env)
+      };
+    }
+  }
+
+  throw new Error("Could not find a writable user install directory.");
+}
+
+async function downloadBinary(url, destinationPath, redirectCount = 0) {
+  if (redirectCount > 5) {
+    throw new Error(`Too many redirects while downloading ${url}`);
+  }
+
+  await new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      { headers: { "User-Agent": "gordon-npm-installer" } },
+      async (response) => {
+        if (
+          response.statusCode &&
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          try {
+            await downloadBinary(response.headers.location, destinationPath, redirectCount + 1);
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(`Download failed with status ${response.statusCode} for ${url}`));
+          return;
+        }
+
+        const fileStream = fs.createWriteStream(destinationPath);
+        pipeline(response, fileStream).then(resolve, reject);
+      }
+    );
+
+    request.on("error", reject);
+  });
+}
+
+async function finalizeBinary(tempPath, targetPath) {
+  if (process.platform !== "win32") {
+    await fs.promises.chmod(tempPath, 0o755);
+  }
+
+  await fs.promises.rm(targetPath, { force: true });
+  await fs.promises.rename(tempPath, targetPath);
+}
+
+async function writeInstallMetadata(targetDirectory, version, channel) {
+  const metadataPath = path.join(targetDirectory, INSTALL_METADATA_FILENAME);
+  const payload = {
+    channel,
+    installDir: targetDirectory,
+    version,
+    installedAt: new Date().toISOString()
+  };
+  await fs.promises.writeFile(metadataPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function getUnixPathHint(directory, env = process.env) {
+  const shell = env.SHELL || "";
+  if (shell.includes("fish")) {
+    return {
+      profile: "~/.config/fish/config.fish",
+      command: `fish_add_path ${directory.replace(os.homedir(), "$HOME")}`
+    };
+  }
+
+  if (shell.includes("zsh")) {
+    return {
+      profile: "~/.zshrc",
+      command: `echo 'export PATH=\"${directory.replace(os.homedir(), "$HOME")}:$PATH\"' >> ~/.zshrc`
+    };
+  }
+
+  return {
+    profile: "~/.bashrc",
+    command: `echo 'export PATH=\"${directory.replace(os.homedir(), "$HOME")}:$PATH\"' >> ~/.bashrc`
+  };
+}
+
+function printPathGuidance(directory) {
+  if (process.platform === "win32") {
+    log(`Add ${directory} to your user PATH, then open a new terminal.`);
+    return;
+  }
+
+  const hint = getUnixPathHint(directory);
+  log(`Add ${directory} to PATH if your shell cannot find \`gordon\` yet.`);
+  console.log(`      ${hint.command}`);
+  console.log(`      # then restart your shell or source ${hint.profile}`);
+}
+
+async function installBinary({ targetDirectory, sourceBinaryPath, version }) {
+  const { binaryName, assetName } = getTarget();
+  await fs.promises.mkdir(targetDirectory, { recursive: true });
+
+  const installPath = path.join(targetDirectory, binaryName);
+  const tempPath = `${installPath}.tmp`;
+  await fs.promises.rm(tempPath, { force: true });
+
+  if (sourceBinaryPath && fs.existsSync(sourceBinaryPath)) {
+    log(`Copying ${path.basename(sourceBinaryPath)} to ${installPath}`);
+    await fs.promises.copyFile(sourceBinaryPath, tempPath);
+  } else {
+    const downloadUrl = getDownloadUrl(version);
+    log(`Downloading ${assetName} from ${downloadUrl}`);
+    await downloadBinary(downloadUrl, tempPath);
+  }
+
+  await finalizeBinary(tempPath, installPath);
+  return installPath;
+}
+
+async function runSelfInstall(args, options = {}) {
+  const parsed = parseArgs(args);
+  if (parsed.help) {
+    printHelp();
+    return 0;
+  }
+
+  const packageRoot = options.packageRoot || path.resolve(__dirname, "..");
+  const version = String(options.version || pkg.version).replace(/^v/, "");
+  const bundledBinaryPath = options.sourceBinaryPath || getInstalledBinaryPath(packageRoot);
+  const sourceBinaryPath = fs.existsSync(bundledBinaryPath) ? bundledBinaryPath : null;
+  const { directory, inPath } = await resolveInstallDirectory(parsed.targetDir);
+  const installPath = await installBinary({
+    targetDirectory: directory,
+    sourceBinaryPath,
+    version
+  });
+  await writeInstallMetadata(directory, version, options.channel || "npx");
+
+  console.log("");
+  log(`Installed Gordon v${version} to ${installPath}`);
+  if (!inPath) {
+    printPathGuidance(directory);
+  }
+  console.log("");
+  console.log("Next steps:");
+  console.log("  gordon --help");
+  console.log("  gordon");
+
+  return 0;
+}
+
+module.exports = {
+  parseArgs,
+  resolveInstallDirectory,
+  runSelfInstall
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@general-liquidity/gordon-cli",
-  "version": "0.8.25",
+  "version": "0.9.0-friends.7",
   "description": "The Frontier Trading Agent",
   "author": "General Liquidity, Inc.",
   "license": "MIT",
@@ -32,6 +32,10 @@
   "engines": {
     "node": ">=18"
   },
+  "publishConfig": {
+    "access": "public",
+    "tag": "friends"
+  },
   "scripts": {
     "prepack": "node ../scripts/prepare-npm-wrapper.cjs",
     "postinstall": "node scripts/postinstall.cjs"