happy-imou-cloud 2.1.49 → 2.1.51

package/dist/codex-DLGP8WF6.mjs

@@ -0,0 +1,577 @@
+import { A as AcpBackend } from './AcpBackend-CqO3D07V.mjs';
+import { a as agentRegistry } from './RuntimeShell-BDt42io_.mjs';
+import { l as logger } from './types-B5vtxa38.mjs';
+import { p as projectPath, C as CodexTransport } from './index-CX-F_fuk.mjs';
+import { r as resolveCommandOnPath, a as resolveCodexAcpSpawn } from './resolveCommand-B3BGyBE2.mjs';
+import fs, { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, readdirSync, cpSync, statSync, realpathSync } from 'node:fs';
+import os, { homedir, tmpdir } from 'node:os';
+import path, { join, relative, isAbsolute, normalize, dirname, basename } from 'node:path';
+
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveCodexExecutable() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    const npmGlobalBin = path.join(appData, "npm");
+    const resolved = firstExistingPath([
+      path.join(npmGlobalBin, "codex.cmd"),
+      path.join(npmGlobalBin, "codex.ps1"),
+      path.join(npmGlobalBin, "codex")
+    ]);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return "codex";
+}
+function shouldUseShellForCodex(executable) {
+  return process.platform === "win32" && /\.(cmd|bat|ps1)$/i.test(executable);
+}
+
+const CODEX_HOME_SEED_FILES = [
+  "auth.json",
+  "config.toml",
+  "cap_sid",
+  "version.json",
+  "MEMORY.md"
+];
+const CODEX_HOME_SEED_DIRS = [
+  "rules"
+];
+const MAX_CODEX_SKILL_DESCRIPTION_LENGTH = 1024;
+const MANAGED_CODEX_HOME_PREFIX = "happy-codex-home-";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isApiKeyOnlyCodexAuth(value) {
+  if (!isPlainObject(value)) {
+    return false;
+  }
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0 && entryValue !== null);
+  return entries.length === 1 && typeof value.OPENAI_API_KEY === "string" && value.OPENAI_API_KEY.trim().length > 0;
+}
+function shouldUseSourceCodexHomeForMutableAuth(sourceHomeDir) {
+  try {
+    const auth = JSON.parse(readFileSync(join(sourceHomeDir, "auth.json"), "utf8"));
+    return !isApiKeyOnlyCodexAuth(auth);
+  } catch {
+    return false;
+  }
+}
+function getCodexPlatformTarget(platform, arch) {
+  if (platform === "win32" && arch === "x64") {
+    return {
+      packageName: "codex-win32-x64",
+      targetTriple: "x86_64-pc-windows-msvc"
+    };
+  }
+  if (platform === "win32" && arch === "arm64") {
+    return {
+      packageName: "codex-win32-arm64",
+      targetTriple: "aarch64-pc-windows-msvc"
+    };
+  }
+  if ((platform === "linux" || platform === "android") && arch === "x64") {
+    return {
+      packageName: "codex-linux-x64",
+      targetTriple: "x86_64-unknown-linux-musl"
+    };
+  }
+  if ((platform === "linux" || platform === "android") && arch === "arm64") {
+    return {
+      packageName: "codex-linux-arm64",
+      targetTriple: "aarch64-unknown-linux-musl"
+    };
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return {
+      packageName: "codex-darwin-x64",
+      targetTriple: "x86_64-apple-darwin"
+    };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return {
+      packageName: "codex-darwin-arm64",
+      targetTriple: "aarch64-apple-darwin"
+    };
+  }
+  return null;
+}
+function dedupePaths(paths, platform) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const entry of paths) {
+    const normalized = normalize(entry);
+    const key = platform === "win32" ? normalized.toLowerCase() : normalized;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(entry);
+  }
+  return unique;
+}
+function getPathDelimiter(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function resolveCodexShimPath({
+  platform = process.platform,
+  exists = existsSync,
+  resolveExecutable = resolveCodexExecutable,
+  resolveOnPath = resolveCommandOnPath
+}) {
+  const resolvedExecutable = resolveExecutable();
+  if (isAbsolute(resolvedExecutable) && exists(resolvedExecutable)) {
+    return resolvedExecutable;
+  }
+  const commandNames = platform === "win32" ? ["codex.cmd", "codex.ps1", "codex"] : ["codex"];
+  for (const commandName of commandNames) {
+    const resolved = resolveOnPath(commandName);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveCodexPackageRoots(executablePath, {
+  platform = process.platform,
+  exists = existsSync,
+  realpath = realpathSync
+}) {
+  const executableDir = dirname(executablePath);
+  const candidates = [
+    join(executableDir, "node_modules", "@openai", "codex"),
+    join(executableDir, "..", "lib", "node_modules", "@openai", "codex")
+  ];
+  try {
+    const realExecutablePath = realpath(executablePath);
+    candidates.push(join(dirname(realExecutablePath), ".."));
+  } catch {
+  }
+  return dedupePaths(
+    candidates.filter((candidate) => exists(candidate)),
+    platform
+  );
+}
+function resolvePathEnvKey(env) {
+  return Object.prototype.hasOwnProperty.call(env, "Path") && !Object.prototype.hasOwnProperty.call(env, "PATH") ? "Path" : "PATH";
+}
+function resolveBundledCodexToolPathDirs(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const codexTarget = getCodexPlatformTarget(platform, arch);
+  if (!codexTarget) {
+    return [];
+  }
+  const codexShimPath = resolveCodexShimPath(options);
+  if (!codexShimPath) {
+    return [];
+  }
+  const packageRoots = resolveCodexPackageRoots(codexShimPath, options);
+  if (packageRoots.length === 0) {
+    return [];
+  }
+  const exists = options.exists ?? existsSync;
+  const candidates = packageRoots.flatMap((packageRoot) => [
+    join(packageRoot, "vendor", codexTarget.targetTriple, "path"),
+    join(
+      packageRoot,
+      "node_modules",
+      "@openai",
+      codexTarget.packageName,
+      "vendor",
+      codexTarget.targetTriple,
+      "path"
+    )
+  ]);
+  return dedupePaths(
+    candidates.filter((candidate) => exists(candidate)),
+    platform
+  );
+}
+function buildCodexAcpEnv(overrides = {}, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const pathDelimiter = getPathDelimiter(platform);
+  const env = {
+    ...process.env,
+    ...overrides
+  };
+  const pathKey = resolvePathEnvKey(env);
+  const alternatePathKey = pathKey === "PATH" ? "Path" : "PATH";
+  const currentPathValue = env[pathKey] ?? env[alternatePathKey] ?? "";
+  const currentPathEntries = currentPathValue.split(pathDelimiter).filter(Boolean);
+  const codexToolDirs = resolveBundledCodexToolPathDirs(options);
+  const mergedPathEntries = dedupePaths(
+    [...codexToolDirs, ...currentPathEntries],
+    platform
+  );
+  if (mergedPathEntries.length > 0) {
+    env[pathKey] = mergedPathEntries.join(pathDelimiter);
+  }
+  delete env[alternatePathKey];
+  const stringEnvEntries = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") {
+      stringEnvEntries.push([key, value]);
+    }
+  }
+  return Object.fromEntries(stringEnvEntries);
+}
+function copyCodexHomeEntry(sourcePath, destPath) {
+  if (!existsSync(sourcePath)) {
+    return;
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  cpSync(sourcePath, destPath, {
+    recursive: true,
+    force: true,
+    dereference: false,
+    verbatimSymlinks: true
+  });
+}
+function normalizePathForComparison(path, platform) {
+  const normalizedPath = normalize(path).replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+}
+function isManagedTemporaryCodexHomePath(path, platform) {
+  const trimmedPath = path.trim();
+  if (!trimmedPath) {
+    return false;
+  }
+  const pathBaseName = trimmedPath.replace(/[\\/]+$/, "").split(/[\\/]/).at(-1) ?? "";
+  if (!pathBaseName.startsWith(MANAGED_CODEX_HOME_PREFIX)) {
+    return false;
+  }
+  const normalizedTempRoot = normalizePathForComparison(tmpdir(), platform);
+  const normalizedPath = normalizePathForComparison(trimmedPath, platform);
+  return normalizedPath.startsWith(`${normalizedTempRoot}/`);
+}
+function extractSkillDescriptionFromFrontmatter(frontmatter) {
+  const lines = frontmatter.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const match = /^description:\s*(.*)$/.exec(line);
+    if (!match) {
+      continue;
+    }
+    const remainder = match[1]?.trim() ?? "";
+    if (!remainder || remainder === "|" || remainder === ">") {
+      const descriptionLines = [];
+      for (let offset = index + 1; offset < lines.length; offset++) {
+        const descriptionLine = lines[offset] ?? "";
+        if (descriptionLine.length > 0 && !/^\s/.test(descriptionLine)) {
+          break;
+        }
+        descriptionLines.push(descriptionLine.replace(/^\s{2}/, ""));
+      }
+      return descriptionLines.join("\n").trim();
+    }
+    return remainder.replace(/^['"]|['"]$/g, "").trim();
+  }
+  return null;
+}
+function extractSkillDescription(skillManifestPath) {
+  const manifest = readFileSync(skillManifestPath, "utf8");
+  const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(manifest);
+  const frontmatter = frontmatterMatch?.[1];
+  if (!frontmatter) {
+    return null;
+  }
+  return extractSkillDescriptionFromFrontmatter(frontmatter);
+}
+function shouldSeedCodexSkillEntry(sourcePath) {
+  if (basename(sourcePath) === ".system") {
+    return true;
+  }
+  const manifestPath = join(sourcePath, "SKILL.md");
+  if (!existsSync(manifestPath)) {
+    return true;
+  }
+  try {
+    const description = extractSkillDescription(manifestPath);
+    if (description && description.length > MAX_CODEX_SKILL_DESCRIPTION_LENGTH) {
+      logger.debug(
+        `[codex] Skipping CODEX_HOME skill entry ${sourcePath} because its description exceeds ${MAX_CODEX_SKILL_DESCRIPTION_LENGTH} characters`
+      );
+      return false;
+    }
+  } catch (error) {
+    logger.debug(`[codex] Failed to inspect CODEX_HOME skill entry ${sourcePath}`, error);
+  }
+  return true;
+}
+function seedCodexSkillEntries(sourceSkillsDir, isolatedHomeDir, sourceLabel) {
+  if (!existsSync(sourceSkillsDir)) {
+    return;
+  }
+  const destSkillsDir = join(isolatedHomeDir, "skills");
+  mkdirSync(destSkillsDir, { recursive: true });
+  for (const entryName of readdirSync(sourceSkillsDir)) {
+    const sourceEntryPath = join(sourceSkillsDir, entryName);
+    if (!shouldSeedCodexSkillEntry(sourceEntryPath)) {
+      continue;
+    }
+    try {
+      copyCodexHomeEntry(
+        sourceEntryPath,
+        join(destSkillsDir, entryName)
+      );
+    } catch (error) {
+      logger.debug(`[codex] Failed to seed CODEX_HOME skills entry ${entryName} from ${sourceLabel}`, error);
+    }
+  }
+}
+function isWithinDirectory(parentDir, childPath, platform) {
+  const normalizedParent = normalizePathForComparison(parentDir, platform);
+  const normalizedChild = normalizePathForComparison(childPath, platform);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function extractCodexSessionIdFromFilePath(filePath) {
+  const match = filePath.match(/-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/);
+  return match?.[1] ?? null;
+}
+function findCodexSessionFile(sourceHomeDir, resumeSessionId, platform) {
+  const sessionsRoot = join(sourceHomeDir, "sessions");
+  const stack = [sessionsRoot];
+  let bestMatch = null;
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (!isWithinDirectory(sessionsRoot, fullPath, platform)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || extractCodexSessionIdFromFilePath(fullPath) !== resumeSessionId) {
+        continue;
+      }
+      try {
+        const mtimeMs = statSync(fullPath).mtimeMs;
+        if (!bestMatch || mtimeMs > bestMatch.mtimeMs) {
+          bestMatch = { path: fullPath, mtimeMs };
+        }
+      } catch {
+      }
+    }
+  }
+  return bestMatch?.path ?? null;
+}
+function seedCodexResumeSessionFile(sourceHomeDir, isolatedHomeDir, resumeSessionId, platform) {
+  const normalizedResumeSessionId = typeof resumeSessionId === "string" && resumeSessionId.trim() ? resumeSessionId.trim() : null;
+  if (!normalizedResumeSessionId) {
+    return;
+  }
+  const sourceSessionFile = findCodexSessionFile(sourceHomeDir, normalizedResumeSessionId, platform);
+  if (!sourceSessionFile) {
+    logger.debug(`[codex] No source CODEX_HOME session file found for resume id ${normalizedResumeSessionId}`);
+    return;
+  }
+  const sourceSessionsRoot = join(sourceHomeDir, "sessions");
+  const relativeSessionPath = relative(sourceSessionsRoot, sourceSessionFile);
+  if (!relativeSessionPath || relativeSessionPath.startsWith("..") || isAbsolute(relativeSessionPath)) {
+    logger.debug(`[codex] Refusing to seed CODEX_HOME session outside sessions root: ${sourceSessionFile}`);
+    return;
+  }
+  try {
+    copyCodexHomeEntry(
+      sourceSessionFile,
+      join(isolatedHomeDir, "sessions", relativeSessionPath)
+    );
+  } catch (error) {
+    logger.debug(`[codex] Failed to seed CODEX_HOME session file for ${normalizedResumeSessionId}`, error);
+  }
+}
+function shouldSyncCodexSessionFileBack(sourcePath, destPath) {
+  let sourceStat;
+  try {
+    sourceStat = statSync(sourcePath);
+  } catch {
+    return false;
+  }
+  if (!sourceStat.isFile()) {
+    return false;
+  }
+  let destStat;
+  try {
+    destStat = statSync(destPath);
+  } catch {
+    return true;
+  }
+  return sourceStat.mtimeMs >= destStat.mtimeMs || sourceStat.size !== destStat.size;
+}
+function syncCodexSessionFilesBackToSource(isolatedHomeDir, sourceHomeDir, platform) {
+  const isolatedSessionsRoot = join(isolatedHomeDir, "sessions");
+  const sourceSessionsRoot = join(sourceHomeDir, "sessions");
+  const stack = [isolatedSessionsRoot];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (!isWithinDirectory(isolatedSessionsRoot, fullPath, platform)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || extractCodexSessionIdFromFilePath(fullPath) === null) {
+        continue;
+      }
+      const relativeSessionPath = relative(isolatedSessionsRoot, fullPath);
+      if (!relativeSessionPath || relativeSessionPath.startsWith("..") || isAbsolute(relativeSessionPath)) {
+        logger.debug(`[codex] Refusing to sync CODEX_HOME session outside sessions root: ${fullPath}`);
+        continue;
+      }
+      const destPath = join(sourceSessionsRoot, relativeSessionPath);
+      if (!shouldSyncCodexSessionFileBack(fullPath, destPath)) {
+        continue;
+      }
+      try {
+        copyCodexHomeEntry(fullPath, destPath);
+      } catch (error) {
+        logger.debug(`[codex] Failed to sync CODEX_HOME session file back to source: ${fullPath}`, error);
+      }
+    }
+  }
+}
+function seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir, resumeSessionId, platform) {
+  if (existsSync(sourceHomeDir)) {
+    for (const fileName of CODEX_HOME_SEED_FILES) {
+      try {
+        copyCodexHomeEntry(join(sourceHomeDir, fileName), join(isolatedHomeDir, fileName));
+      } catch (error) {
+        logger.debug(`[codex] Failed to seed CODEX_HOME file ${fileName}`, error);
+      }
+    }
+    for (const dirName of CODEX_HOME_SEED_DIRS) {
+      try {
+        copyCodexHomeEntry(join(sourceHomeDir, dirName), join(isolatedHomeDir, dirName));
+      } catch (error) {
+        logger.debug(`[codex] Failed to seed CODEX_HOME directory ${dirName}`, error);
+      }
+    }
+  }
+  if (bundledSkillsDir) {
+    seedCodexSkillEntries(bundledSkillsDir, isolatedHomeDir, "bundled skills");
+  }
+  seedCodexSkillEntries(join(sourceHomeDir, "skills"), isolatedHomeDir, "source CODEX_HOME");
+  seedCodexResumeSessionFile(sourceHomeDir, isolatedHomeDir, resumeSessionId, platform);
+}
+function prepareCodexAcpEnvironment(overrides = {}, options = {}) {
+  const env = buildCodexAcpEnv(overrides, options);
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    return { env };
+  }
+  const explicitCodexHome = typeof overrides.CODEX_HOME === "string" ? overrides.CODEX_HOME.trim() : "";
+  const existingCodexHome = typeof env.CODEX_HOME === "string" ? env.CODEX_HOME.trim() : "";
+  if (existingCodexHome) {
+    if (!explicitCodexHome && isManagedTemporaryCodexHomePath(existingCodexHome, platform)) {
+      logger.debug(`[codex] Ignoring inherited managed CODEX_HOME ${existingCodexHome} and rebuilding an isolated home`);
+      delete env.CODEX_HOME;
+    } else {
+      return { env };
+    }
+  }
+  const sourceHomeDir = options.sourceHomeDir ?? join(homedir(), ".codex");
+  const bundledSkillsDir = options.bundledSkillsDir ?? join(projectPath(), "skills");
+  if (shouldUseSourceCodexHomeForMutableAuth(sourceHomeDir)) {
+    logger.debug("[codex] Using source CODEX_HOME for mutable Codex auth credentials");
+    env.CODEX_HOME = sourceHomeDir;
+    return {
+      env,
+      codexHomePath: sourceHomeDir
+    };
+  }
+  const tempDirFactory = options.tempDirFactory ?? mkdtempSync;
+  const isolatedHomeDir = tempDirFactory(join(tmpdir(), "happy-codex-home-"));
+  mkdirSync(isolatedHomeDir, { recursive: true });
+  seedIsolatedCodexHome(sourceHomeDir, isolatedHomeDir, bundledSkillsDir, options.resumeSessionId, platform);
+  env.CODEX_HOME = isolatedHomeDir;
+  return {
+    env,
+    codexHomePath: isolatedHomeDir,
+    cleanup: () => {
+      syncCodexSessionFilesBackToSource(isolatedHomeDir, sourceHomeDir, platform);
+      rmSync(isolatedHomeDir, { recursive: true, force: true });
+    }
+  };
+}
+
+class CodexAcpTransport extends CodexTransport {
+  constructor(initTimeoutMs) {
+    super();
+    this.initTimeoutMs = initTimeoutMs;
+  }
+  getInitTimeout() {
+    return this.initTimeoutMs;
+  }
+}
+function resolveCodexTransport(command) {
+  if (/npx(?:\.cmd)?$/i.test(command)) {
+    return new CodexAcpTransport(18e4);
+  }
+  return new CodexAcpTransport(6e4);
+}
+function createCodexBackend(options) {
+  const spawn = resolveCodexAcpSpawn({
+    command: options.command,
+    args: options.args,
+    baseArgs: options.baseArgs,
+    model: options.model,
+    sandbox: options.sandbox,
+    approvalPolicy: options.approvalPolicy
+  });
+  const preparedEnv = prepareCodexAcpEnvironment({
+    ...options.env,
+    NODE_ENV: "production"
+  }, {
+    resumeSessionId: options.resumeSessionId
+  });
+  const backendOptions = {
+    agentName: "codex",
+    cwd: options.cwd,
+    command: spawn.command,
+    args: spawn.args,
+    env: preparedEnv.env,
+    permissionHandler: options.permissionHandler,
+    selectionHandler: options.selectionHandler,
+    transportHandler: resolveCodexTransport(spawn.command),
+    resourceCleanup: preparedEnv.cleanup,
+    resumeSessionId: options.resumeSessionId
+  };
+  return {
+    backend: new AcpBackend(backendOptions),
+    command: spawn.command,
+    args: spawn.args
+  };
+}
+function registerCodexAgent() {
+  agentRegistry.register("codex", (opts) => createCodexBackend(opts).backend);
+}
+
+export { resolveCodexExecutable as a, createCodexBackend as c, registerCodexAgent as r, shouldUseShellForCodex as s };