@fastmoss/cli 0.1.5 → 0.1.13

package/lib/runtime.js

@@ -1,494 +1,89 @@
 const fs = require("node:fs");
-const os = require("node:os");
 const path = require("node:path");
-const http = require("node:http");
-const https = require("node:https");
-const { pipeline } = require("node:stream/promises");
 const { spawn } = require("node:child_process");
+const { resolvePlatformTarget } = require("./targets");
 
-const DEFAULT_DOWNLOAD_BASE_URL =
-  "https://github.com/FastMoss/cli/releases/download";
-const SKILL_NAME = "fastmoss-cli";
-const INSTALL_SKILL_USAGE = `Usage: fastmoss-install-skill [--agent codex|claude|agents|all]
-
-Options:
-  -a, --agent <agent>   Install for a specific agent client.
-                         Supported: codex, claude, agents, all.
-  -h, --help            Show this help message.
-
-Environment:
-  FASTMOSS_SKILL_AGENT          Default agent for this command.
-  FASTMOSS_SKILL_DIR            Override the target skills directory.
-  FASTMOSS_SKIP_SKILL_INSTALL   Skip skill installation.
-`;
-
-const PLATFORM_TARGETS = {
-  "darwin:x64": {
-    assetName: "fastmoss-darwin-amd64",
-    binaryName: "fastmoss",
-    cacheKey: "darwin-amd64",
-  },
-  "darwin:arm64": {
-    assetName: "fastmoss-darwin-arm64",
-    binaryName: "fastmoss",
-    cacheKey: "darwin-arm64",
-  },
-  "linux:x64": {
-    assetName: "fastmoss-linux-amd64",
-    binaryName: "fastmoss",
-    cacheKey: "linux-amd64",
-  },
-  "linux:arm64": {
-    assetName: "fastmoss-linux-arm64",
-    binaryName: "fastmoss",
-    cacheKey: "linux-arm64",
-  },
-  "win32:x64": {
-    assetName: "fastmoss-windows-amd64.exe",
-    binaryName: "fastmoss.exe",
-    cacheKey: "windows-amd64",
-  },
-};
-
-function resolvePlatformTarget({
-  platform = process.platform,
-  arch = process.arch,
-} = {}) {
-  const key = `${platform}:${arch}`;
-  const target = PLATFORM_TARGETS[key];
-  if (!target) {
-    throw new Error(
-      `Unsupported platform: ${platform}/${arch}. Supported targets: ${Object.keys(
-        PLATFORM_TARGETS,
-      )
-        .map((value) => value.replace(":", "/"))
-        .join(", ")}`,
-    );
-  }
-  return target;
-}
-
-function resolveCacheRoot({
-  env = process.env,
-  homeDir = os.homedir(),
-} = {}) {
-  const override = String(env.FASTMOSS_CACHE_DIR || "").trim();
-  if (override !== "") {
-    return override;
-  }
-  return path.join(homeDir, ".fastmoss", "bin");
-}
-
-function resolveBinaryPath({ cacheRoot, version, target }) {
-  return path.join(cacheRoot, version, target.cacheKey, target.binaryName);
+function reinstallMessage(version) {
+  return [
+    `Run: npm install -g @fastmoss/cli@${version}`,
+    "Do not install with --omit=optional.",
+  ].join("\n");
 }
 
-function resolveDownloadBaseURL({
-  env = process.env,
-  configuredDownloadBaseURL = "",
-} = {}) {
-  const envOverride = String(env.FASTMOSS_DOWNLOAD_BASE_URL || "").trim();
-  if (envOverride !== "") {
-    return envOverride.replace(/\/+$/, "");
-  }
-
-  const configured = String(configuredDownloadBaseURL || "").trim();
-  if (configured !== "") {
-    return configured.replace(/\/+$/, "");
-  }
-
-  return DEFAULT_DOWNLOAD_BASE_URL;
-}
-
-function buildDownloadURL({
+function resolvePlatformBinary({
   version,
-  target,
-  env = process.env,
-  configuredDownloadBaseURL = "",
-}) {
-  const baseURL = resolveDownloadBaseURL({ env, configuredDownloadBaseURL });
-  return `${baseURL}/v${version}/${target.assetName}`;
-}
-
-async function ensureBinary({
-  version,
-  env = process.env,
   platform = process.platform,
   arch = process.arch,
-  homeDir = os.homedir(),
-  configuredDownloadBaseURL = "",
-  onDownloadStart = () => {},
-  downloadFileFn = downloadFile,
-}) {
-  const target = resolvePlatformTarget({ platform, arch });
-  const cacheRoot = resolveCacheRoot({ env, homeDir });
-  const binaryPath = resolveBinaryPath({ cacheRoot, version, target });
-
-  if (await fileExists(binaryPath)) {
-    return { binaryPath, downloaded: false };
-  }
-
-  await fs.promises.mkdir(path.dirname(binaryPath), { recursive: true });
-  const downloadURL = buildDownloadURL({
-    version,
-    target,
-    env,
-    configuredDownloadBaseURL,
-  });
-  const tempPath = `${binaryPath}.download`;
-
-  onDownloadStart(downloadURL);
-  await downloadFileFn(downloadURL, tempPath);
-
-  if (platform !== "win32") {
-    await fs.promises.chmod(tempPath, 0o755);
-  }
-
-  await fs.promises.rename(tempPath, binaryPath);
-  return { binaryPath, downloaded: true, downloadURL };
-}
-
-function shouldSkipDownload(env = process.env) {
-  const value = String(env.FASTMOSS_SKIP_DOWNLOAD || "").trim().toLowerCase();
-  return value !== "" && value !== "0" && value !== "false";
-}
-
-function isTruthyEnv(value) {
-  const normalized = String(value || "").trim().toLowerCase();
-  return normalized !== "" && normalized !== "0" && normalized !== "false";
-}
-
-function shouldSkipSkillInstall(env = process.env) {
-  return isTruthyEnv(env.FASTMOSS_SKIP_SKILL_INSTALL);
-}
-
-function normalizeSkillAgent(agent = "") {
-  const normalized = String(agent || "").trim().toLowerCase();
-  if (normalized === "" || normalized === "auto") {
-    return "auto";
-  }
-  if (normalized === "claude-code") {
-    return "claude";
-  }
-  if (normalized === "agent") {
-    return "agents";
-  }
-  return normalized;
-}
-
-function knownSkillTargets({ env = process.env, homeDir = os.homedir() } = {}) {
-  return {
-    codex: path.join(env.CODEX_HOME || path.join(homeDir, ".codex"), "skills"),
-    claude: path.join(
-      env.CLAUDE_HOME || path.join(homeDir, ".claude"),
-      "skills",
-    ),
-    agents: path.join(
-      env.AGENTS_HOME || path.join(homeDir, ".agents"),
-      "skills",
-    ),
-  };
-}
-
-function resolveSkillInstallTargets({
-  agent = "auto",
-  env = process.env,
-  homeDir = os.homedir(),
+  resolvePackageJSON = (packageName) =>
+    require.resolve(`${packageName}/package.json`),
+  readFileSync = fs.readFileSync,
+  accessSync = fs.accessSync,
 } = {}) {
-  const override = String(env.FASTMOSS_SKILL_DIR || "").trim();
-  if (override !== "") {
-    return [override];
-  }
-
-  const targets = knownSkillTargets({ env, homeDir });
-  const normalizedAgent = normalizeSkillAgent(agent || env.FASTMOSS_SKILL_AGENT);
-
-  if (normalizedAgent === "all") {
-    return [targets.codex, targets.claude, targets.agents];
-  }
-  if (normalizedAgent === "auto") {
-    return Object.values(targets);
-  }
-  if (targets[normalizedAgent]) {
-    return [targets[normalizedAgent]];
-  }
-
-  throw new Error(
-    `Unsupported FastMoss skill agent: ${agent}. Supported agents: codex, claude, agents, all`,
-  );
-}
-
-function parseInstallSkillArgs(args = []) {
-  const result = {
-    agent: "",
-    help: false,
-  };
-
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--help" || arg === "-h") {
-      result.help = true;
-      continue;
-    }
-    if (arg === "--agent" || arg === "-a") {
-      const value = args[index + 1];
-      if (!value || value.startsWith("-")) {
-        throw new Error(`${arg} requires an agent value`);
-      }
-      result.agent = value;
-      index += 1;
-      continue;
-    }
-    throw new Error(`Unknown option: ${arg}`);
-  }
-
-  return result;
-}
-
-async function installSkill({
-  packageRoot = path.join(__dirname, ".."),
-  agent = "",
-  env = process.env,
-  homeDir = os.homedir(),
-  stderr = process.stderr,
-} = {}) {
-  if (shouldSkipSkillInstall(env)) {
-    stderr.write(
-      "Skipping FastMoss CLI skill installation because FASTMOSS_SKIP_SKILL_INSTALL is set.\n",
-    );
-    return { installed: [], skipped: true };
-  }
-
-  const sourceSkillDir = path.join(packageRoot, "skills", SKILL_NAME);
-  if (!(await directoryExists(sourceSkillDir))) {
-    throw new Error(`FastMoss CLI skill not found: ${sourceSkillDir}`);
-  }
-
-  let targetRoots = resolveSkillInstallTargets({
-    agent: agent || env.FASTMOSS_SKILL_AGENT || "auto",
-    env,
-    homeDir,
-  });
-
-  const isAuto =
-    String(env.FASTMOSS_SKILL_DIR || "").trim() === "" &&
-    normalizeSkillAgent(agent || env.FASTMOSS_SKILL_AGENT) === "auto";
-  if (isAuto) {
-    const existingRoots = [];
-    for (const targetRoot of targetRoots) {
-      if (await directoryExists(targetRoot)) {
-        existingRoots.push(targetRoot);
-      }
-    }
-    targetRoots = existingRoots;
-  }
-
-  if (targetRoots.length === 0) {
-    stderr.write(
-      "Skipping FastMoss CLI skill installation because no supported agent skill directory was found. Set FASTMOSS_SKILL_AGENT=codex or FASTMOSS_SKILL_DIR to install explicitly.\n",
-    );
-    return { installed: [], skipped: true };
-  }
-
-  const installed = [];
-  for (const targetRoot of targetRoots) {
-    const targetSkillDir = path.join(targetRoot, SKILL_NAME);
-    await fs.promises.mkdir(targetRoot, { recursive: true });
-    await fs.promises.rm(targetSkillDir, { recursive: true, force: true });
-    await fs.promises.cp(sourceSkillDir, targetSkillDir, { recursive: true });
-    installed.push(targetSkillDir);
-    stderr.write(`Installed FastMoss CLI skill to ${targetSkillDir}\n`);
-  }
-
-  return { installed, skipped: false };
-}
-
-async function installCLI({
-  version,
-  env = process.env,
-  platform = process.platform,
-  arch = process.arch,
-  homeDir = os.homedir(),
-  stderr = process.stderr,
-  configuredDownloadBaseURL = "",
-} = {}) {
-  if (shouldSkipDownload(env)) {
-    stderr.write(
-      "Skipping fastmoss binary download because FASTMOSS_SKIP_DOWNLOAD is set.\n",
-    );
-    return { skipped: true };
-  }
-
-  return ensureBinary({
-    version,
-    env,
-    platform,
-    arch,
-    homeDir,
-    configuredDownloadBaseURL,
-    onDownloadStart(downloadURL) {
-      stderr.write(`Downloading fastmoss ${version} from ${downloadURL}\n`);
-    },
-  });
-}
-
-async function fileExists(filePath) {
+  const target = resolvePlatformTarget({ platform, arch });
+  let packageJSONPath;
   try {
-    const stat = await fs.promises.stat(filePath);
-    return stat.isFile() && stat.size > 0;
+    packageJSONPath = resolvePackageJSON(target.packageName);
   } catch (error) {
-    if (error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
+    if (!error || error.code !== "MODULE_NOT_FOUND") throw error;
+    throw new Error(
+      [
+        `FastMoss binary package for ${platform}/${arch} is missing: ${target.packageName}.`,
+        reinstallMessage(version),
+      ].join("\n"),
+    );
   }
-}
 
-async function directoryExists(directoryPath) {
-  try {
-    const stat = await fs.promises.stat(directoryPath);
-    return stat.isDirectory();
-  } catch (error) {
-    if (error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
+  const platformPackage = JSON.parse(readFileSync(packageJSONPath, "utf8"));
+  if (platformPackage.version !== version) {
+    throw new Error(
+      [
+        `FastMoss platform package version mismatch: expected ${version}, found ${platformPackage.version}.`,
+        reinstallMessage(version),
+      ].join("\n"),
+    );
   }
-}
 
-async function downloadFile(url, destination) {
+  const binaryPath = path.join(
+    path.dirname(packageJSONPath),
+    "bin",
+    target.binaryName,
+  );
   try {
-    await downloadWithRedirects(url, destination, 0);
-  } catch (error) {
-    await fs.promises.rm(destination, { force: true }).catch(() => {});
-    throw error;
-  }
-}
-
-function downloadWithRedirects(url, destination, redirectCount) {
-  if (redirectCount > 5) {
-    return Promise.reject(new Error("Too many redirects while downloading fastmoss"));
-  }
-
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith("https://") ? https : http;
-    const request = client.get(
-      url,
-      {
-        headers: {
-          "User-Agent": "fastmoss-npm-wrapper",
-        },
-      },
-      async (response) => {
-        const statusCode = response.statusCode || 0;
-
-        if (
-          statusCode >= 300 &&
-          statusCode < 400 &&
-          response.headers.location
-        ) {
-          response.resume();
-          try {
-            await downloadWithRedirects(
-              response.headers.location,
-              destination,
-              redirectCount + 1,
-            );
-            resolve();
-          } catch (error) {
-            reject(error);
-          }
-          return;
-        }
-
-        if (statusCode !== 200) {
-          response.resume();
-          reject(
-            new Error(
-              `Failed to download fastmoss binary: HTTP ${statusCode} from ${url}`,
-            ),
-          );
-          return;
-        }
-
-        const output = fs.createWriteStream(destination, { mode: 0o755 });
-        try {
-          await pipeline(response, output);
-          resolve();
-        } catch (error) {
-          reject(error);
-        }
-      },
+    accessSync(
+      binaryPath,
+      platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK,
     );
-
-    request.on("error", reject);
-  });
+  } catch {
+    throw new Error(
+      [
+        `FastMoss binary is missing or not executable: ${binaryPath}.`,
+        reinstallMessage(version),
+      ].join("\n"),
+    );
+  }
+  return { binaryPath, target };
 }
 
 async function runCLI({
   version,
   args = process.argv.slice(2),
-  env = process.env,
   platform = process.platform,
   arch = process.arch,
-  homeDir = os.homedir(),
   stdout = process.stdout,
-  stderr = process.stderr,
-  configuredDownloadBaseURL = "",
+  resolveBinary = resolvePlatformBinary,
+  spawnFn = spawn,
 } = {}) {
-  if (
-    args.length === 1 &&
-    ["--version", "-v", "version"].includes(args[0])
-  ) {
+  if (args.length === 1 && ["--version", "-v", "version"].includes(args[0])) {
     stdout.write(`${version}\n`);
-    return;
+    return { code: 0, signal: null };
   }
 
-  const { binaryPath, downloaded, downloadURL } = await ensureBinary({
-    version,
-    env,
-    platform,
-    arch,
-    homeDir,
-    configuredDownloadBaseURL,
-    onDownloadStart(downloadURL) {
-      stderr.write(`Downloading fastmoss ${version} from ${downloadURL}\n`);
-    },
-  });
-
-  if (downloaded) {
-    stderr.write(`Downloaded fastmoss ${version} to ${binaryPath}\n`);
-  }
-
-  await new Promise((resolve, reject) => {
-    const child = spawn(binaryPath, args, {
-      stdio: ["inherit", stdout, stderr],
-    });
-
-    child.on("error", reject);
-    child.on("exit", (code, signal) => {
-      if (signal) {
-        reject(new Error(`fastmoss exited with signal ${signal}`));
-        return;
-      }
-      process.exitCode = code || 0;
-      resolve();
-    });
+  const { binaryPath } = resolveBinary({ version, platform, arch });
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(binaryPath, args, { stdio: "inherit" });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
   });
 }
 
-module.exports = {
-  DEFAULT_DOWNLOAD_BASE_URL,
-  INSTALL_SKILL_USAGE,
-  buildDownloadURL,
-  ensureBinary,
-  installSkill,
-  installCLI,
-  parseInstallSkillArgs,
-  resolveBinaryPath,
-  resolveCacheRoot,
-  resolveDownloadBaseURL,
-  resolveSkillInstallTargets,
-  resolvePlatformTarget,
-  runCLI,
-};
+module.exports = { reinstallMessage, resolvePlatformBinary, runCLI };

package/lib/targets.js

@@ -0,0 +1,65 @@
+const PLATFORM_TARGETS = Object.freeze({
+  "darwin:x64": Object.freeze({
+    packageName: "@fastmoss/cli-darwin-amd64",
+    packageDir: "cli-darwin-amd64",
+    assetName: "fastmoss-darwin-amd64",
+    binaryName: "fastmoss-darwin-amd64",
+    buildPath: "darwin-amd64/fastmoss",
+    os: "darwin",
+    cpu: "x64",
+  }),
+  "darwin:arm64": Object.freeze({
+    packageName: "@fastmoss/cli-darwin-arm64",
+    packageDir: "cli-darwin-arm64",
+    assetName: "fastmoss-darwin-arm64",
+    binaryName: "fastmoss-darwin-arm64",
+    buildPath: "darwin-arm64/fastmoss",
+    os: "darwin",
+    cpu: "arm64",
+  }),
+  "linux:x64": Object.freeze({
+    packageName: "@fastmoss/cli-linux-amd64",
+    packageDir: "cli-linux-amd64",
+    assetName: "fastmoss-linux-amd64",
+    binaryName: "fastmoss-linux-amd64",
+    buildPath: "linux-amd64/fastmoss",
+    os: "linux",
+    cpu: "x64",
+  }),
+  "linux:arm64": Object.freeze({
+    packageName: "@fastmoss/cli-linux-arm64",
+    packageDir: "cli-linux-arm64",
+    assetName: "fastmoss-linux-arm64",
+    binaryName: "fastmoss-linux-arm64",
+    buildPath: "linux-arm64/fastmoss",
+    os: "linux",
+    cpu: "arm64",
+  }),
+  "win32:x64": Object.freeze({
+    packageName: "@fastmoss/cli-windows-amd64",
+    packageDir: "cli-windows-amd64",
+    assetName: "fastmoss-windows-amd64.exe",
+    binaryName: "fastmoss-windows-amd64.exe",
+    buildPath: "windows-amd64/fastmoss.exe",
+    os: "win32",
+    cpu: "x64",
+  }),
+});
+
+function resolvePlatformTarget({
+  platform = process.platform,
+  arch = process.arch,
+} = {}) {
+  const target = PLATFORM_TARGETS[`${platform}:${arch}`];
+  if (!target) {
+    const supported = Object.keys(PLATFORM_TARGETS)
+      .map((key) => key.replace(":", "/"))
+      .join(", ");
+    throw new Error(
+      `Unsupported platform: ${platform}/${arch}. Supported targets: ${supported}`,
+    );
+  }
+  return target;
+}
+
+module.exports = { PLATFORM_TARGETS, resolvePlatformTarget };

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "@fastmoss/cli",
-  "version": "0.1.5",
-  "description": "FastMoss CLI launcher for npm and npx",
+  "version": "0.1.13",
+  "description": "FastMoss CLI for npm and npx",
   "license": "UNLICENSED",
   "private": false,
   "bin": {
-    "fastmoss": "bin/fastmoss.js",
-    "fastmoss-install-skill": "bin/install-skill.js"
+    "fastmoss": "bin/fastmoss.js"
   },
   "files": [
     "bin",
     "lib",
-    "skills",
     "README.md",
     "README.zh-CN.md"
   ],
   "scripts": {
-    "postinstall": "node ./bin/postinstall.js",
     "test": "node --test ./test/*.test.js"
   },
+  "optionalDependencies": {
+    "@fastmoss/cli-darwin-amd64": "0.1.13",
+    "@fastmoss/cli-darwin-arm64": "0.1.13",
+    "@fastmoss/cli-linux-amd64": "0.1.13",
+    "@fastmoss/cli-linux-arm64": "0.1.13",
+    "@fastmoss/cli-windows-amd64": "0.1.13"
+  },
   "engines": {
     "node": ">=18"
-  },
-  "fastmoss": {
-    "downloadBaseURL": "https://github.com/FastMoss/cli/releases/download"
   }
 }

package/bin/install-skill.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-
-const path = require("node:path");
-const {
-  INSTALL_SKILL_USAGE,
-  installSkill,
-  parseInstallSkillArgs,
-} = require("../lib/runtime");
-
-async function main() {
-  let options;
-  try {
-    options = parseInstallSkillArgs(process.argv.slice(2));
-  } catch (error) {
-    process.stderr.write(`${error.message}\n\n${INSTALL_SKILL_USAGE}`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (options.help) {
-    process.stdout.write(INSTALL_SKILL_USAGE);
-    return;
-  }
-
-  await installSkill({
-    packageRoot: path.join(__dirname, ".."),
-    agent: options.agent,
-  });
-}
-
-main().catch((error) => {
-  process.stderr.write(`fastmoss-install-skill error: ${error.message}\n`);
-  process.exitCode = 1;
-});

package/bin/postinstall.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-
-const packageJSON = require("../package.json");
-const { installCLI } = require("../lib/runtime");
-
-installCLI({
-  version: packageJSON.version,
-  configuredDownloadBaseURL: packageJSON.fastmoss?.downloadBaseURL,
-}).catch((error) => {
-  process.stderr.write(`fastmoss postinstall warning: ${error.message}\n`);
-  process.stderr.write("The binary will be downloaded on first run.\n");
-});