helixlife-v5-cli 1.2.7 → 1.2.9

package/lib/token-file.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { isHelixSiteOpen, resolveCommandName } = require('./helix-styles-guard');
+
+/** Helix 用户配置目录名 */
+const HELIX_CONFIG_DIR_NAME = 'helix';
+
+/** 默认 token 文件名 */
+const DEFAULT_TOKEN_FILE_NAME = 'token-key.txt';
+
+const TOKEN_COOKIE_NAME = 'token';
+
+/** open 后 cookie 可能尚未从 profile 注入，重试读取 */
+const TOKEN_READ_RETRIES = 4;
+const TOKEN_READ_RETRY_DELAY_MS = 600;
+
+/**
+ * 解析 Helix 用户配置目录（固定路径，与 SKILL 安装位置无关）。
+ * 全平台统一：`$XDG_CONFIG_HOME/helix` 或 `~/.config/helix`
+ * （Windows 示例：`C:\Users\<你>\.config\helix`）
+ * @returns {string}
+ */
+function resolveHelixConfigDir() {
+  const override = (process.env.HELIX_CONFIG_DIR ?? process.env.HELIX_TOKEN_DIR)?.trim();
+  if (override) {
+    if (path.isAbsolute(override)) {
+      return path.normalize(override);
+    }
+    return path.join(os.homedir(), override);
+  }
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return path.join(configHome, HELIX_CONFIG_DIR_NAME);
+}
+
+/**
+ * 默认 token 文件绝对路径。
+ * @returns {string}
+ */
+function defaultTokenFilePath() {
+  return path.join(resolveHelixConfigDir(), DEFAULT_TOKEN_FILE_NAME);
+}
+
+/**
+ * 解析 token 文件绝对路径。
+ * - 未设置 HELIX_TOKEN_FILE：平台默认配置目录下的 token-key.txt
+ * - HELIX_TOKEN_FILE 为绝对路径：原样使用
+ * - HELIX_TOKEN_FILE 为相对路径：基于 resolveHelixConfigDir() 解析
+ * @param {string | undefined} [file]
+ * @returns {string}
+ */
+function resolveTokenFile(file) {
+  const raw = (file ?? process.env.HELIX_TOKEN_FILE)?.trim();
+  if (!raw) {
+    return defaultTokenFilePath();
+  }
+  if (path.isAbsolute(raw)) {
+    return path.normalize(raw);
+  }
+  return path.resolve(resolveHelixConfigDir(), raw);
+}
+
+/**
+ * 命令完成后是否尝试将 token 落盘。
+ * @param {string[]} tokens
+ * @returns {boolean}
+ */
+function shouldTryPersistTokenAfterCommand(tokens) {
+  const cmd = resolveCommandName(tokens);
+  if (cmd === 'open') {
+    return isHelixSiteOpen(tokens);
+  }
+  // Agent 常用 snapshot 验收登录态，此时 cookie 通常已就绪
+  if (cmd === 'snapshot') {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * 从 `cookie-get token` 的 --raw 输出解析 token 值。
+ * @param {string} line
+ * @returns {string | null}
+ */
+function parseTokenFromCookieLine(line) {
+  const trimmed = String(line ?? '').trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^token=([^\s(]+)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * 从当前浏览器会话读取登录 token cookie。
+ * @param {(args: string[], options?: { capture?: boolean }) => number | { code: number, stdout: string, stderr: string }} runPassthrough
+ * @returns {{ ok: true, token: string } | { ok: false, reason: string, detail?: string }}
+ */
+function readTokenFromBrowser(runPassthrough) {
+  const result = runPassthrough(['--raw', 'cookie-get', TOKEN_COOKIE_NAME], { capture: true });
+  if (typeof result !== 'object' || result === null || !('code' in result)) {
+    return { ok: false, reason: 'cookie-get_unexpected_result' };
+  }
+  if (result.code !== 0) {
+    const detail = (result.stderr || result.stdout || '').trim();
+    return { ok: false, reason: 'cookie-get_failed', detail: detail || undefined };
+  }
+  const token = parseTokenFromCookieLine(result.stdout);
+  if (!token) {
+    return { ok: false, reason: 'not_logged_in' };
+  }
+  return { ok: true, token };
+}
+
+/**
+ * 将 token 写入 token-key.txt（或 HELIX_TOKEN_FILE 指定路径）。
+ * @param {string} token
+ * @param {string} [tokenFile]
+ * @returns {string} 写入文件的绝对路径
+ */
+function writeTokenFile(token, tokenFile) {
+  const filePath = tokenFile ?? resolveTokenFile();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${token}\n`, { encoding: 'utf8', mode: 0o600 });
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(filePath, 0o600);
+    } catch {
+      // 权限收紧失败不阻断写入
+    }
+  }
+  return filePath;
+}
+
+function sleepMs(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+/**
+ * 若当前浏览器会话已登录，则将 token 落盘（含重试，应对 open 后 cookie 尚未就绪）。
+ * @param {(args: string[], options?: { capture?: boolean }) => number | { code: number, stdout: string, stderr: string }} runPassthrough
+ * @param {{ log?: (msg: string) => void, retries?: number, delayMs?: number }} [options]
+ * @returns {Promise<boolean>} 是否已保存
+ */
+async function maybePersistLoginToken(runPassthrough, options = {}) {
+  const retries = options.retries ?? TOKEN_READ_RETRIES;
+  const delayMs = options.delayMs ?? TOKEN_READ_RETRY_DELAY_MS;
+
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    const read = readTokenFromBrowser(runPassthrough);
+    if (read.ok) {
+      const filePath = writeTokenFile(read.token);
+      if (options.log) {
+        options.log(`已登录，token 已保存：${filePath}`);
+      }
+      return true;
+    }
+    if (read.reason !== 'not_logged_in') {
+      if (options.log) {
+        options.log(`token 未保存：${read.detail || read.reason}`);
+      }
+      return false;
+    }
+    if (attempt < retries - 1) {
+      await sleepMs(delayMs);
+    }
+  }
+  return false;
+}
+
+module.exports = {
+  HELIX_CONFIG_DIR_NAME,
+  DEFAULT_TOKEN_FILE_NAME,
+  TOKEN_COOKIE_NAME,
+  TOKEN_READ_RETRIES,
+  TOKEN_READ_RETRY_DELAY_MS,
+  resolveHelixConfigDir,
+  resolveTokenFile,
+  defaultTokenFilePath,
+  shouldTryPersistTokenAfterCommand,
+  parseTokenFromCookieLine,
+  readTokenFromBrowser,
+  writeTokenFile,
+  maybePersistLoginToken,
+};

package/lib/visual-page-wrap.js

@@ -0,0 +1,311 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { GUARD_SETUP, GUARD_TEARDOWN } = require("./automation-file-chooser-guard");
+
+/**
+ * 解析 run-code 参数，读取 --filename 或内联代码。
+ * @param {string[]} tokens 已剥离 visual flags、保留 run-code 命令
+ */
+function parseRunCodePayload(tokens) {
+  let i = 0;
+  if (tokens[i] === "--raw") i += 1;
+  if (tokens[i] === "--json") i += 1;
+  if (tokens[i] && tokens[i].startsWith("-s=")) i += 1;
+  if (tokens[i] !== "run-code") {
+    throw Object.assign(new Error("wrapRunCodeTokens 需要 run-code 命令"), {
+      code: "E_BAD_ARG",
+    });
+  }
+  i += 1;
+
+  let filename = null;
+  let code = null;
+  const passthroughFlags = [];
+  for (; i < tokens.length; i += 1) {
+    const t = tokens[i];
+    if (t === "--filename" || t === "-f") {
+      filename = tokens[i + 1];
+      i += 1;
+    } else if (t.startsWith("--filename=")) {
+      filename = t.slice("--filename=".length);
+    } else if (!t.startsWith("--") && code == null) {
+      code = t;
+    } else {
+      passthroughFlags.push(t);
+      if (t.startsWith("--") && !t.includes("=")) {
+        const next = tokens[i + 1];
+        if (next !== undefined && !next.startsWith("-")) {
+          passthroughFlags.push(next);
+          i += 1;
+        }
+      }
+    }
+  }
+
+  if (filename) {
+    const resolved = path.isAbsolute(filename)
+      ? filename
+      : path.resolve(process.cwd(), filename);
+    code = fs.readFileSync(resolved, "utf8");
+  }
+  if (!code || !String(code).trim()) {
+    throw Object.assign(new Error("run-code 缺少内联代码或 --filename"), {
+      code: "E_BAD_ARG",
+    });
+  }
+  return {
+    code: String(code).trim(),
+    filename,
+    passthroughFlags,
+  };
+}
+
+/**
+ * 将用户 `async page => { ... }` 包装为带逐步视觉反馈的版本。
+ * @param {string} userSource
+ * @param {{ initScript: string, scriptName?: string }} meta
+ */
+function wrapRunCodeSource(userSource, meta) {
+  const userFn = String(userSource).trim();
+  const initScriptJson = JSON.stringify(meta.initScript);
+  const cfgJson = JSON.stringify({
+    scriptName: meta.scriptName || "脚本",
+  });
+
+  return `async page => {
+  const __INIT__ = ${initScriptJson};
+  const __CFG__ = ${cfgJson};
+
+  await page.evaluate((src) => {
+    if (window.__helix_visual__) return;
+    const run = new Function(src);
+    run();
+  }, __INIT__);
+
+  await page.evaluate(() => {
+    window.__helix_visual__?.setVisualOptions({ enabled: true, persist: true });
+  });
+
+  const __ACTIONS__ = {
+    click: { pending: "正在点击", success: "已点击", tone: "pending", ok: "success" },
+    dblclick: { pending: "正在双击", success: "已双击", tone: "pending", ok: "success" },
+    hover: { pending: "正在悬停", success: "已悬停", tone: "info", ok: "info" },
+    fill: { pending: "正在填写", success: "已填写", tone: "pending", ok: "success" },
+    check: { pending: "正在勾选", success: "已勾选", tone: "pending", ok: "success" },
+    uncheck: { pending: "正在取消勾选", success: "已取消勾选", tone: "pending", ok: "info" },
+  };
+
+  const __PAGE_METHODS__ = [
+    "locator",
+    "getByRole",
+    "getByText",
+    "getByLabel",
+    "getByPlaceholder",
+    "getByAltText",
+    "getByTitle",
+    "getByTestId",
+  ];
+  const __ACT__ = [
+    "click",
+    "dblclick",
+    "hover",
+    "fill",
+    "check",
+    "uncheck",
+    "selectOption",
+    "press",
+    "type",
+    "tap",
+    "focus",
+  ];
+
+  const __describe__ = async (locator) => {
+    try {
+      return await locator.evaluate((el) => {
+        const t = (el.innerText || el.textContent || el.getAttribute("aria-label") || "")
+          .replace(/\\s+/g, " ")
+          .trim();
+        return t.slice(0, 72);
+      });
+    } catch {
+      return "";
+    }
+  };
+
+  const __resolveHighlight__ = async (locator) => {
+    try {
+      const row = locator.locator('xpath=ancestor::*[contains(@title,"操作区")][1]');
+      if ((await row.count()) > 0) return row.first();
+      const li = locator.locator("xpath=ancestor::li[1]/div[1]");
+      if ((await li.count()) > 0) return li.first();
+    } catch {}
+    return locator;
+  };
+
+  const __highlight__ = async (locator, args) => {
+    try {
+      const target = await __resolveHighlight__(locator);
+      await target.evaluate(
+        (el, payload) => window.__helix_visual__?.select(el, payload),
+        args,
+      );
+    } catch {}
+  };
+
+  const __wrapLoc__ = (locator, page) =>
+    new Proxy(locator, {
+      get(target, prop) {
+        const val = target[prop];
+        if (__ACT__.includes(prop) && typeof val === "function") {
+          return async (...args) => {
+            const def = __ACTIONS__[prop] || {
+              pending: String(prop),
+              success: "完成",
+              tone: "info",
+              ok: "success",
+            };
+            const desc = await __describe__(target);
+            await __highlight__(target, {
+              tone: def.tone,
+              label: desc || def.pending,
+              action: String(prop),
+              target: desc,
+              detail: def.pending + "…",
+            });
+            try {
+              const result = await val.apply(target, args);
+              await __highlight__(target, {
+                tone: def.ok,
+                label: desc || def.success,
+                action: String(prop),
+                target: desc,
+                detail: def.success,
+              });
+              return result;
+            } catch (err) {
+              await page.evaluate(
+                (payload) => window.__helix_visual__?.showHud(payload),
+                {
+                  action: String(prop),
+                  target: desc,
+                  status: "danger",
+                  detail: String(err && err.message ? err.message : err),
+                },
+              );
+              throw err;
+            }
+          };
+        }
+        if (typeof val === "function") {
+          return (...args) => {
+            const out = val.apply(target, args);
+            if (out && typeof out === "object" && typeof out.click === "function") {
+              return __wrapLoc__(out, page);
+            }
+            return out;
+          };
+        }
+        return val;
+      },
+    });
+
+  const __wrapPage__ = (page) =>
+    new Proxy(page, {
+      get(target, prop) {
+        if (prop === "__helixVisual") {
+          return {
+            select: async (locator, opts = {}) => {
+              await __highlight__(locator, {
+                tone: opts.status || "pending",
+                label: opts.label || opts.target || "",
+                action: opts.action || "步骤",
+                target: opts.target || opts.label || "",
+                detail: opts.detail || "执行中…",
+              });
+            },
+            hud: async (opts = {}) => {
+              await page.evaluate(
+                (payload) => window.__helix_visual__?.showHud(payload),
+                opts,
+              );
+            },
+            cleanup: async () => {
+              await page.evaluate(() => window.__helix_visual__?.cleanup());
+            },
+          };
+        }
+        const val = target[prop];
+        if (__PAGE_METHODS__.includes(prop) && typeof val === "function") {
+          return (...args) => __wrapLoc__(val.apply(target, args), target);
+        }
+        if (typeof val === "function") return val.bind(target);
+        return val;
+      },
+    });
+
+  await page.evaluate(
+    (cfg) =>
+      window.__helix_visual__?.showHud({
+        action: "执行脚本",
+        target: cfg.scriptName,
+        status: "pending",
+        detail: "执行中…",
+      }),
+    __CFG__,
+  );
+
+  const __userFn = ${userFn};
+  try {${GUARD_SETUP}
+    const result = await __userFn(__wrapPage__(page));
+    await page.evaluate(
+      (cfg) =>
+        window.__helix_visual__?.showHud({
+          action: "执行脚本",
+          target: cfg.scriptName,
+          status: "success",
+          detail: "完成",
+        }),
+      __CFG__,
+    );
+    return result;
+  } catch (err) {
+    await page.evaluate(
+      (payload) => window.__helix_visual__?.showHud(payload),
+      {
+        action: "执行脚本",
+        target: __CFG__.scriptName,
+        status: "danger",
+        detail: String(err && err.message ? err.message : err),
+      },
+    );
+    throw err;
+  } finally {${GUARD_TEARDOWN}
+    await page.evaluate(() => {
+      window.__helix_visual__?.setVisualOptions({ persist: false });
+    });
+  }
+`;
+}
+
+/**
+ * 将 run-code tokens 替换为注入视觉反馈的内联脚本。
+ * @param {string[]} tokens
+ * @param {string} initScript
+ */
+function wrapRunCodeTokens(tokens, initScript) {
+  const { code, filename, passthroughFlags } = parseRunCodePayload(tokens);
+  const scriptName = filename ? path.basename(filename, path.extname(filename)) : "脚本";
+  const wrapped = wrapRunCodeSource(code, {
+    initScript,
+    scriptName,
+  });
+  return ["run-code", wrapped, ...passthroughFlags];
+}
+
+module.exports = {
+  parseRunCodePayload,
+  wrapRunCodeSource,
+  wrapRunCodeTokens,
+};