@sh-renjian/sw 0.1.0-rc.2 → 0.1.0-rc.3

package/README.md

@@ -1,6 +1,12 @@
 # @sh-renjian/sw
 
-`@sh-renjian/sw` 是 `sw` CLI 的 npm 入口包。
+`@sh-renjian/sw` 是 `sw` CLI 的统一 npm 入口包。
+
+它提供三类命令入口：
+
+- `sw toolchain ...`：安装或检查本地官方 Worker toolchain（`wrangler`、`create-cloudflare`）。
+- `sw worker ...`：委托官方 Worker 生命周期命令。
+- `sw platform ...`：调用 sansi 自部署平台控制面。
 
 安装后会按当前平台自动选择对应的预编译二进制：
 
@@ -13,6 +19,12 @@ npx @sh-renjian/sw --version
 ```sh
 npm install -g @sh-renjian/sw
 sw --version
+sw toolchain doctor
 ```
 
+补充说明：
+
+- `sw toolchain ...` / `sw worker ...` 当前委托官方 `wrangler@4.x` 与 `create-cloudflare@2.x`，实测要求 `Node.js >= 22.0.0`，仓库验证版本为 `22.22.1`。
+- `sw toolchain install` 会在安装后继续验证 `wrangler`、`create-cloudflare` 是否能在当前 Node 环境下启动；如果只是下载成功但不可执行，命令会直接失败。
+
 支持的平台以发布说明为准。

package/bin/sw.js

@@ -1,20 +1,11 @@
 #!/usr/bin/env node
 
-import { spawnSync } from "node:child_process";
-
-import { installedBinaryPath } from "../lib/platform.mjs";
+import { runCli } from "../lib/cli.mjs";
 
 try {
-  const binaryPath = installedBinaryPath();
-  const result = spawnSync(binaryPath, process.argv.slice(2), {
-    stdio: "inherit"
-  });
-  if (result.error) {
-    throw result.error;
-  }
-  process.exit(result.status ?? 1);
+  process.exit(runCli(process.argv.slice(2)));
 } catch (error) {
   const detail = error instanceof Error ? error.message : String(error);
-  console.error(`Unable to locate the installed @sh-renjian/sw binary for ${process.platform}/${process.arch}: ${detail}`);
+  console.error(`sw CLI failed: ${detail}`);
   process.exit(1);
 }

package/lib/cli.mjs

@@ -0,0 +1,403 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import { installedBinaryPath } from "./platform.mjs";
+
+const PLATFORM_ALIASES = new Set([
+  "login",
+  "auth",
+  "logout",
+  "deploy",
+  "workers",
+  "deployments",
+  "tail",
+  "d1",
+  "r2",
+  "bindings",
+  "version",
+  "--version",
+  "-v",
+]);
+
+const DEFAULT_WRANGLER_VERSION = "latest";
+const DEFAULT_CREATE_CLOUDFLARE_VERSION = "latest";
+
+function commandFileName(command, platform = process.platform) {
+  return platform === "win32" ? `${command}.cmd` : command;
+}
+
+function parseSharedFlags(argv) {
+  let cwd = process.cwd();
+  const forwardedArgs = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === "--") {
+      forwardedArgs.push(...argv.slice(index + 1));
+      break;
+    }
+    if (value === "--cwd") {
+      const next = argv[index + 1];
+      if (next == null) {
+        throw new Error("--cwd requires a value");
+      }
+      cwd = path.resolve(next);
+      index += 1;
+      continue;
+    }
+    forwardedArgs.push(value);
+  }
+  return { cwd, forwardedArgs };
+}
+
+function parseToolchainFlags(argv) {
+  const options = {
+    json: false,
+    cwd: process.cwd(),
+    wranglerVersion: DEFAULT_WRANGLER_VERSION,
+    createCloudflareVersion: DEFAULT_CREATE_CLOUDFLARE_VERSION,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index];
+    switch (value) {
+      case "--json":
+        options.json = true;
+        break;
+      case "--cwd":
+        if (argv[index + 1] == null) {
+          throw new Error("--cwd requires a value");
+        }
+        options.cwd = path.resolve(argv[index + 1]);
+        index += 1;
+        break;
+      case "--wrangler-version":
+        if (argv[index + 1] == null) {
+          throw new Error("--wrangler-version requires a value");
+        }
+        options.wranglerVersion = argv[index + 1];
+        index += 1;
+        break;
+      case "--create-cloudflare-version":
+        if (argv[index + 1] == null) {
+          throw new Error("--create-cloudflare-version requires a value");
+        }
+        options.createCloudflareVersion = argv[index + 1];
+        index += 1;
+        break;
+      default:
+        throw new Error(`unknown flag ${value}`);
+    }
+  }
+  return options;
+}
+
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function projectBinaryPath(command, cwd, platform = process.platform) {
+  return path.join(cwd, "node_modules", ".bin", commandFileName(command, platform));
+}
+
+function toolchainBinaryPath(command, rootDir, platform = process.platform) {
+  return path.join(rootDir, "node_modules", ".bin", commandFileName(command, platform));
+}
+
+function missingToolchainExecutables(rootDir) {
+  const requiredCommands = ["wrangler", "create-cloudflare"];
+  return requiredCommands.filter((command) => !isExecutable(toolchainBinaryPath(command, rootDir)));
+}
+
+function unusableToolchainExecutables(rootDir) {
+  const requiredCommands = ["wrangler", "create-cloudflare"];
+  return requiredCommands.filter((command) => {
+    const executablePath = toolchainBinaryPath(command, rootDir);
+    return runCommand(executablePath, ["--help"], { stdio: "pipe" }) !== 0;
+  });
+}
+
+function resolveInstalledToolchainCommand(command, rootDir) {
+  const toolchainPath = toolchainBinaryPath(command, rootDir);
+  if (isExecutable(toolchainPath)) {
+    return { command: toolchainPath, source: "sw-toolchain", path: toolchainPath };
+  }
+  return { command: null, source: "missing", path: toolchainPath };
+}
+
+function resolveToolCommand(command, cwd, rootDir) {
+  const projectPath = projectBinaryPath(command, cwd);
+  if (isExecutable(projectPath)) {
+    return { command: projectPath, source: "project-local", path: projectPath };
+  }
+  const toolchainPath = toolchainBinaryPath(command, rootDir);
+  if (isExecutable(toolchainPath)) {
+    return { command: toolchainPath, source: "sw-toolchain", path: toolchainPath };
+  }
+  return { command: null, source: "missing", path: toolchainPath };
+}
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? process.cwd(),
+    stdio: options.stdio ?? "inherit",
+    env: { ...process.env, ...(options.env ?? {}) },
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return result.status ?? 1;
+}
+
+function printUsage(body) {
+  process.stdout.write(`${body.trim()}\n`);
+  return 0;
+}
+
+function globalUsage() {
+  return `
+Usage: sw <namespace|platform-command> [options]
+
+Namespaces:
+  worker      Delegate Worker project lifecycle to official create-cloudflare / wrangler
+  toolchain   Install or inspect the local official toolchain used by sw
+  platform    Talk to sansi Worker Platform Server
+
+Platform command compatibility aliases:
+  login auth logout deploy workers deployments tail d1 r2 bindings version
+`;
+}
+
+function workerUsage() {
+  return `
+Usage: sw worker <command> [options]
+
+Commands:
+  init
+  dev
+  deploy [cloudflare]
+  d1
+  r2
+  versions
+  setup
+  tail
+
+Shared flags:
+  --cwd <project-dir>
+  -- <extra flags passed through to the official tool>
+`;
+}
+
+function toolchainUsage() {
+  return `
+Usage: sw toolchain <command> [options]
+
+Commands:
+  install
+  doctor
+`;
+}
+
+function printJSON(value) {
+  process.stdout.write(`${JSON.stringify(value)}\n`);
+  return 0;
+}
+
+function printToolchainStatus(status, json = false) {
+  if (json) {
+    return printJSON({ ok: true, ...status });
+  }
+  process.stdout.write(
+    [
+      `toolchainRoot: ${status.toolchainRoot}`,
+      `wrangler: ${status.wrangler.source}${status.wrangler.path ? ` (${status.wrangler.path})` : ""}`,
+      `create-cloudflare: ${status.createCloudflare.source}${status.createCloudflare.path ? ` (${status.createCloudflare.path})` : ""}`,
+      `node: ${status.node.version}`,
+    ].join("\n") + "\n",
+  );
+  return 0;
+}
+
+function toolchainStatus(cwd, rootDir) {
+  return {
+    toolchainRoot: rootDir,
+    node: {
+      version: process.version,
+      executable: process.execPath,
+    },
+    wrangler: resolveToolCommand("wrangler", cwd, rootDir),
+    createCloudflare: resolveToolCommand("create-cloudflare", cwd, rootDir),
+  };
+}
+
+function installedToolchainStatus(rootDir) {
+  return {
+    toolchainRoot: rootDir,
+    node: {
+      version: process.version,
+      executable: process.execPath,
+    },
+    wrangler: resolveInstalledToolchainCommand("wrangler", rootDir),
+    createCloudflare: resolveInstalledToolchainCommand("create-cloudflare", rootDir),
+  };
+}
+
+function runToolchainInstall(args) {
+  const options = parseToolchainFlags(args);
+  const rootDir = toolchainRootDir();
+  fs.mkdirSync(rootDir, { recursive: true });
+  const status = runCommand("npm", [
+    "install",
+    "--no-save",
+    "--prefix",
+    rootDir,
+    `wrangler@${options.wranglerVersion}`,
+    `create-cloudflare@${options.createCloudflareVersion}`,
+  ]);
+  if (status !== 0) {
+    return status;
+  }
+  const missing = missingToolchainExecutables(rootDir);
+  if (missing.length > 0) {
+    process.stderr.write(
+      `toolchain install did not produce required executables: ${missing.join(", ")}\n`,
+    );
+    return 1;
+  }
+  const unusable = unusableToolchainExecutables(rootDir);
+  if (unusable.length > 0) {
+    process.stderr.write(
+      `toolchain install verification failed: ${unusable.join(", ")}\n`,
+    );
+    return 1;
+  }
+  return printToolchainStatus(installedToolchainStatus(rootDir), options.json);
+}
+
+function runToolchainDoctor(args) {
+  const options = parseToolchainFlags(args);
+  return printToolchainStatus(toolchainStatus(options.cwd, toolchainRootDir()), options.json);
+}
+
+function runToolchainCommand(args) {
+  if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+    return printUsage(toolchainUsage());
+  }
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case "install":
+      return runToolchainInstall(rest);
+    case "doctor":
+      return runToolchainDoctor(rest);
+    default:
+      process.stderr.write(`unknown sw toolchain command: ${subcommand}\n`);
+      return 1;
+  }
+}
+
+function runWorkerCommand(args) {
+  if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+    return printUsage(workerUsage());
+  }
+  const { cwd, forwardedArgs } = parseSharedFlags(args);
+  if (forwardedArgs.length === 0) {
+    return printUsage(workerUsage());
+  }
+  if (forwardedArgs[0] === "package" && forwardedArgs[1] === "platform") {
+    process.stderr.write("sw worker package platform is not implemented yet\n");
+    return 1;
+  }
+
+  let commandName = "wrangler";
+  let childArgs = [...forwardedArgs];
+  if (forwardedArgs[0] === "init") {
+    commandName = "create-cloudflare";
+    childArgs = forwardedArgs.slice(1);
+  } else if (forwardedArgs[0] === "deploy" && forwardedArgs[1] === "cloudflare") {
+    childArgs = [forwardedArgs[0], ...forwardedArgs.slice(2)];
+  }
+
+  const resolved = resolveToolCommand(commandName, cwd, toolchainRootDir());
+  if (!resolved.command) {
+    process.stderr.write(
+      `missing ${commandName} toolchain; run "sw toolchain install" or install it in ${cwd}\n`,
+    );
+    return 1;
+  }
+  return runCommand(resolved.command, childArgs, { cwd });
+}
+
+function runPlatformCommand(args) {
+  const binaryPath = installedBinaryPath();
+  return runCommand(binaryPath, args);
+}
+
+export function classifyCommand(argv) {
+  if (argv.length === 0) {
+    return { kind: "help", forwardedArgs: [], compatAlias: false };
+  }
+  if (argv[0] === "platform") {
+    return {
+      kind: "platform",
+      forwardedArgs: argv.slice(1),
+      compatAlias: false,
+    };
+  }
+  if (argv[0] === "worker") {
+    return {
+      kind: "worker",
+      forwardedArgs: argv.slice(1),
+      compatAlias: false,
+    };
+  }
+  if (argv[0] === "toolchain") {
+    return {
+      kind: "toolchain",
+      forwardedArgs: argv.slice(1),
+      compatAlias: false,
+    };
+  }
+  if (PLATFORM_ALIASES.has(argv[0])) {
+    return {
+      kind: "platform",
+      forwardedArgs: argv,
+      compatAlias: true,
+    };
+  }
+  return {
+    kind: "unknown",
+    forwardedArgs: argv,
+    compatAlias: false,
+  };
+}
+
+export function toolchainRootDir(env = process.env) {
+  const home = env.HOME?.trim() || os.homedir();
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || path.join(home, ".config");
+  return path.join(configRoot, "sansi-worker", "sw", "toolchain");
+}
+
+export function runCli(argv = process.argv.slice(2)) {
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+    return printUsage(globalUsage());
+  }
+
+  const classification = classifyCommand(argv);
+  switch (classification.kind) {
+    case "platform":
+      return runPlatformCommand(classification.forwardedArgs.length > 0 ? classification.forwardedArgs : ["--help"]);
+    case "worker":
+      return runWorkerCommand(classification.forwardedArgs);
+    case "toolchain":
+      return runToolchainCommand(classification.forwardedArgs);
+    default:
+      process.stderr.write(`unknown sw command: ${argv[0]}\n`);
+      process.stderr.write("run `sw --help` to see the unified command model\n");
+      return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sh-renjian/sw",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.3",
   "description": "sansi Worker Platform CLI entry package",
   "license": "UNLICENSED",
   "repository": {
@@ -25,10 +25,10 @@
     "sh-renjian-sw": "bin/sw.js"
   },
   "optionalDependencies": {
-    "@sh-renjian/sw-darwin-arm64": "0.1.0-rc.2",
-    "@sh-renjian/sw-darwin-x64": "0.1.0-rc.2",
-    "@sh-renjian/sw-linux-arm64": "0.1.0-rc.2",
-    "@sh-renjian/sw-linux-x64": "0.1.0-rc.2",
-    "@sh-renjian/sw-win32-x64": "0.1.0-rc.2"
+    "@sh-renjian/sw-darwin-arm64": "0.1.0-rc.3",
+    "@sh-renjian/sw-darwin-x64": "0.1.0-rc.3",
+    "@sh-renjian/sw-linux-arm64": "0.1.0-rc.3",
+    "@sh-renjian/sw-linux-x64": "0.1.0-rc.3",
+    "@sh-renjian/sw-win32-x64": "0.1.0-rc.3"
   }
 }