Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

17.0 KB
Raw Blame
import { execFileSync } from "node:child_process";
import { existsSync, readFileSync } from "node:fs";
import { homedir } from "node:os";
import {
  resolvePnpmInvocation,
  usablePnpmExecPath,
} from "../../../../scripts/shared/pnpm-invocation.mjs";
import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { mobileClientBundleEnv } from "../../../../scripts/shared/client-endpoint-build-env.mjs";
import { withLocalMobileRegionConfig } from "./mobile-dev-region.mjs";
import { inspectMetroListeners, probeMetroOwnership } from "../sim-metro.mjs";

const mobileDir = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
const SIMULATOR_UDID_PATTERN = /^[0-9A-F]{8}(?:-[0-9A-F]{4}){3}-[0-9A-F]{12}$/;

/** Parse one optional exact Simulator target without changing sim:start arguments. */
export function extractSimWhoamiUdidArgs(args) {
  let simulatorUdid = null;
  const passthrough = [];

  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    let value = null;
    if (arg === "--udid") {
      value = args[++index];
    } else if (arg.startsWith("--udid=")) {
      value = arg.slice("--udid=".length);
    } else {
      passthrough.push(arg);
      continue;
    }

    if (simulatorUdid !== null) throw new Error("Simulator UDID 只能传一次");
    const normalized = String(value ?? "")
      .trim()
      .toUpperCase();
    if (!SIMULATOR_UDID_PATTERN.test(normalized)) {
      throw new Error(`Simulator UDID 无效: ${value ?? "(缺失)"}`);
    }
    simulatorUdid = normalized;
  }

  return { simulatorUdid, passthrough };
}

/** Select only the exact booted device when Host supplies a Simulator target. */
export function bootedSimulatorLinesForTarget(lines, simulatorUdid) {
  const booted = lines.filter((line) => /\(Booted\)/.test(line));
  if (!simulatorUdid) return booted;
  const exactUdid = simulatorUdid.toUpperCase();
  return booted.filter((line) => line.toUpperCase().includes(`(${exactUdid})`));
}

/** Cindy's own simulator (the official Baguette plugin) keeps a private CoreSimulator device set. */
export const CINDY_SIMULATOR_ROOT = join(homedir(), "Library/Application Support/BaguetteCindy");

/** Same rule as the plugin: a missing settings file is its default (allowed), an unreadable one is paused. */
export function cindySimulatorEnabled({ root = CINDY_SIMULATOR_ROOT, readFile = readFileSync } = {}) {
  try {
    return JSON.parse(readFile(join(root, "runtime-settings.json"), "utf8")).enabled === true;
  } catch (error) {
    return error?.code === "ENOENT";
  }
}

/**
 * Device sets to search, in order. CINDY_MOBILE_SIMULATOR=auto (default) prefers Cindy's
 * simulator when it is installed and allowed to run, then the system (Xcode) set;
 * `cindy` / `system` pin one, and an absolute path pins that CoreSimulator device set.
 */
export function resolveSimulatorDeviceSets({
  choice = process.env.CINDY_MOBILE_SIMULATOR || "auto",
  root = CINDY_SIMULATOR_ROOT,
  exists = existsSync,
  readFile = readFileSync,
} = {}) {
  const cindy = { name: "cindy", path: join(root, "devices") };
  const system = { name: "system", path: null };
  if (choice === "auto")
    return exists(cindy.path) && cindySimulatorEnabled({ root, readFile }) ? [cindy, system] : [system];
  if (choice === "system") return [system];
  if (choice === "cindy") {
    if (!exists(cindy.path))
      throw new Error("没有找到 Cindy 模拟器的设备目录;请先在 Cindy 安装并使用 Baguette 模拟器插件");
    if (!cindySimulatorEnabled({ root, readFile }))
      throw new Error("Cindy 模拟器在插件设置中关闭了运行;请先在 Cindy 打开");
    return [cindy];
  }
  if (!isAbsolute(choice))
    throw new Error("CINDY_MOBILE_SIMULATOR 只能是 auto、cindy、system 或设备目录的绝对路径");
  return [{ name: choice, path: choice }];
}

/** simctl arguments scoped to one device set (`null` path = the system set). */
export function simctlArgs(deviceSet, args) {
  return deviceSet?.path ? ["simctl", "--set", deviceSet.path, ...args] : ["simctl", ...args];
}

/**
 * Use the set holding the exact UDID, otherwise the first set with a booted device.
 * An unreadable fallback candidate is skipped; a pinned (single) set still reports its error.
 */
export function selectBootedSimulator(deviceSets, listBooted, simulatorUdid) {
  for (const deviceSet of deviceSets) {
    let lines;
    try {
      lines = listBooted(deviceSet).split("\n");
    } catch (error) {
      if (deviceSets.length === 1) throw error;
      continue;
    }
    const booted = bootedSimulatorLinesForTarget(lines, null);
    const targetBooted = bootedSimulatorLinesForTarget(lines, simulatorUdid);
    if (simulatorUdid ? targetBooted.length : booted.length) return { deviceSet, booted, targetBooted };
  }
  return { deviceSet: deviceSets[0], booted: [], targetBooted: [] };
}

/** Find the set that knows this UDID in any state (build-only runs need no booted device). */
export function findSimulatorDeviceSet(deviceSets, listDevices, simulatorUdid) {
  for (const deviceSet of deviceSets) {
    try {
      if (listDevices(deviceSet).toUpperCase().includes(`(${simulatorUdid.toUpperCase()})`)) return deviceSet;
    } catch {
      // An unreadable candidate cannot own the device; keep looking.
    }
  }
  return null;
}

/** Probe app installation on the exact Host-owned Simulator without fallback. */
export function getSimulatorAppContainer(run, simulatorUdid, bundleId, deviceSet = null) {
  return run("xcrun", simctlArgs(deviceSet, [
    "get_app_container",
    simulatorUdid ?? "booted",
    bundleId,
    "app",
  ]));
}

/** Parse the optional Metro port shared by sim:start and sim:whoami. */
export function extractSimMetroPortArgs(args, defaultPort = 8081) {
  let port = defaultPort;
  let seen = false;
  const passthrough = [];

  for (let index = 0; index < args.length; index += 1) {
    const arg = args[index];
    let value = null;
    if (arg === "--port" || arg === "-p") {
      value = args[++index];
    } else if (arg.startsWith("--port=")) {
      value = arg.slice("--port=".length);
    } else {
      passthrough.push(arg);
      continue;
    }

    if (seen) throw new Error("Metro 端口只能传一次");
    seen = true;
    const parsed = Number(value);
    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
      throw new Error(`Metro 端口无效: ${value ?? "(缺失)"}`);
    }
    port = parsed;
  }

  return { port, explicit: seen, passthrough };
}

/** Parse the explicit simulator handoff permission used only by the personal Skill. */
export function extractSimTakeoverArgs(args) {
  let takeover = false;
  const passthrough = [];

  for (const arg of args) {
    if (arg === "--takeover") {
      if (takeover) throw new Error("--takeover 只能传一次");
      takeover = true;
    } else {
      passthrough.push(arg);
    }
  }

  return { takeover, passthrough };
}

/** Decide whether a listener has enough Cindy-specific identity for an explicit handoff. */
export function classifySimMetroListener({ cwd, source, targetWorktree, platform = process.platform }) {
  if (!cwd) return { confirmed: false, worktree: null };

  const normalizedCwd = normalize(cwd)
    .replaceAll("\\", "/")
    .replace(/\/+$/, "");
  const normalizedTarget = normalize(targetWorktree)
    .replaceAll("\\", "/")
    .replace(/\/+$/, "");
  const suffix = "/apps/mobile";
  if (!normalizedCwd.endsWith(suffix) || !source) {
    return { confirmed: false, worktree: null };
  }

  const worktree = normalizedCwd.slice(0, -suffix.length);
  const isTarget = platform === 'win32'
    ? worktree.toLowerCase() === normalizedTarget.toLowerCase()
    : worktree === normalizedTarget;
  return {
    confirmed: true,
    worktree,
    isTarget,
  };
}

/**
 * @typedef {object} SimMetroIdentity
 * @property {{ confirmed: boolean, isTarget?: boolean } | null} [listener]
 * @property {string | null} [currentSource]
 * @property {string | null} [runningSource]
 * @property {string} [currentRegion]
 * @property {string | null} [runningRegion]
 * @property {string} [currentEnvFingerprint]
 * @property {string | null} [runningEnvFingerprint]
 * @property {boolean} [envChanged]
 */
/**
 * Shared freshness verdict. Missing evidence must never count as a match.
 * @param {SimMetroIdentity} [input]
 */
export function validateSimMetroIdentity({
  listener, currentSource, runningSource, currentRegion, runningRegion,
  currentEnvFingerprint, runningEnvFingerprint, envChanged = false,
} = {}) {
  let code = 'target-fresh';
  if (!listener?.confirmed) code = 'occupied-unknown';
  else if (!listener.isTarget) code = 'occupied-foreign';
  else if (!currentSource || runningSource !== currentSource) code = 'target-stale';
  else if (currentRegion !== undefined && runningRegion !== currentRegion) code = 'target-region-stale';
  else if (envChanged || (currentEnvFingerprint !== undefined && runningEnvFingerprint !== currentEnvFingerprint)) code = 'target-env-stale';
  return { healthy: code === 'target-fresh', code };
}

/**
 * Assemble the whoami Metro receipt and its start-hint decision. The CLI and
 * unit tests use this same entry; only read-only process I/O is injectable.
 */
export function inspectSimMetroIdentity({
  ports, expectedPort, worktreeRoot, expectedSource, region, envFingerprint,
}, {
  inspectListeners = inspectMetroListeners,
  probeOwnership = probeMetroOwnership,
  timedCheck = (_stage, run) => run(),
} = {}) {
  const probeErrors = [];
  const metros = [];
  let anyMetro = false;
  let currentSourceOnExpectedPort = false;
  const listeners = timedCheck("metro-listeners", () => inspectListeners(ports));
  if (!listeners.healthy) probeErrors.push({ stage: "metro-listeners", code: listeners.code });
  for (const port of ports) {
    if (!listeners.pids[port]) continue;
    const ownership = timedCheck(`metro-${port}`, () => probeOwnership(port, {
      listenerPid: () => listeners.pids[port],
      onProbeError: (error) => probeErrors.push({ port, ...error }),
    }));
    if (!ownership) continue;
    const listener = classifySimMetroListener({
      cwd: ownership.cwd, source: ownership.source, targetWorktree: worktreeRoot,
    });
    const identity = validateSimMetroIdentity({
      listener, currentSource: expectedSource, runningSource: ownership.source,
      currentRegion: region, runningRegion: ownership.region,
      currentEnvFingerprint: envFingerprint, runningEnvFingerprint: ownership.envFingerprint,
    });
    anyMetro ||= listener.confirmed;
    metros.push({ port, ...ownership, pid: Number(ownership.pid), worktree: listener.worktree,
      isMetro: listener.confirmed, identity });
    if (port === expectedPort) currentSourceOnExpectedPort = identity.healthy;
  }
  return {
    healthy: currentSourceOnExpectedPort && probeErrors.length === 0,
    anyMetro, currentSourceOnExpectedPort, metros, probeErrors,
    canSuggestStart: !anyMetro && probeErrors.length === 0,
  };
}

/**
 * Decide whether sim:start should reuse, restart, or refuse the occupant on 8081.
 *
 * `--takeover` may stop a confirmed Cindy Metro (cwd ends with /apps/mobile and
 * the process has an injected source token). It does not require the occupying
 * worktree's live git fingerprint to still match the running Metro. A missing
 * worktree is an orphan Metro and is also eligible. Unknown occupants stay
 * fail-closed even with `--takeover`.
 * @param {SimMetroIdentity & { port?: number, cwd?: string | null, takeover?: boolean, listenerWorktreeExists?: boolean }} [input]
 */
export function resolveSimMetroHandoff({
  port = 8081,
  cwd = null,
  takeover = false,
  envChanged = false,
  currentSource,
  runningSource,
  currentRegion,
  runningRegion,
  currentEnvFingerprint,
  runningEnvFingerprint,
  listener,
  listenerWorktreeExists = false,
} = {}) {
  const occupant = cwd || "(未知进程)";
  const identity = validateSimMetroIdentity({ listener, currentSource, runningSource,
    currentRegion, runningRegion, currentEnvFingerprint, runningEnvFingerprint, envChanged });

  if (!listener?.confirmed) {
    return {
      action: "refuse",
      code: "occupied-unknown",
      lines: [
        `✗ 端口 ${port} 被其他进程占用:${occupant}`,
        "  不是可确认的 Cindy Metro(需要 .../apps/mobile 工作目录 + 注入的源码指纹)。",
        "  未知进程即使传 `--takeover` 也不会停。",
      ],
    };
  }

  if (listener.isTarget) {
    if (identity.code !== "target-stale") {
      const regionChanged = identity.code === "target-region-stale";
      const environmentChanged = identity.code === "target-env-stale";
      if ((envChanged || regionChanged || environmentChanged) && !takeover) {
        return {
          action: 'refuse',
          code: regionChanged ? 'target-region-stale' : 'target-env-stale',
          lines: [
            `✗ apps/mobile/.env 或 --mock 模拟数据开关变了,但 ${port} 上的 Metro 是用旧 env 启动的(env 在 bundle 时注入)。`,
            "  需要刷新 env 时传 `--takeover` 重起,新 env 才会生效。",
          ],
        };
      }
      if ((envChanged || regionChanged || environmentChanged) && takeover) {
        return { action: 'restart', code: regionChanged ? 'target-region' : 'target-env', lines: [] };
      }
      return {
        action: "reuse",
        code: "target-fresh",
        lines: [
          `✓ Metro 已在 ${port} 运行(本 worktree,源码指纹 ${currentSource})。改 JS 直接 Fast Refresh,无需重开。`,
        ],
      };
    }
    if (!takeover) {
      return {
        action: "refuse",
        code: "target-stale",
        lines: [
          `✗ ${port} 上是本 worktree 的 Metro,但源码指纹已过期(运行中=${runningSource || "(无)"} ≠ 当前=${currentSource})。`,
          "  这通常表示 Metro 启动后又 amend/rebase/reset/改过文件。需要接管时传 `--takeover` 重起。",
        ],
      };
    }
    return { action: "restart", code: "target-stale", lines: [] };
  }

  if (!listenerWorktreeExists) {
    if (!takeover) {
      return {
        action: "refuse",
        code: "occupied-orphan",
        lines: [
          `✗ 端口 ${port} 被已删除 worktree 的孤儿 Metro 占用:${occupant}`,
          "  该目录已不存在,进程还占着端口。确认可以清掉时传 `--takeover`。",
        ],
      };
    }
    return { action: "restart", code: "occupied-orphan", lines: [] };
  }

  if (!takeover) {
    return {
      action: "refuse",
      code: "occupied-foreign",
      lines: [
        `✗ 端口 ${port} 被其他 Cindy worktree 的 Metro 占用:${occupant}`,
        "  当前版本需要这块端口。确认可以切换时传 `--takeover`。",
      ],
    };
  }
  return { action: "restart", code: "occupied-foreign", lines: [] };
}

/** Parse the machine-readable output switch for mobile:sim:whoami. */
export function extractSimJsonArgs(args) {
  let json = false;
  const passthrough = [];

  for (const arg of args) {
    if (arg === "--json") {
      if (json) throw new Error("--json 只能传一次");
      json = true;
    } else {
      passthrough.push(arg);
    }
  }

  return { json, passthrough };
}

/**
 * 用实际 Expo config 解析本地 Simulator development client 的 bundle id。
 * 测试可注入 execFile,避免真的启动 Expo CLI。
 */
export function resolveMobileSimulatorBundleId(region, options = {}) {
  const run =
    options.execFile ??
    ((command, args, opts) => {
      if (command !== "pnpm") return execFileSync(command, args, opts);
      const invocation = resolvePnpmInvocation(
        ["exec", "expo", "config", "--type", "public", "--json"],
        {
          npmExecPath: usablePnpmExecPath(process.env.npm_execpath, existsSync),
        },
      );
      return execFileSync(invocation.command, invocation.args, {
        ...opts,
        env: { ...opts.env, ...(invocation.env ?? {}) },
      });
    });
  const buildEnv = withLocalMobileRegionConfig(
    mobileClientBundleEnv({ authRegion: region }),
  );
  let raw;
  try {
    raw = run(
      "pnpm",
      ["exec", "expo", "config", "--type", "public", "--json"],
      {
        cwd: options.mobileDir ?? mobileDir,
        env: { ...(options.env ?? process.env), ...buildEnv },
        encoding: "utf8",
        stdio: ["ignore", "pipe", "pipe"],
        timeout: 30_000,
        killSignal: "SIGKILL",
      },
    );
  } catch (error) {
    if (error?.code === "ETIMEDOUT") {
      throw Object.assign(new Error(`Expo config 解析 ${region} Simulator bundle id 超时(30s);检查当前 worktree 依赖和 Expo 配置后重试。`), { code: "EXPO_CONFIG_TIMEOUT" });
    }
    const detail = String(error?.stderr ?? error?.message ?? error).trim();
    throw new Error(
      `无法解析 ${region} Simulator bundle id${detail ? `: ${detail}` : ""}`,
      { cause: error },
    );
  }

  let config;
  try {
    config = JSON.parse(String(raw));
  } catch (error) {
    throw new Error(`Expo config 未返回合法 JSON(region=${region})`, {
      cause: error,
    });
  }
  const bundleId = config?.ios?.bundleIdentifier;
  if (typeof bundleId !== "string" || !bundleId.trim()) {
    throw new Error(`Expo config 缺少 ios.bundleIdentifier(region=${region})`);
  }
  return bundleId.trim();
}