@jiayunxie/aerial 0.2.1 → 0.2.2

package/src/service/status.js

@@ -0,0 +1,296 @@
+import fs from "node:fs";
+import { apiKeyPath, githubTokenPath } from "../shared/paths.js";
+import { loadConfig } from "../shared/config.js";
+import { defaultHealthFetch, classifyHealth } from "./health.js";
+import { defaultRunCommand } from "./runner.js";
+import { isUnsupportedPlatform, serviceState } from "./platform.js";
+import {
+  aerialLogPath,
+  buildSchtasksArgs,
+  darwinWrapperPath,
+  logsDir,
+  stdioLogPath,
+  winWrapperPath,
+  wrapperLogConfig
+} from "./wrapper-render.js";
+
+function unescapeShSingleQuoted(line, prefix) {
+  if (!line.startsWith(prefix)) return undefined;
+  const rest = line.slice(prefix.length);
+  if (!rest.startsWith("'")) return undefined;
+  let i = 1;
+  let out = "";
+  while (i < rest.length) {
+    const ch = rest[i];
+    if (ch === "'") {
+      if (rest.slice(i, i + 4) === "'\\''") {
+        out += "'";
+        i += 4;
+        continue;
+      }
+      return out;
+    }
+    out += ch;
+    i += 1;
+  }
+  return undefined;
+}
+
+function unescapePsSingleQuoted(line, prefix) {
+  if (!line.startsWith(prefix)) return undefined;
+  const rest = line.slice(prefix.length);
+  if (!rest.startsWith("'")) return undefined;
+  let i = 1;
+  let out = "";
+  while (i < rest.length) {
+    const ch = rest[i];
+    if (ch === "'") {
+      if (rest[i + 1] === "'") {
+        out += "'";
+        i += 2;
+        continue;
+      }
+      return out;
+    }
+    out += ch;
+    i += 1;
+  }
+  return undefined;
+}
+
+export function parseWrapperPaths(wrapperFile) {
+  if (!wrapperFile) return { node: undefined, cli: undefined };
+  try {
+    if (!fs.existsSync(wrapperFile)) return { node: undefined, cli: undefined };
+    const data = fs.readFileSync(wrapperFile, "utf8");
+    const lines = data.split(/\r?\n/);
+    if (wrapperFile.endsWith(".sh")) {
+      let node;
+      let cli;
+      for (const line of lines) {
+        if (node === undefined) {
+          const candidate = unescapeShSingleQuoted(line, "NODE_BIN=");
+          if (candidate !== undefined) node = candidate;
+        }
+        if (cli === undefined) {
+          const candidate = unescapeShSingleQuoted(line, "CLI_ENTRY=");
+          if (candidate !== undefined) cli = candidate;
+        }
+        if (node !== undefined && cli !== undefined) break;
+      }
+      return { node, cli };
+    }
+    if (wrapperFile.endsWith(".ps1")) {
+      let node;
+      let cli;
+      for (const line of lines) {
+        if (node === undefined) {
+          const m = line.match(/^\$node\s*=\s*(.*)$/);
+          if (m) {
+            const candidate = unescapePsSingleQuoted(m[1].trim(), "");
+            if (candidate !== undefined) node = candidate;
+          }
+        }
+        if (cli === undefined) {
+          const m = line.match(/^\$cli\s*=\s*(.*)$/);
+          if (m) {
+            const candidate = unescapePsSingleQuoted(m[1].trim(), "");
+            if (candidate !== undefined) cli = candidate;
+          }
+        }
+        if (node !== undefined && cli !== undefined) break;
+      }
+      return { node, cli };
+    }
+  } catch {}
+  return { node: undefined, cli: undefined };
+}
+
+export function readWrapperNodePath(wrapperFile) {
+  return parseWrapperPaths(wrapperFile).node;
+}
+
+export const STALE_REASONS = Object.freeze({
+  WRAPPER_MISSING: "wrapper_missing",
+  WRAPPER_NODE_MISSING: "wrapper_node_missing",
+  WRAPPER_CLI_MISSING: "wrapper_cli_missing",
+  WRAPPER_LOG_CONFIG_UNPARSEABLE: "wrapper_log_config_unparseable"
+});
+
+export function wrapperBlock(state) {
+  if (!state || state.installed !== true) {
+    return { stale: false, staleReasons: [] };
+  }
+  let wrapperPath;
+  if (process.platform === "darwin") wrapperPath = darwinWrapperPath();
+  else if (process.platform === "win32") wrapperPath = winWrapperPath();
+  const wrapperFileExists = wrapperPath ? fs.existsSync(wrapperPath) : false;
+  const staleReasons = [];
+  if (!wrapperFileExists) {
+    return {
+      path: wrapperPath,
+      nodePath: undefined,
+      nodeExists: undefined,
+      cliPath: undefined,
+      cliExists: undefined,
+      logConfigParseable: undefined,
+      stale: true,
+      staleReasons: [STALE_REASONS.WRAPPER_MISSING]
+    };
+  }
+  const { node: nodePath, cli: cliPath } = parseWrapperPaths(wrapperPath);
+  const nodeExists = nodePath ? fs.existsSync(nodePath) : false;
+  const cliExists = cliPath ? fs.existsSync(cliPath) : false;
+  const logConfigParseable = parseWrapperLogValues(wrapperPath) !== null;
+  if (!nodeExists) staleReasons.push(STALE_REASONS.WRAPPER_NODE_MISSING);
+  if (!cliExists) staleReasons.push(STALE_REASONS.WRAPPER_CLI_MISSING);
+  if (!logConfigParseable) staleReasons.push(STALE_REASONS.WRAPPER_LOG_CONFIG_UNPARSEABLE);
+  return {
+    path: wrapperPath,
+    nodePath,
+    nodeExists,
+    cliPath,
+    cliExists,
+    logConfigParseable,
+    stale: staleReasons.length > 0,
+    staleReasons
+  };
+}
+
+function authFileStatus(file) {
+  if (!fs.existsSync(file)) return { file, state: "missing" };
+  try {
+    const data = fs.readFileSync(file, "utf8");
+    if (!data || !data.trim()) return { file, state: "invalid", reason: "empty" };
+    return { file, state: "present" };
+  } catch (err) {
+    return { file, state: "invalid", reason: err.message };
+  }
+}
+
+export function authBlock() {
+  return {
+    api_key: authFileStatus(apiKeyPath()),
+    github_token: authFileStatus(githubTokenPath())
+  };
+}
+
+function statFile(file) {
+  if (!file) return { exists: false };
+  try {
+    if (!fs.existsSync(file)) return { exists: false };
+    return { exists: true, size: fs.statSync(file).size };
+  } catch {
+    return { exists: false };
+  }
+}
+
+export function logsBlock() {
+  const dir = logsDir();
+  const primary = aerialLogPath();
+  const stdio = stdioLogPath();
+  let wrapperFile;
+  if (process.platform === "darwin") wrapperFile = darwinWrapperPath();
+  else if (process.platform === "win32") wrapperFile = winWrapperPath();
+  const parsed = wrapperFile ? parseWrapperLogValues(wrapperFile) : null;
+  let maxBytes;
+  let rotateKeep;
+  let source;
+  if (parsed) {
+    maxBytes = parsed.maxBytes;
+    rotateKeep = parsed.backups;
+    source = "installed-wrapper";
+  } else {
+    const cfg = wrapperLogConfig();
+    maxBytes = cfg.maxBytes;
+    rotateKeep = cfg.backups;
+    source = "next-install-default";
+  }
+  return {
+    dir,
+    primary: { file: primary, ...statFile(primary) },
+    stdio: { file: stdio, ...statFile(stdio) },
+    maxFileBytes: maxBytes,
+    rotateKeep,
+    source
+  };
+}
+
+export function parseWrapperLogValues(file) {
+  if (!file) return null;
+  try {
+    if (!fs.existsSync(file)) return null;
+    const data = fs.readFileSync(file, "utf8");
+    let maxBytes;
+    let backups;
+    if (file.endsWith(".sh")) {
+      const m = data.match(/^MAX_BYTES=(\d+)\s*$/m);
+      const b = data.match(/^BACKUPS=(\d+)\s*$/m);
+      if (m) maxBytes = Number(m[1]);
+      if (b) backups = Number(b[1]);
+    } else if (file.endsWith(".ps1")) {
+      const m = data.match(/^\$maxBytes\s*=\s*(\d+)\s*$/m);
+      const b = data.match(/^\$backups\s*=\s*(\d+)\s*$/m);
+      if (m) maxBytes = Number(m[1]);
+      if (b) backups = Number(b[1]);
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0) return null;
+    if (!Number.isInteger(backups) || backups < 1) return null;
+    return { maxBytes, backups };
+  } catch {
+    return null;
+  }
+}
+
+export async function serviceStatus({ run = defaultRunCommand, healthFetch } = {}) {
+  const config = loadConfig();
+  const ctx = { run };
+  if (isUnsupportedPlatform()) {
+    return {
+      schema: "aerial.service-status.v1",
+      platform: process.platform,
+      supported: false,
+      config: { host: config.host, port: config.port },
+      service: { installed: false, loaded: false, reason: "unsupported_platform", platform: process.platform, wrapper: wrapperBlock({ installed: false }) },
+      health: { ok: false, error: "unsupported_platform" },
+      logs: logsBlock(),
+      auth: authBlock(),
+      summary: "unsupported"
+    };
+  }
+  const state = serviceState(ctx);
+  const probe = await (healthFetch || defaultHealthFetch)(config.host, config.port);
+  const cls = classifyHealth(probe);
+  const wrapper = wrapperBlock(state);
+  let supervisor;
+  if (cls.mode === "aerial_running") {
+    supervisor = state.installed && state.loaded ? "service-managed" : "foreground";
+  }
+  const health = { ...probe };
+  if (cls.mode === "port_conflict") {
+    health.portConflict = true;
+    health.conflictReason = cls.reason;
+  }
+  if (cls.mode === "aerial_running") {
+    health.aerial = true;
+    health.supervisor = supervisor;
+  }
+  let summary;
+  if (cls.mode === "aerial_running" && supervisor === "service-managed") summary = "running (service-managed)";
+  else if (cls.mode === "aerial_running" && supervisor === "foreground") summary = "running (foreground)";
+  else if (cls.mode === "port_conflict") summary = "port conflict (non-Aerial process on port)";
+  else if (state.installed && state.loaded) summary = "manager reports up but health failed";
+  else if (state.installed) summary = "installed (not running)";
+  else summary = "not installed";
+  return {
+    schema: "aerial.service-status.v1",
+    platform: process.platform,
+    supported: true,
+    config: { host: config.host, port: config.port },
+    service: { platform: process.platform, ...state, wrapper },
+    health,
+    logs: logsBlock(),
+    auth: authBlock(),
+    summary
+  };
+}

package/src/service/wrapper-render.js

@@ -0,0 +1,228 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { configDir } from "../shared/paths.js";
+
+export const SERVICE_LABEL = "com.jiayunxie.aerial";
+export const WIN_TASK_NAME = "AerialLocalProxy";
+
+const PLIST_HEADER = "<!-- Generated by aerial; do not edit. Run `aerial service install` to regenerate. -->";
+const POSIX_HEADER = "# Generated by aerial; do not edit. Run `aerial service install` to regenerate.";
+const DEFAULT_WRAPPER_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const DEFAULT_WRAPPER_LOG_BACKUPS = 3;
+
+export function wrapperLogConfig() {
+  const out = { maxBytes: DEFAULT_WRAPPER_LOG_MAX_BYTES, backups: DEFAULT_WRAPPER_LOG_BACKUPS };
+  const rawMax = process.env.AERIAL_LOG_MAX_BYTES;
+  if (rawMax && /^\d+$/.test(String(rawMax).trim())) {
+    const n = Number(String(rawMax).trim());
+    if (n > 0) out.maxBytes = n;
+  }
+  const rawBackups = process.env.AERIAL_LOG_BACKUPS;
+  if (rawBackups && /^\d+$/.test(String(rawBackups).trim())) {
+    const n = Number(String(rawBackups).trim());
+    if (n >= 1) out.backups = n;
+  }
+  return out;
+}
+
+export function nodeBinary() {
+  return process.env.AERIAL_SERVICE_NODE || process.execPath;
+}
+
+export function cliEntry() {
+  if (process.env.AERIAL_SERVICE_CLI) return process.env.AERIAL_SERVICE_CLI;
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "cli", "index.js");
+}
+
+export function logsDir() {
+  return process.env.AERIAL_LOG_DIR || path.join(configDir(), "logs");
+}
+
+export function aerialLogPath() {
+  return path.join(logsDir(), "aerial.log");
+}
+
+export function stdioLogPath() {
+  return path.join(logsDir(), "aerial-stdio.log");
+}
+
+export function plistPath() {
+  return path.join(os.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+
+export function darwinWrapperPath() {
+  return path.join(configDir(), "bin", "aerial-service.sh");
+}
+
+export function winWrapperPath() {
+  return path.join(configDir(), "bin", "aerial-service.ps1");
+}
+
+function xmlEscape(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function shEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function psEscape(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function uidString() {
+  if (process.platform !== "darwin") return "";
+  const uid = process.getuid?.();
+  return uid === undefined || uid === null ? "" : String(uid);
+}
+
+export function explicitConfigDir() {
+  const v = process.env.AERIAL_CONFIG_DIR;
+  return v && v.trim() ? v : undefined;
+}
+
+export function renderPlist({ label = SERVICE_LABEL, wrapperPath: wrapper }) {
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    PLIST_HEADER,
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>Label</key>",
+    `  <string>${xmlEscape(label)}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    "    <string>/bin/sh</string>",
+    `    <string>${xmlEscape(wrapper)}</string>`,
+    "  </array>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>KeepAlive</key>",
+    "  <dict>",
+    "    <key>SuccessfulExit</key>",
+    "    <false/>",
+    "    <key>Crashed</key>",
+    "    <true/>",
+    "  </dict>",
+    "  <key>ThrottleInterval</key>",
+    "  <integer>10</integer>",
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+
+export function renderDarwinWrapper({ nodePath, cliPath, host, port, stdioLog, aerialLog, configDir: cfg, maxBytes, backups }) {
+  const max = Number.isInteger(maxBytes) && maxBytes > 0 ? maxBytes : DEFAULT_WRAPPER_LOG_MAX_BYTES;
+  const keep = Number.isInteger(backups) && backups >= 1 ? backups : DEFAULT_WRAPPER_LOG_BACKUPS;
+  const lines = [
+    "#!/bin/sh",
+    POSIX_HEADER,
+    "set -e",
+    `STDIO_LOG=${shEscape(stdioLog)}`,
+    `AERIAL_LOG_FILE=${shEscape(aerialLog)}`,
+    `MAX_BYTES=${max}`,
+    `BACKUPS=${keep}`,
+    `NODE_BIN=${shEscape(nodePath)}`,
+    `CLI_ENTRY=${shEscape(cliPath)}`,
+    `HOST=${shEscape(host)}`,
+    `PORT=${Number(port)}`,
+    "STDIO_DIR=$(dirname \"$STDIO_LOG\")",
+    "AERIAL_DIR=$(dirname \"$AERIAL_LOG_FILE\")",
+    "mkdir -p \"$STDIO_DIR\" \"$AERIAL_DIR\"",
+    "if [ -f \"$STDIO_LOG\" ]; then",
+    "  SIZE=$(wc -c < \"$STDIO_LOG\" | tr -d ' ')",
+    "  if [ \"$SIZE\" -gt \"$MAX_BYTES\" ]; then",
+    "    i=$((BACKUPS - 1))",
+    "    while [ \"$i\" -ge 1 ]; do",
+    "      SRC=\"$STDIO_LOG.$i\"",
+    "      DST=\"$STDIO_LOG.$((i + 1))\"",
+    "      if [ -f \"$SRC\" ]; then mv \"$SRC\" \"$DST\"; fi",
+    "      i=$((i - 1))",
+    "    done",
+    "    mv \"$STDIO_LOG\" \"$STDIO_LOG.1\"",
+    "  fi",
+    "fi",
+    "export AERIAL_LOG_FILE",
+    `export AERIAL_LOG_MAX_BYTES=${max}`,
+    `export AERIAL_LOG_BACKUPS=${keep}`
+  ];
+  if (cfg) lines.push(`export AERIAL_CONFIG_DIR=${shEscape(cfg)}`);
+  lines.push("exec \"$NODE_BIN\" \"$CLI_ENTRY\" start --host \"$HOST\" --port \"$PORT\" >> \"$STDIO_LOG\" 2>&1");
+  lines.push("");
+  return lines.join("\n");
+}
+
+export function renderWindowsWrapper({ nodePath, cliPath, host, port, stdioLog, aerialLog, configDir: cfg, maxBytes, backups }) {
+  const max = Number.isInteger(maxBytes) && maxBytes > 0 ? maxBytes : DEFAULT_WRAPPER_LOG_MAX_BYTES;
+  const keep = Number.isInteger(backups) && backups >= 1 ? backups : DEFAULT_WRAPPER_LOG_BACKUPS;
+  const lines = [
+    POSIX_HEADER,
+    "$ErrorActionPreference = 'Stop'",
+    `$node = ${psEscape(nodePath)}`,
+    `$cli  = ${psEscape(cliPath)}`,
+    `$serviceHost = ${psEscape(host)}`,
+    `$servicePort = ${Number(port)}`,
+    `$stdioLog = ${psEscape(stdioLog)}`,
+    `$aerialLog = ${psEscape(aerialLog)}`,
+    `$maxBytes = ${max}`,
+    `$backups = ${keep}`,
+    "$stdioDir = Split-Path -Parent $stdioLog",
+    "$aerialDir = Split-Path -Parent $aerialLog",
+    "if (-not (Test-Path -LiteralPath $stdioDir)) { New-Item -ItemType Directory -Path $stdioDir | Out-Null }",
+    "if (-not (Test-Path -LiteralPath $aerialDir)) { New-Item -ItemType Directory -Path $aerialDir | Out-Null }",
+    "if (Test-Path -LiteralPath $stdioLog) {",
+    "  $size = (Get-Item -LiteralPath $stdioLog).Length",
+    "  if ($size -gt $maxBytes) {",
+    "    for ($i = $backups - 1; $i -ge 1; $i--) {",
+    "      $src = \"$stdioLog.$i\"",
+    "      $dst = \"$stdioLog.$($i + 1)\"",
+    "      if (Test-Path -LiteralPath $src) {",
+    "        if (Test-Path -LiteralPath $dst) { Remove-Item -LiteralPath $dst -Force }",
+    "        Move-Item -LiteralPath $src -Destination $dst",
+    "      }",
+    "    }",
+    "    if (Test-Path -LiteralPath \"$stdioLog.1\") { Remove-Item -LiteralPath \"$stdioLog.1\" -Force }",
+    "    Move-Item -LiteralPath $stdioLog -Destination \"$stdioLog.1\"",
+    "  }",
+    "}",
+    "$env:AERIAL_LOG_FILE = $aerialLog",
+    "$env:AERIAL_LOG_MAX_BYTES = \"$maxBytes\"",
+    "$env:AERIAL_LOG_BACKUPS = \"$backups\""
+  ];
+  if (cfg) lines.push(`$env:AERIAL_CONFIG_DIR = ${psEscape(cfg)}`);
+  lines.push("& $node $cli start --host $serviceHost --port $servicePort *>> $stdioLog");
+  lines.push("");
+  return lines.join("\r\n");
+}
+
+export function quoteSchtasksTR(command) {
+  const wrapped = command.replace(/"/g, '\\"');
+  return `\\"${wrapped}\\"`;
+}
+
+export function buildSchtasksCreateArgs({ taskName = WIN_TASK_NAME, wrapperPath: wrapper }) {
+  const cmd = `powershell.exe -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "${wrapper}"`;
+  return [
+    "/Create",
+    "/TN", taskName,
+    "/SC", "ONLOGON",
+    "/RL", "LIMITED",
+    "/F",
+    "/TR", quoteSchtasksTR(cmd)
+  ];
+}
+
+export function buildSchtasksArgs(action, taskName = WIN_TASK_NAME) {
+  if (action === "delete") return ["/Delete", "/TN", taskName, "/F"];
+  if (action === "run") return ["/Run", "/TN", taskName];
+  if (action === "end") return ["/End", "/TN", taskName];
+  if (action === "query") return ["/Query", "/TN", taskName, "/FO", "LIST"];
+  throw new Error(`Unsupported schtasks action: ${action}`);
+}

package/src/setup/backup.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const BACKUP_PREFIX = ".aerial-backup-";
+const ISO_STAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z$/;
+
+export function backupIfExists(file) {
+  if (!fs.existsSync(file)) return undefined;
+  const backup = `${file}.aerial-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  fs.copyFileSync(file, backup);
+  return backup;
+}
+
+function listBackups(file) {
+  const dir = path.dirname(file);
+  const base = path.basename(file);
+  if (!fs.existsSync(dir)) return [];
+  const prefix = `${base}${BACKUP_PREFIX}`;
+  const entries = fs.readdirSync(dir);
+  const matches = [];
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix)) continue;
+    const stamp = entry.slice(prefix.length);
+    if (!ISO_STAMP_RE.test(stamp)) continue;
+    matches.push({ name: entry, path: path.join(dir, entry), stamp });
+  }
+  matches.sort((a, b) => (a.stamp < b.stamp ? -1 : a.stamp > b.stamp ? 1 : 0));
+  return matches;
+}
+
+export function findLatestBackup(file) {
+  const all = listBackups(file);
+  return all.length ? all[all.length - 1] : undefined;
+}
+
+export function backupPathsFor(file) {
+  return listBackups(file).map((entry) => entry.path);
+}