maactl 0.1.0 → 0.1.2

package/lib/cli.js

@@ -1,136 +1,136 @@
-'use strict';
-
-// Thin launcher: hand every argument over to maactl.exe untouched, inherit the
-// stdio of the calling shell, and relay the exit status back to npm/npx.
-
-const { spawn } = require('node:child_process');
-
-const { resolveBinary, ensureBinary, verbose } = require('./binary');
-const env = require('./env');
-const { MaactlError } = require('./errors');
-const messages = require('./messages');
-
-// Signals worth relaying on POSIX hosts. On Windows the console broadcasts
-// Ctrl+C to the whole process group, so the Go process receives it directly.
-const POSIX_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];
-
-function describeSpawnError(file, error) {
-  const reason = error && error.message ? error.message : String(error);
-  return new MaactlError(messages.text('spawnFailed', file, reason), { cause: error });
-}
-
-/**
- * Run `exe` with `argv`, inheriting stdio.
- *
- * Resolves with the numeric exit code of the child. When the child is killed
- * by a signal on POSIX the shim re-raises that signal so the caller sees the
- * same failure it would have seen without the wrapper.
- */
-function runBinary(exe, argv, options = {}) {
-  const spawnImpl = options.spawn || spawn;
-  const proc = options.process || process;
-  const platform = options.platform || process.platform;
-  const child = spawnImpl(exe, argv, {
-    stdio: options.stdio || 'inherit',
-    cwd: options.cwd || process.cwd(),
-    env: options.env || process.env,
-    windowsHide: false,
-  });
-
-  return new Promise((resolve, reject) => {
-    const listeners = [];
-    const cleanup = () => {
-      for (const [signal, handler] of listeners) {
-        proc.removeListener(signal, handler);
-      }
-      listeners.length = 0;
-    };
-
-    child.once('error', (error) => {
-      cleanup();
-      reject(describeSpawnError(exe, error));
-    });
-    child.once('exit', (code, signal) => {
-      cleanup();
-      if (signal) {
-        try {
-          proc.kill(proc.pid, signal);
-        } catch {
-          // Re-raising is a courtesy; fall through to a generic failure code.
-        }
-        resolve(1);
-        return;
-      }
-      resolve(code === null || code === undefined ? 1 : code);
-    });
-
-    const forward = (signal) => {
-      if (child.exitCode !== null || child.signalCode !== null) {
-        return;
-      }
-      try {
-        child.kill(signal);
-      } catch {
-        // The child already exited; its exit handler reports the status.
-      }
-    };
-
-    if (platform === 'win32') {
-      // Windows has no POSIX signals: the console broadcasts Ctrl+C/Ctrl+Break
-      // to the whole process group, so maactl.exe already received it. Swallowing
-      // the first signal keeps the shim alive long enough to report the child's
-      // exit code; a second Ctrl+C falls back to the default behaviour and kills
-      // the shim, which is the escape hatch when the child will not stop.
-      const swallowOnce = () => cleanup();
-      for (const signal of ['SIGINT', 'SIGBREAK']) {
-        try {
-          proc.on(signal, swallowOnce);
-          listeners.push([signal, swallowOnce]);
-        } catch {
-          // Signal not supported on this platform.
-        }
-      }
-    } else {
-      for (const signal of POSIX_SIGNALS) {
-        const handler = () => forward(signal);
-        try {
-          proc.on(signal, handler);
-          listeners.push([signal, handler]);
-        } catch {
-          // Signal not supported on this platform.
-        }
-      }
-    }
-  });
-}
-
-/**
- * Resolve (downloading once if needed) and run maactl.exe with `argv`.
- *
- * `argv` is forwarded verbatim, so `npx maactl run task "自动挂机卖蛋" -f D:\proj`
- * reaches the executable exactly as typed.
- */
-async function main(argv = process.argv.slice(2), options = {}) {
-  const write = options.write || ((line) => process.stderr.write(`${line}\n`));
-  const resolve = options.resolveBinary || resolveBinary;
-  const ensure = options.ensureBinary || ensureBinary;
-  const quiet = options.quiet ?? env.flag('MAACTL_QUIET');
-
-  let exe = options.binary || (await resolve());
-  if (!exe) {
-    try {
-      exe = await ensure({ write, quiet });
-    } catch (error) {
-      const detail = error instanceof MaactlError ? error.message : String(error && error.message);
-      throw new MaactlError(`${detail}\n${messages.text('resolveHint')}`, { cause: error });
-    }
-  }
-
-  if (verbose() && !options.binary) {
-    write(messages.text('usingBinary', exe));
-  }
-
-  return runBinary(exe, argv, options);
-}
-
-module.exports = { main, runBinary };
+'use strict';
+
+// Thin launcher: hand every argument over to maactl.exe untouched, inherit the
+// stdio of the calling shell, and relay the exit status back to npm/npx.
+
+const { spawn } = require('node:child_process');
+
+const { resolveBinary, ensureBinary, verbose } = require('./binary');
+const env = require('./env');
+const { MaactlError } = require('./errors');
+const messages = require('./messages');
+
+// Signals worth relaying on POSIX hosts. On Windows the console broadcasts
+// Ctrl+C to the whole process group, so the Go process receives it directly.
+const POSIX_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];
+
+function describeSpawnError(file, error) {
+  const reason = error && error.message ? error.message : String(error);
+  return new MaactlError(messages.text('spawnFailed', file, reason), { cause: error });
+}
+
+/**
+ * Run `exe` with `argv`, inheriting stdio.
+ *
+ * Resolves with the numeric exit code of the child. When the child is killed
+ * by a signal on POSIX the shim re-raises that signal so the caller sees the
+ * same failure it would have seen without the wrapper.
+ */
+function runBinary(exe, argv, options = {}) {
+  const spawnImpl = options.spawn || spawn;
+  const proc = options.process || process;
+  const platform = options.platform || process.platform;
+  const child = spawnImpl(exe, argv, {
+    stdio: options.stdio || 'inherit',
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env,
+    windowsHide: false,
+  });
+
+  return new Promise((resolve, reject) => {
+    const listeners = [];
+    const cleanup = () => {
+      for (const [signal, handler] of listeners) {
+        proc.removeListener(signal, handler);
+      }
+      listeners.length = 0;
+    };
+
+    child.once('error', (error) => {
+      cleanup();
+      reject(describeSpawnError(exe, error));
+    });
+    child.once('exit', (code, signal) => {
+      cleanup();
+      if (signal) {
+        try {
+          proc.kill(proc.pid, signal);
+        } catch {
+          // Re-raising is a courtesy; fall through to a generic failure code.
+        }
+        resolve(1);
+        return;
+      }
+      resolve(code === null || code === undefined ? 1 : code);
+    });
+
+    const forward = (signal) => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        return;
+      }
+      try {
+        child.kill(signal);
+      } catch {
+        // The child already exited; its exit handler reports the status.
+      }
+    };
+
+    if (platform === 'win32') {
+      // Windows has no POSIX signals: the console broadcasts Ctrl+C/Ctrl+Break
+      // to the whole process group, so maactl.exe already received it. Swallowing
+      // the first signal keeps the shim alive long enough to report the child's
+      // exit code; a second Ctrl+C falls back to the default behaviour and kills
+      // the shim, which is the escape hatch when the child will not stop.
+      const swallowOnce = () => cleanup();
+      for (const signal of ['SIGINT', 'SIGBREAK']) {
+        try {
+          proc.on(signal, swallowOnce);
+          listeners.push([signal, swallowOnce]);
+        } catch {
+          // Signal not supported on this platform.
+        }
+      }
+    } else {
+      for (const signal of POSIX_SIGNALS) {
+        const handler = () => forward(signal);
+        try {
+          proc.on(signal, handler);
+          listeners.push([signal, handler]);
+        } catch {
+          // Signal not supported on this platform.
+        }
+      }
+    }
+  });
+}
+
+/**
+ * Resolve (downloading once if needed) and run maactl.exe with `argv`.
+ *
+ * `argv` is forwarded verbatim, so `npx maactl run task "自动挂机卖蛋" -f D:\proj`
+ * reaches the executable exactly as typed.
+ */
+async function main(argv = process.argv.slice(2), options = {}) {
+  const write = options.write || ((line) => process.stderr.write(`${line}\n`));
+  const resolve = options.resolveBinary || resolveBinary;
+  const ensure = options.ensureBinary || ensureBinary;
+  const quiet = options.quiet ?? env.flag('MAACTL_QUIET');
+
+  let exe = options.binary || (await resolve());
+  if (!exe) {
+    try {
+      exe = await ensure({ write, quiet });
+    } catch (error) {
+      const detail = error instanceof MaactlError ? error.message : String(error && error.message);
+      throw new MaactlError(`${detail}\n${messages.text('resolveHint')}`, { cause: error });
+    }
+  }
+
+  if (verbose() && !options.binary) {
+    write(messages.text('usingBinary', exe));
+  }
+
+  return runBinary(exe, argv, options);
+}
+
+module.exports = { main, runBinary };

package/lib/download.js

@@ -1,188 +1,188 @@
-'use strict';
-
-// Minimal HTTPS downloader for the maactl.exe release asset.
-//
-// Node built-ins only: the npm package ships no runtime dependencies. GitHub
-// release downloads answer with a 302 to objects.githubusercontent.com, so
-// redirects are followed manually and the Authorization header (when a
-// GH_TOKEN is provided to dodge rate limits) is dropped on cross-host hops.
-
-const fs = require('node:fs');
-const http = require('node:http');
-const https = require('node:https');
-
-const MAX_REDIRECTS = 5;
-const REQUEST_TIMEOUT_MS = 60_000;
-// A slow-but-alive transfer is fine; a silent socket is not. If no bytes arrive
-// for this long the download is aborted with a readable error.
-const STALL_TIMEOUT_MS = 120_000;
-
-const REDIRECT_CODES = new Set([301, 302, 303, 307, 308]);
-
-function userAgent() {
-  const pkg = require('../package.json');
-  return `maactl-npm/${pkg.version} (node/${process.versions.node}; ${process.platform})`;
-}
-
-function githubToken() {
-  return (process.env.GH_TOKEN || process.env.GITHUB_TOKEN || '').trim();
-}
-
-function baseHeaders(url) {
-  const headers = {
-    'user-agent': userAgent(),
-    accept: 'application/octet-stream',
-  };
-  const token = githubToken();
-  if (token && /(^|\.)github\.com$/i.test(new URL(url).hostname)) {
-    headers.authorization = `Bearer ${token}`;
-  }
-  return headers;
-}
-
-function requestOnce(url, headers) {
-  return new Promise((resolve, reject) => {
-    const target = new URL(url);
-    const transport = target.protocol === 'http:' ? http : https;
-    const request = transport.get(target, { headers, timeout: REQUEST_TIMEOUT_MS }, (response) => {
-      response.setTimeout(STALL_TIMEOUT_MS);
-      response.on('timeout', () => {
-        response.destroy(new Error(`no data received for ${STALL_TIMEOUT_MS} ms`));
-      });
-      resolve(response);
-    });
-    request.on('timeout', () => request.destroy(new Error(`request timed out after ${REQUEST_TIMEOUT_MS} ms`)));
-    request.on('error', reject);
-  });
-}
-
-function writeBody(response, dest, onProgress) {
-  return new Promise((resolve, reject) => {
-    const total = Number(response.headers['content-length'] || 0);
-    let received = 0;
-    let finished = false;
-    const settle = (fn, value) => {
-      if (!finished) {
-        finished = true;
-        fn(value);
-      }
-    };
-    const output = fs.createWriteStream(dest);
-
-    response.on('data', (chunk) => {
-      received += chunk.length;
-      if (onProgress) {
-        onProgress(received, total);
-      }
-    });
-    response.on('error', (error) => settle(reject, error));
-    output.on('error', (error) => settle(reject, error));
-    output.on('finish', () => {
-      if (total > 0 && received !== total) {
-        settle(reject, new Error(`truncated download: received ${received} of ${total} bytes`));
-        return;
-      }
-      settle(resolve, received);
-    });
-    response.pipe(output);
-  });
-}
-
-/**
- * Download `url` into `dest` (written to `dest.part` first, renamed on
- * success). `onProgress(received, total)` is called for every chunk.
- */
-async function download(url, dest, { onProgress } = {}) {
-  const partial = `${dest}.part`;
-  const headers = baseHeaders(url);
-  let current = url;
-
-  try {
-    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
-      const response = await requestOnce(current, headers);
-      const status = response.statusCode || 0;
-
-      if (REDIRECT_CODES.has(status)) {
-        const location = response.headers.location;
-        response.resume();
-        if (!location) {
-          throw new Error(`HTTP ${status} without a Location header`);
-        }
-        const next = new URL(location, current);
-        if (next.hostname !== new URL(current).hostname) {
-          delete headers.authorization;
-        }
-        current = next.href;
-        continue;
-      }
-
-      if (status !== 200) {
-        response.resume();
-        throw new Error(`HTTP ${status} ${response.statusMessage || ''}`.trim());
-      }
-
-      await writeBody(response, partial, onProgress);
-      fs.renameSync(partial, dest);
-      return dest;
-    }
-    throw new Error(`too many redirects (limit ${MAX_REDIRECTS})`);
-  } catch (error) {
-    try {
-      fs.rmSync(partial, { force: true });
-    } catch {
-      // Best effort: a stale .part file only costs disk space.
-    }
-    throw error;
-  }
-}
-
-/** Try `download` up to `attempts` times, backing off between attempts. */
-async function downloadWithRetry(url, dest, options = {}) {
-  const attempts = options.attempts || 3;
-  const delay = options.retryDelayMs ?? 1_000;
-  let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    try {
-      return await download(url, dest, options);
-    } catch (error) {
-      lastError = error;
-      if (attempt < attempts && options.onRetry) {
-        options.onRetry(attempt, attempts, error);
-      }
-      if (attempt < attempts) {
-        await new Promise((resolve) => setTimeout(resolve, delay * attempt));
-      }
-    }
-  }
-  throw lastError;
-}
-
-/** Human readable byte count, e.g. 34.2 MiB. */
-function formatBytes(bytes) {
-  if (!Number.isFinite(bytes) || bytes <= 0) {
-    return '0 B';
-  }
-  const units = ['B', 'KiB', 'MiB', 'GiB'];
-  let value = bytes;
-  let unit = 0;
-  while (value >= 1024 && unit < units.length - 1) {
-    value /= 1024;
-    unit += 1;
-  }
-  return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
-}
-
-/** Render a single-line progress indicator to stderr. */
-function progressReporter(stream = process.stderr) {
-  let lastLength = 0;
-  return (received, total) => {
-    const line = total > 0
-      ? `  ${formatBytes(received)} / ${formatBytes(total)} (${Math.floor((received / total) * 100)}%)`
-      : `  ${formatBytes(received)}`;
-    const padding = ' '.repeat(Math.max(0, lastLength - line.length));
-    lastLength = line.length;
-    stream.write(`\r${line}${padding}`);
-  };
-}
-
-module.exports = { download, downloadWithRetry, formatBytes, progressReporter, userAgent };
+'use strict';
+
+// Minimal HTTPS downloader for the maactl.exe release asset.
+//
+// Node built-ins only: the npm package ships no runtime dependencies. GitHub
+// release downloads answer with a 302 to objects.githubusercontent.com, so
+// redirects are followed manually and the Authorization header (when a
+// GH_TOKEN is provided to dodge rate limits) is dropped on cross-host hops.
+
+const fs = require('node:fs');
+const http = require('node:http');
+const https = require('node:https');
+
+const MAX_REDIRECTS = 5;
+const REQUEST_TIMEOUT_MS = 60_000;
+// A slow-but-alive transfer is fine; a silent socket is not. If no bytes arrive
+// for this long the download is aborted with a readable error.
+const STALL_TIMEOUT_MS = 120_000;
+
+const REDIRECT_CODES = new Set([301, 302, 303, 307, 308]);
+
+function userAgent() {
+  const pkg = require('../package.json');
+  return `maactl-npm/${pkg.version} (node/${process.versions.node}; ${process.platform})`;
+}
+
+function githubToken() {
+  return (process.env.GH_TOKEN || process.env.GITHUB_TOKEN || '').trim();
+}
+
+function baseHeaders(url) {
+  const headers = {
+    'user-agent': userAgent(),
+    accept: 'application/octet-stream',
+  };
+  const token = githubToken();
+  if (token && /(^|\.)github\.com$/i.test(new URL(url).hostname)) {
+    headers.authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+
+function requestOnce(url, headers) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(url);
+    const transport = target.protocol === 'http:' ? http : https;
+    const request = transport.get(target, { headers, timeout: REQUEST_TIMEOUT_MS }, (response) => {
+      response.setTimeout(STALL_TIMEOUT_MS);
+      response.on('timeout', () => {
+        response.destroy(new Error(`no data received for ${STALL_TIMEOUT_MS} ms`));
+      });
+      resolve(response);
+    });
+    request.on('timeout', () => request.destroy(new Error(`request timed out after ${REQUEST_TIMEOUT_MS} ms`)));
+    request.on('error', reject);
+  });
+}
+
+function writeBody(response, dest, onProgress) {
+  return new Promise((resolve, reject) => {
+    const total = Number(response.headers['content-length'] || 0);
+    let received = 0;
+    let finished = false;
+    const settle = (fn, value) => {
+      if (!finished) {
+        finished = true;
+        fn(value);
+      }
+    };
+    const output = fs.createWriteStream(dest);
+
+    response.on('data', (chunk) => {
+      received += chunk.length;
+      if (onProgress) {
+        onProgress(received, total);
+      }
+    });
+    response.on('error', (error) => settle(reject, error));
+    output.on('error', (error) => settle(reject, error));
+    output.on('finish', () => {
+      if (total > 0 && received !== total) {
+        settle(reject, new Error(`truncated download: received ${received} of ${total} bytes`));
+        return;
+      }
+      settle(resolve, received);
+    });
+    response.pipe(output);
+  });
+}
+
+/**
+ * Download `url` into `dest` (written to `dest.part` first, renamed on
+ * success). `onProgress(received, total)` is called for every chunk.
+ */
+async function download(url, dest, { onProgress } = {}) {
+  const partial = `${dest}.part`;
+  const headers = baseHeaders(url);
+  let current = url;
+
+  try {
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+      const response = await requestOnce(current, headers);
+      const status = response.statusCode || 0;
+
+      if (REDIRECT_CODES.has(status)) {
+        const location = response.headers.location;
+        response.resume();
+        if (!location) {
+          throw new Error(`HTTP ${status} without a Location header`);
+        }
+        const next = new URL(location, current);
+        if (next.hostname !== new URL(current).hostname) {
+          delete headers.authorization;
+        }
+        current = next.href;
+        continue;
+      }
+
+      if (status !== 200) {
+        response.resume();
+        throw new Error(`HTTP ${status} ${response.statusMessage || ''}`.trim());
+      }
+
+      await writeBody(response, partial, onProgress);
+      fs.renameSync(partial, dest);
+      return dest;
+    }
+    throw new Error(`too many redirects (limit ${MAX_REDIRECTS})`);
+  } catch (error) {
+    try {
+      fs.rmSync(partial, { force: true });
+    } catch {
+      // Best effort: a stale .part file only costs disk space.
+    }
+    throw error;
+  }
+}
+
+/** Try `download` up to `attempts` times, backing off between attempts. */
+async function downloadWithRetry(url, dest, options = {}) {
+  const attempts = options.attempts || 3;
+  const delay = options.retryDelayMs ?? 1_000;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      return await download(url, dest, options);
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts && options.onRetry) {
+        options.onRetry(attempt, attempts, error);
+      }
+      if (attempt < attempts) {
+        await new Promise((resolve) => setTimeout(resolve, delay * attempt));
+      }
+    }
+  }
+  throw lastError;
+}
+
+/** Human readable byte count, e.g. 34.2 MiB. */
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    return '0 B';
+  }
+  const units = ['B', 'KiB', 'MiB', 'GiB'];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+
+/** Render a single-line progress indicator to stderr. */
+function progressReporter(stream = process.stderr) {
+  let lastLength = 0;
+  return (received, total) => {
+    const line = total > 0
+      ? `  ${formatBytes(received)} / ${formatBytes(total)} (${Math.floor((received / total) * 100)}%)`
+      : `  ${formatBytes(received)}`;
+    const padding = ' '.repeat(Math.max(0, lastLength - line.length));
+    lastLength = line.length;
+    stream.write(`\r${line}${padding}`);
+  };
+}
+
+module.exports = { download, downloadWithRetry, formatBytes, progressReporter, userAgent };