@lark-people/cli 0.0.0-beta.1

package/scripts/install-wizard.js

@@ -0,0 +1,700 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const { execFileSync, execFile } = require("child_process");
+
+let p;
+
+const BIN_NAME = "people-cli";
+const CURRENT_PACKAGE_DIR = path.resolve(__dirname, "..");
+const DEFAULT_PKG = "@lark-people/cli";
+const DEFAULT_SKILLS_DIR = path.join(__dirname, "..", "skills");
+const isWindows = process.platform === "win32";
+const EXCLUDED_BUNDLED_SKILLS = new Set(["people-skill-maker"]);
+
+function readPackageMeta(packageDir = CURRENT_PACKAGE_DIR) {
+  try {
+    const packageJSON = path.join(packageDir, "package.json");
+    return JSON.parse(fs.readFileSync(packageJSON, "utf8"));
+  } catch (_) {
+    return {};
+  }
+}
+
+const PKG = readPackageMeta().name || DEFAULT_PKG;
+
+const messages = {
+  zh: {
+    setup: "正在设置 People CLI...",
+    step1: "正在安装 %s...",
+    step1Upgrade: "正在升级 %s (v%s → v%s)...",
+    step1Skip: "已安装 (v%s)，跳过",
+    step1Done: "已全局安装",
+    step1Upgraded: "已升级到 v%s",
+    step1Fail: "全局安装失败。运行以下命令重试: npm install -g %s",
+    step2Spinner: "正在安装 Skills...",
+    step2Skip: "官方 Skills 已齐全，跳过",
+    step2Done: "Skills 已安装",
+    step2Fail: "Skills 安装失败。运行以下命令重试: npx skills add <本地skill目录> -g -y",
+    step2Empty: "未发现可安装的官方 Skills",
+    step3: "正在配置应用...",
+    step3NotFound: "未找到 people-cli，终止",
+    step3Found: "发现已配置应用 (App ID: %s)，继续使用？",
+    step3Reinit: "检测到已有应用配置不可用，将重新初始化",
+    step3Skip: "跳过应用配置",
+    step3Done: "应用已配置",
+    step3Fail: "应用配置失败。运行以下命令重试: people-cli config init --new",
+    step4: "授权",
+    step4NotFound: "未找到 people-cli，跳过授权",
+    step4Confirm: "是否现在执行登录授权，让 CLI 能访问你已授权的 People 数据？",
+    step4Skip: "跳过授权。后续运行 people-cli auth login 完成授权",
+    step4Done: "授权完成",
+    step4Fail: "授权失败。运行以下命令重试: people-cli auth login",
+    done: "安装完成！现在可以开始使用 People CLI 及其官方 Skills。",
+    cancelled: "安装已取消",
+    nonTtyHint: "要完成配置，请在终端中运行：\n  people-cli config init --new\n  people-cli auth login",
+  },
+  en: {
+    setup: "Setting up People CLI...",
+    step1: "Installing %s globally...",
+    step1Upgrade: "Upgrading %s (v%s -> v%s)...",
+    step1Skip: "Already installed (v%s). Skipped",
+    step1Done: "Installed globally",
+    step1Upgraded: "Upgraded to v%s",
+    step1Fail: "Failed to install globally. Run manually: npm install -g %s",
+    step2Spinner: "Installing skills...",
+    step2Skip: "Official skills already present. Skipped",
+    step2Done: "Skills installed",
+    step2Fail: "Failed to install skills. Run manually: npx skills add <local-skill-dir> -g -y",
+    step2Empty: "No bundled official skills found",
+    step3: "Configuring app...",
+    step3NotFound: "people-cli not found. Aborting",
+    step3Found: "Found existing app (App ID: %s). Use this app?",
+    step3Reinit: "Detected stale app configuration. Re-initializing",
+    step3Skip: "Skipped app configuration",
+    step3Done: "App configured",
+    step3Fail: "Failed to configure app. Run manually: people-cli config init --new",
+    step4: "Authorization",
+    step4NotFound: "people-cli not found. Skipping authorization",
+    step4Confirm: "Authorize now so People CLI can access your approved People data?",
+    step4Skip: "Skipped. Run people-cli auth login to authorize later",
+    step4Done: "Authorization complete",
+    step4Fail: "Failed to authorize. Run people-cli auth login to retry",
+    done: "You are all set! People CLI and its official skills are ready.",
+    cancelled: "Installation cancelled",
+    nonTtyHint: "To complete setup, run interactively:\n  people-cli config init --new\n  people-cli auth login",
+  },
+};
+
+function handleCancel(value, msg) {
+  if (p.isCancel(value)) {
+    p.cancel(msg.cancelled);
+    process.exit(0);
+  }
+  return value;
+}
+
+function execCmd(cmd, args, opts) {
+  if (isWindows) {
+    return execFileSync("cmd.exe", ["/c", cmd, ...args], opts);
+  }
+  return execFileSync(cmd, args, opts);
+}
+
+function run(cmd, args, opts = {}) {
+  execCmd(cmd, args, { stdio: "inherit", ...opts });
+}
+
+function runSilent(cmd, args, opts = {}) {
+  return execCmd(cmd, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    ...opts,
+  });
+}
+
+function runSilentAsync(cmd, args, opts = {}) {
+  const actualCmd = isWindows ? "cmd.exe" : cmd;
+  const actualArgs = isWindows ? ["/c", cmd, ...args] : args;
+  return new Promise((resolve, reject) => {
+    execFile(actualCmd, actualArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...opts,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+function hasExecutable(bin) {
+  try {
+    const cmd = isWindows ? "where" : "which";
+    const output = runSilent(cmd, [bin], { timeout: 5000 }).toString().trim();
+    return output.length > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+function resolveSkillsLauncher(check = hasExecutable) {
+  if (check("npx")) {
+    return {
+      cmd: "npx",
+      prefix: ["-y", "skills"],
+    };
+  }
+  if (check("npm")) {
+    return {
+      cmd: "npm",
+      prefix: ["exec", "--yes", "--", "skills"],
+    };
+  }
+  return null;
+}
+
+function buildSkillsCommandArgs(skillArgs, check = hasExecutable) {
+  const launcher = resolveSkillsLauncher(check);
+  if (!launcher) {
+    throw new Error("Neither npx nor npm is available in PATH");
+  }
+  return {
+    cmd: launcher.cmd,
+    args: launcher.prefix.concat(skillArgs),
+  };
+}
+
+function runSkillsCommandAsync(skillArgs, opts = {}) {
+  const command = buildSkillsCommandArgs(skillArgs);
+  return runSilentAsync(command.cmd, command.args, opts);
+}
+
+function formatCommandFailure(err) {
+  for (const key of ["stderr", "stdout"]) {
+    const value = err && err[key] ? String(err[key]).trim() : "";
+    if (value) {
+      return value;
+    }
+  }
+  return err && err.message ? String(err.message).trim() : "";
+}
+
+function buildInstallAuthLoginArgs() {
+  return ["auth", "login", "--install-scope-level", "all"];
+}
+
+function fmt(template, ...values) {
+  let i = 0;
+  return template.replace(/%s/g, () => values[i++] ?? "");
+}
+
+function getCurrentPackageName(packageDir = CURRENT_PACKAGE_DIR) {
+  return readPackageMeta(packageDir).name || DEFAULT_PKG;
+}
+
+function getCurrentPackageVersion(packageDir = CURRENT_PACKAGE_DIR) {
+  return readPackageMeta(packageDir).version || null;
+}
+
+function resolveGlobalPackageDir(packageName = PKG) {
+  try {
+    const prefix = runSilent("npm", ["prefix", "-g"], { timeout: 15000 }).toString().trim();
+    const parts = packageName.split("/");
+    return isWindows
+      ? path.join(prefix, "node_modules", ...parts)
+      : path.join(prefix, "lib", "node_modules", ...parts);
+  } catch (_) {
+    return null;
+  }
+}
+
+function sameResolvedPath(a, b) {
+  if (!a || !b) {
+    return false;
+  }
+  try {
+    return fs.realpathSync(a) === fs.realpathSync(b);
+  } catch (_) {
+    return path.resolve(a) === path.resolve(b);
+  }
+}
+
+function parseVersion(version) {
+  if (!version) {
+    return null;
+  }
+  const match = String(version).trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([A-Za-z]+)\.(\d+))?$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prereleaseType: match[4] || null,
+    prereleaseNumber: match[5] ? Number(match[5]) : null,
+  };
+}
+
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) {
+    return 0;
+  }
+  if (left.major !== right.major) return left.major - right.major;
+  if (left.minor !== right.minor) return left.minor - right.minor;
+  if (left.patch !== right.patch) return left.patch - right.patch;
+
+  const leftStable = left.prereleaseType === null;
+  const rightStable = right.prereleaseType === null;
+  if (leftStable && rightStable) return 0;
+  if (leftStable) return 1;
+  if (rightStable) return -1;
+  if (left.prereleaseType !== right.prereleaseType) {
+    return left.prereleaseType.localeCompare(right.prereleaseType);
+  }
+  return (left.prereleaseNumber || 0) - (right.prereleaseNumber || 0);
+}
+
+function planGlobalInstall({
+  currentPackageName = PKG,
+  installedVersion,
+  latestVersion,
+  currentVersion,
+  currentPackageDir = CURRENT_PACKAGE_DIR,
+  globalPackageDir = resolveGlobalPackageDir(currentPackageName),
+} = {}) {
+  const useCurrentPackage = Boolean(
+    currentPackageDir &&
+    globalPackageDir &&
+    !sameResolvedPath(currentPackageDir, globalPackageDir),
+  );
+
+  if (useCurrentPackage) {
+    return {
+      skip: false,
+      needsUpgrade: false,
+      installTarget: currentPackageDir,
+      installVersion: currentVersion || latestVersion || installedVersion || null,
+      useCurrentPackage: true,
+    };
+  }
+
+  const installVersion = latestVersion || currentVersion || installedVersion || null;
+  const needsUpgrade = Boolean(
+    installedVersion &&
+    installVersion &&
+    compareVersions(installedVersion, installVersion) < 0,
+  );
+
+  return {
+    skip: Boolean(installedVersion && !needsUpgrade),
+    needsUpgrade,
+    installTarget: currentPackageName,
+    installVersion,
+    useCurrentPackage: false,
+  };
+}
+
+function parseLangArg(argv = process.argv.slice(2)) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--lang" && argv[i + 1]) {
+      const value = argv[i + 1].toLowerCase();
+      if (value === "zh" || value === "en") return value;
+    }
+    if (argv[i].startsWith("--lang=")) {
+      const value = argv[i].split("=")[1].toLowerCase();
+      if (value === "zh" || value === "en") return value;
+    }
+  }
+  return null;
+}
+
+function whichPeopleCli() {
+  try {
+    const prefix = runSilent("npm", ["prefix", "-g"], { timeout: 15000 }).toString().trim();
+    const bin = isWindows
+      ? path.join(prefix, "people-cli.cmd")
+      : path.join(prefix, "bin", "people-cli");
+    if (fs.existsSync(bin)) return bin;
+  } catch (_) {
+    // fall through
+  }
+
+  try {
+    const cmd = isWindows ? "where" : "which";
+    return runSilent(cmd, [BIN_NAME], { timeout: 5000 })
+      .toString()
+      .split("\n")[0]
+      .trim();
+  } catch (_) {
+    return null;
+  }
+}
+
+function getLatestVersion(packageName = PKG) {
+  try {
+    const out = runSilent("npm", ["view", packageName, "version"], { timeout: 15000 });
+    const version = out.toString().trim();
+    return parseVersion(version) ? version : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function getGloballyInstalledVersion(packageName = PKG) {
+  try {
+    const out = runSilent("npm", ["list", "-g", packageName], { timeout: 15000 });
+    const match = out.toString().match(/@(\d+\.\d+\.\d+[^\s]*)/);
+    return match ? match[1] : "unknown";
+  } catch (_) {
+    return null;
+  }
+}
+
+function getExistingAppId(binPath) {
+  try {
+    const out = runSilent(binPath, ["config", "show"], { timeout: 10000 });
+    const parsed = JSON.parse(out.toString());
+    return parsed.appId || parsed.app_id || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function inspectExistingAppConfig(binPath, deps = {}) {
+  const runSilentFn = deps.runSilent || runSilent;
+  try {
+    const out = runSilentFn(binPath, ["config", "show"], { timeout: 10000 });
+    const parsed = JSON.parse(out.toString());
+    const appId = parsed.appId || parsed.app_id || null;
+    if (!appId) {
+      return { appId: null, reusable: false };
+    }
+    try {
+      runSilentFn(binPath, ["auth", "status"], { timeout: 10000 });
+      return { appId, reusable: true };
+    } catch (_) {
+      return { appId, reusable: false };
+    }
+  } catch (_) {
+    return { appId: null, reusable: false };
+  }
+}
+
+function listBundledSkills(skillsDir = DEFAULT_SKILLS_DIR) {
+  if (!fs.existsSync(skillsDir)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(skillsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => {
+      const dir = path.join(skillsDir, entry.name);
+      return {
+        name: entry.name,
+        dir,
+        skillFile: path.join(dir, "SKILL.md"),
+      };
+    })
+    .filter(skill => !EXCLUDED_BUNDLED_SKILLS.has(skill.name))
+    .filter(skill => fs.existsSync(skill.skillFile))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function parseGlobalSkillsJSON(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .map(item => (item && typeof item.name === "string" ? item.name.trim() : ""))
+      .filter(Boolean)
+      .sort();
+  } catch (_) {
+    return [];
+  }
+}
+
+function parseGlobalSkillsText(text) {
+  const seen = new Set();
+  const lines = String(text).split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === "Global Skills" || trimmed === "General" || trimmed === "Project" || trimmed === "Local") {
+      continue;
+    }
+    if (trimmed.startsWith("Tip:") || trimmed.startsWith("Agents:")) {
+      continue;
+    }
+    const candidate = trimmed.split(/\s+/)[0];
+    if (/^[A-Za-z0-9][A-Za-z0-9_:-]*(@[^\s]+)?$/.test(candidate)) {
+      seen.add(candidate);
+    }
+  }
+  return Array.from(seen).sort();
+}
+
+async function listInstalledGlobalSkills() {
+  try {
+    const jsonText = await runSkillsCommandAsync(["ls", "-g", "--json"], {
+      timeout: 120000,
+    });
+    const parsed = parseGlobalSkillsJSON(jsonText.toString());
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  } catch (_) {
+    // fall through
+  }
+
+  try {
+    const text = await runSkillsCommandAsync(["ls", "-g"], {
+      timeout: 120000,
+    });
+    return parseGlobalSkillsText(text.toString());
+  } catch (_) {
+    return [];
+  }
+}
+
+function diffMissingSkills(bundledSkills, installedNames) {
+  const installed = new Set(installedNames);
+  return bundledSkills.filter(skill => !installed.has(skill.name));
+}
+
+async function stepSelectLang() {
+  const fromArg = parseLangArg();
+  if (fromArg) return fromArg;
+
+  const lang = await p.select({
+    message: "请选择语言 / Select language",
+    options: [
+      { value: "zh", label: "中文" },
+      { value: "en", label: "English" },
+    ],
+  });
+  return handleCancel(lang, messages.zh);
+}
+
+async function stepInstallGlobally(msg) {
+  const currentPkg = getCurrentPackageName();
+  const installedVer = getGloballyInstalledVersion(currentPkg);
+  const currentVer = getCurrentPackageVersion();
+  const latestVer = getLatestVersion(currentPkg);
+  const plan = planGlobalInstall({
+    currentPackageName: currentPkg,
+    installedVersion: installedVer,
+    latestVersion: latestVer,
+    currentVersion: currentVer,
+  });
+
+  if (plan.skip) {
+    if (p) {
+      p.log.info(fmt(msg.step1Skip, installedVer));
+    } else {
+      console.log(fmt(msg.step1Skip, installedVer));
+    }
+    return false;
+  }
+
+  const spinner = p ? p.spinner() : null;
+  if (spinner) {
+    spinner.start(
+      plan.needsUpgrade
+        ? fmt(msg.step1Upgrade, PKG, installedVer, plan.installVersion)
+        : fmt(msg.step1, PKG),
+    );
+  }
+  try {
+    await runSilentAsync("npm", ["install", "-g", plan.installTarget], { timeout: 120000 });
+    if (spinner) {
+      spinner.stop(plan.needsUpgrade ? fmt(msg.step1Upgraded, plan.installVersion) : msg.step1Done);
+    }
+    return true;
+  } catch (_) {
+    if (spinner) {
+      spinner.stop(fmt(msg.step1Fail, PKG));
+    } else {
+      console.error(fmt(msg.step1Fail, PKG));
+    }
+    process.exit(1);
+  }
+}
+
+async function stepInstallSkills(msg, deps = {}) {
+  const listBundled = deps.listBundledSkills || listBundledSkills;
+  const installSkill = deps.installSkill || (skill => runSkillsCommandAsync(["add", skill.dir, "-g", "-y"], {
+    timeout: 120000,
+  }));
+  const spinner = p ? p.spinner() : null;
+  if (spinner) {
+    spinner.start(msg.step2Spinner);
+  }
+
+  try {
+    const bundled = listBundled();
+    if (bundled.length === 0) {
+      if (spinner) {
+        spinner.stop(msg.step2Empty);
+      } else {
+        console.log(msg.step2Empty);
+      }
+      return;
+    }
+
+    for (const skill of bundled) {
+      await installSkill(skill);
+    }
+
+    if (spinner) {
+      spinner.stop(msg.step2Done);
+    } else {
+      console.log(msg.step2Done);
+    }
+  } catch (err) {
+    if (spinner) {
+      spinner.stop(msg.step2Fail);
+    } else {
+      console.error(msg.step2Fail);
+    }
+    const detail = formatCommandFailure(err);
+    if (detail) {
+      if (p) {
+        p.log.error(detail);
+      } else {
+        console.error(detail);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+async function stepConfigInit(msg, lang) {
+  const spinner = p ? p.spinner() : null;
+  if (spinner) {
+    spinner.start(msg.step3);
+  }
+
+  const peopleCli = whichPeopleCli();
+  if (!peopleCli) {
+    if (spinner) {
+      spinner.stop(msg.step3NotFound);
+    }
+    process.exit(1);
+  }
+
+  const existing = inspectExistingAppConfig(peopleCli);
+  if (spinner) {
+    spinner.stop(msg.step3);
+  }
+
+  if (existing.appId && existing.reusable) {
+    const reuse = await p.confirm({
+      message: fmt(msg.step3Found, existing.appId),
+    });
+    if (handleCancel(reuse, msg) && reuse) {
+      p.log.info(msg.step3Skip);
+      return;
+    }
+  } else if (existing.appId) {
+    p.log.warn(msg.step3Reinit);
+  }
+
+  try {
+    run(peopleCli, ["config", "init", "--new", "--lang", lang]);
+    p.log.success(msg.step3Done);
+  } catch (_) {
+    p.log.error(msg.step3Fail);
+    process.exit(1);
+  }
+}
+
+async function stepAuthLogin(msg) {
+  const peopleCli = whichPeopleCli();
+  if (!peopleCli) {
+    p.log.warn(msg.step4NotFound);
+    return;
+  }
+
+  const yes = await p.confirm({
+    message: msg.step4Confirm,
+  });
+  if (p.isCancel(yes)) {
+    p.cancel(msg.cancelled);
+    process.exit(0);
+  }
+  if (!yes) {
+    p.log.info(msg.step4Skip);
+    return;
+  }
+
+  p.log.step(msg.step4);
+  try {
+    run(peopleCli, buildInstallAuthLoginArgs());
+    p.log.success(msg.step4Done);
+  } catch (_) {
+    p.log.warn(msg.step4Fail);
+  }
+}
+
+async function main() {
+  const isInteractive = !!process.stdin.isTTY;
+  const lang = isInteractive ? await stepSelectLang() : (parseLangArg() || "zh");
+  const msg = messages[lang];
+
+  if (isInteractive) {
+    p.intro(msg.setup);
+    await stepInstallGlobally(msg);
+    await stepInstallSkills(msg);
+    await stepConfigInit(msg, lang);
+    await stepAuthLogin(msg);
+    p.outro(msg.done);
+  } else {
+    console.log(msg.setup);
+    await stepInstallGlobally(msg);
+    await stepInstallSkills(msg);
+    console.log(msg.nonTtyHint);
+  }
+}
+
+async function runCLI() {
+  p = await import("@clack/prompts");
+  await main();
+}
+
+module.exports = {
+  buildInstallAuthLoginArgs,
+  DEFAULT_SKILLS_DIR,
+  diffMissingSkills,
+  formatCommandFailure,
+  buildSkillsCommandArgs,
+  inspectExistingAppConfig,
+  listBundledSkills,
+  listInstalledGlobalSkills,
+  parseGlobalSkillsJSON,
+  parseGlobalSkillsText,
+  parseLangArg,
+  planGlobalInstall,
+  resolveSkillsLauncher,
+  stepInstallSkills,
+  main,
+  runCLI,
+};
+
+if (require.main === module) {
+  runCLI().catch(err => {
+    const message = "Unexpected error: " + (err.message || err);
+    if (p) {
+      p.cancel(message);
+    } else {
+      console.error(message);
+    }
+    process.exit(1);
+  });
+}