@gakr-gakr/codex 0.1.0 → 0.1.1

package/src/migration/source.ts

@@ -1,643 +0,0 @@
-import type { Dirent } from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import {
-  defaultCodexAppInventoryCache,
-  type CodexAppInventoryRequest,
-} from "../app-server/app-inventory-cache.js";
-import { CODEX_PLUGINS_MARKETPLACE_NAME } from "../app-server/config.js";
-import type { CodexAppServerStartOptions } from "../app-server/config.js";
-import { buildCodexPluginAppCacheKey } from "../app-server/plugin-app-cache-key.js";
-import {
-  pluginReadParams,
-  type CodexPluginMarketplaceRef,
-} from "../app-server/plugin-inventory.js";
-import type { CodexGetAccountResponse, v2 } from "../app-server/protocol.js";
-import { requestCodexAppServerJson } from "../app-server/request.js";
-import {
-  exists,
-  isDirectory,
-  readJsonObject,
-  resolveHomePath,
-  resolveUserHomeDir,
-} from "./helpers.js";
-
-const SKILL_FILENAME = "SKILL.md";
-const MAX_SCAN_DEPTH = 6;
-const MAX_DISCOVERED_DIRS = 2000;
-
-export type CodexSkillSource = {
-  name: string;
-  source: string;
-  sourceLabel: string;
-};
-
-export type CodexPluginSource = {
-  name: string;
-  source: string;
-  sourceKind: "app-server" | "cache";
-  migratable: boolean;
-  manifestPath?: string;
-  marketplaceName?: typeof CODEX_PLUGINS_MARKETPLACE_NAME;
-  pluginName?: string;
-  installed?: boolean;
-  enabled?: boolean;
-  apps?: CodexPluginMigrationAppFact[];
-  migrationBlock?: CodexPluginMigrationBlock;
-  message?: string;
-};
-
-export type CodexPluginMigrationBlockCode =
-  | "plugin_disabled"
-  | "codex_subscription_required"
-  | "codex_account_unavailable"
-  | "plugin_read_unavailable"
-  | "app_inventory_unavailable"
-  | "app_inaccessible"
-  | "app_disabled"
-  | "app_missing";
-
-export type CodexPluginMigrationAppFact = {
-  id: string;
-  name: string;
-  needsAuth?: boolean;
-  isAccessible?: boolean;
-  isEnabled?: boolean;
-};
-
-export type CodexPluginMigrationBlock = {
-  code: CodexPluginMigrationBlockCode;
-  apps?: CodexPluginMigrationAppFact[];
-  error?: string;
-};
-
-type CodexArchiveSource = {
-  id: string;
-  path: string;
-  relativePath: string;
-  message?: string;
-};
-
-type CodexSource = {
-  root: string;
-  confidence: "low" | "medium" | "high";
-  codexHome: string;
-  codexSkillsDir?: string;
-  personalAgentsSkillsDir?: string;
-  configPath?: string;
-  hooksPath?: string;
-  skills: CodexSkillSource[];
-  plugins: CodexPluginSource[];
-  pluginDiscoveryError?: string;
-  archivePaths: CodexArchiveSource[];
-};
-
-type CodexSourceDiscoveryOptions = {
-  input?: string;
-  evaluatePluginMigrationEligibility?: boolean;
-  verifyPluginApps?: boolean;
-};
-
-type SourceAppServerRequestOptions = {
-  startOptions: CodexAppServerStartOptions;
-};
-
-type PluginReadResult =
-  | {
-      ok: true;
-      detail: v2.PluginDetail;
-    }
-  | {
-      ok: false;
-      error: string;
-    };
-
-function defaultCodexHome(): string {
-  return resolveHomePath(process.env.CODEX_HOME?.trim() || "~/.codex");
-}
-
-function personalAgentsSkillsDir(): string {
-  return path.join(resolveUserHomeDir(), ".agents", "skills");
-}
-
-async function safeReadDir(dir: string): Promise<Dirent[]> {
-  return await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-}
-
-async function discoverSkillDirs(params: {
-  root: string | undefined;
-  sourceLabel: string;
-  excludeSystem?: boolean;
-}): Promise<CodexSkillSource[]> {
-  if (!params.root || !(await isDirectory(params.root))) {
-    return [];
-  }
-  const discovered: CodexSkillSource[] = [];
-  async function visit(dir: string, depth: number): Promise<void> {
-    if (discovered.length >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) {
-      return;
-    }
-    const name = path.basename(dir);
-    if (params.excludeSystem && depth === 1 && name === ".system") {
-      return;
-    }
-    if (await exists(path.join(dir, SKILL_FILENAME))) {
-      discovered.push({ name, source: dir, sourceLabel: params.sourceLabel });
-      return;
-    }
-    for (const entry of await safeReadDir(dir)) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      await visit(path.join(dir, entry.name), depth + 1);
-    }
-  }
-  await visit(params.root, 0);
-  return discovered;
-}
-
-async function discoverPluginDirs(codexHome: string): Promise<CodexPluginSource[]> {
-  const root = path.join(codexHome, "plugins", "cache");
-  if (!(await isDirectory(root))) {
-    return [];
-  }
-  const discovered = new Map<string, CodexPluginSource>();
-  async function visit(dir: string, depth: number): Promise<void> {
-    if (discovered.size >= MAX_DISCOVERED_DIRS || depth > MAX_SCAN_DEPTH) {
-      return;
-    }
-    const manifestPath = path.join(dir, ".codex-plugin", "plugin.json");
-    if (await exists(manifestPath)) {
-      const manifest = await readJsonObject(manifestPath);
-      const manifestName = typeof manifest.name === "string" ? manifest.name.trim() : "";
-      const name = manifestName || path.basename(dir);
-      discovered.set(dir, {
-        name,
-        source: dir,
-        manifestPath,
-        sourceKind: "cache",
-        migratable: false,
-        message:
-          "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory",
-      });
-      return;
-    }
-    for (const entry of await safeReadDir(dir)) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      await visit(path.join(dir, entry.name), depth + 1);
-    }
-  }
-  await visit(root, 0);
-  return [...discovered.values()].toSorted((a, b) => a.source.localeCompare(b.source));
-}
-
-async function discoverInstalledCuratedPlugins(
-  codexHome: string,
-  options: CodexSourceDiscoveryOptions = {},
-): Promise<{
-  plugins: CodexPluginSource[];
-  error?: string;
-}> {
-  const startOptions = sourceCodexAppServerStartOptions(codexHome);
-  const requestOptions = { startOptions };
-  try {
-    const response = await requestSourceCodexAppServerJson<v2.PluginListResponse>(requestOptions, {
-      method: "plugin/list",
-      requestParams: { cwds: [] } satisfies v2.PluginListParams,
-    });
-    const marketplace = response.marketplaces.find(
-      (entry) => entry.name === CODEX_PLUGINS_MARKETPLACE_NAME,
-    );
-    if (!marketplace) {
-      return {
-        plugins: [],
-        error: `Codex marketplace ${CODEX_PLUGINS_MARKETPLACE_NAME} was not found in source plugin inventory.`,
-      };
-    }
-    const plugins = marketplace.plugins
-      .filter((plugin) => plugin.installed)
-      .map((plugin) => buildInstalledPluginSource(plugin))
-      .filter((plugin): plugin is CodexPluginSource => plugin !== undefined);
-    const withEligibility =
-      options.evaluatePluginMigrationEligibility === true
-        ? await withPluginMigrationEligibility({
-            plugins,
-            marketplace: marketplaceRef(marketplace),
-            requestOptions,
-            verifyPluginApps: options.verifyPluginApps === true,
-          })
-        : plugins;
-    const sorted = withEligibility.toSorted((a, b) =>
-      (a.pluginName ?? a.name).localeCompare(b.pluginName ?? b.name),
-    );
-    return { plugins: sorted };
-  } catch (error) {
-    return {
-      plugins: [],
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-function sourceCodexAppServerStartOptions(codexHome: string): CodexAppServerStartOptions {
-  return {
-    transport: "stdio",
-    command: "codex",
-    commandSource: "managed",
-    args: ["app-server", "--listen", "stdio://"],
-    headers: {},
-    env: {
-      CODEX_HOME: codexHome,
-      HOME: path.dirname(codexHome),
-    },
-  };
-}
-
-async function requestSourceCodexAppServerJson<T>(
-  options: SourceAppServerRequestOptions,
-  params: {
-    method: string;
-    requestParams?: unknown;
-  },
-): Promise<T> {
-  return await requestCodexAppServerJson<T>({
-    method: params.method,
-    requestParams: params.requestParams,
-    timeoutMs: 60_000,
-    startOptions: options.startOptions,
-    authProfileId: null,
-    isolated: true,
-  });
-}
-
-function buildInstalledPluginSource(plugin: v2.PluginSummary): CodexPluginSource | undefined {
-  const pluginName = pluginNameFromSummary(plugin);
-  if (!pluginName) {
-    return undefined;
-  }
-  return {
-    name: plugin.name,
-    pluginName,
-    marketplaceName: CODEX_PLUGINS_MARKETPLACE_NAME,
-    source: `${CODEX_PLUGINS_MARKETPLACE_NAME}/${pluginName}`,
-    sourceKind: "app-server",
-    migratable: true,
-    installed: plugin.installed,
-    enabled: plugin.enabled,
-  };
-}
-
-function marketplaceRef(marketplace: v2.PluginMarketplaceEntry): CodexPluginMarketplaceRef {
-  return {
-    name: CODEX_PLUGINS_MARKETPLACE_NAME,
-    ...(marketplace.path ? { path: marketplace.path } : {}),
-    ...(!marketplace.path ? { remoteMarketplaceName: marketplace.name } : {}),
-  };
-}
-
-async function withPluginMigrationEligibility(params: {
-  plugins: CodexPluginSource[];
-  marketplace: CodexPluginMarketplaceRef;
-  requestOptions: SourceAppServerRequestOptions;
-  verifyPluginApps: boolean;
-}): Promise<CodexPluginSource[]> {
-  const pending: Array<{ plugin: CodexPluginSource; apps: CodexPluginMigrationAppFact[] }> = [];
-  const evaluated: CodexPluginSource[] = [];
-
-  for (const plugin of params.plugins) {
-    if (plugin.enabled !== true) {
-      evaluated.push({
-        ...plugin,
-        migratable: false,
-        migrationBlock: { code: "plugin_disabled" },
-        message: `Codex plugin "${plugin.pluginName ?? plugin.name}" is installed in Codex but disabled; enable it in Codex before migrating it to AutoBot.`,
-      });
-      continue;
-    }
-
-    const detail = await readPluginDetail(params.requestOptions, params.marketplace, plugin);
-    if (!detail.ok) {
-      evaluated.push({
-        ...plugin,
-        migratable: false,
-        migrationBlock: { code: "plugin_read_unavailable", error: detail.error },
-        message: `Codex plugin "${plugin.pluginName ?? plugin.name}" detail could not be read: ${detail.error}`,
-      });
-      continue;
-    }
-
-    if (detail.detail.apps.length === 0) {
-      evaluated.push({
-        ...plugin,
-        migratable: true,
-      });
-      continue;
-    }
-
-    const apps = detail.detail.apps
-      .map(sourcePluginAppFact)
-      .toSorted((left, right) => left.id.localeCompare(right.id));
-    pending.push({ plugin, apps });
-  }
-
-  if (pending.length === 0) {
-    return evaluated;
-  }
-
-  let sourceAccount: Awaited<ReturnType<typeof readSourceCodexAccount>> | undefined;
-  try {
-    sourceAccount = await readSourceCodexAccount(params.requestOptions);
-  } catch (error) {
-    if (!params.verifyPluginApps) {
-      const message = error instanceof Error ? error.message : String(error);
-      for (const { plugin, apps } of pending) {
-        evaluated.push({
-          ...plugin,
-          migratable: false,
-          migrationBlock: { code: "codex_account_unavailable", apps, error: message },
-          message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but the source Codex app-server account could not be read: ${message}`,
-        });
-      }
-      return evaluated;
-    }
-  }
-  if (sourceAccount && sourceAccount !== "chatgpt") {
-    for (const { plugin, apps } of pending) {
-      evaluated.push({
-        ...plugin,
-        migratable: false,
-        migrationBlock: { code: "codex_subscription_required", apps },
-        message: codexSubscriptionRequiredMessage(plugin),
-      });
-    }
-    return evaluated;
-  }
-
-  if (!params.verifyPluginApps) {
-    for (const { plugin, apps } of pending) {
-      evaluated.push({
-        ...plugin,
-        apps,
-        migratable: true,
-      });
-    }
-    return evaluated;
-  }
-
-  const snapshot = await refreshSourceAppInventory(params.requestOptions).catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    for (const { plugin, apps } of pending) {
-      evaluated.push({
-        ...plugin,
-        migratable: false,
-        migrationBlock: {
-          code: "app_inventory_unavailable",
-          apps,
-          error: message,
-        },
-        message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but source app inventory could not be read: ${message}`,
-      });
-    }
-    return undefined;
-  });
-  if (!snapshot) {
-    return evaluated;
-  }
-
-  const appInfoById = new Map(snapshot.apps.map((app) => [app.id, app] as const));
-  for (const { plugin, apps: declaredApps } of pending) {
-    const apps = declaredApps
-      .map((app) => sourcePluginAppFactWithInventory(app, appInfoById.get(app.id)))
-      .toSorted((left, right) => left.id.localeCompare(right.id));
-    const blockCode = migrationBlockCodeForApps(apps);
-    if (!blockCode) {
-      evaluated.push({ ...plugin, apps, migratable: true });
-      continue;
-    }
-    evaluated.push({
-      ...plugin,
-      migratable: false,
-      migrationBlock: { code: blockCode, apps },
-      message: appInventoryBlockMessage(plugin, apps, blockCode),
-    });
-  }
-
-  return evaluated;
-}
-
-async function readSourceCodexAccount(
-  options: SourceAppServerRequestOptions,
-): Promise<"chatgpt" | "non_chatgpt" | "missing"> {
-  const response = await requestSourceCodexAppServerJson<CodexGetAccountResponse>(options, {
-    method: "account/read",
-    requestParams: { refreshToken: false },
-  });
-  if (
-    !response.account ||
-    typeof response.account !== "object" ||
-    Array.isArray(response.account)
-  ) {
-    return "missing";
-  }
-  const type = response.account.type;
-  return type === "chatgpt" ? "chatgpt" : "non_chatgpt";
-}
-
-async function readPluginDetail(
-  options: SourceAppServerRequestOptions,
-  marketplace: CodexPluginMarketplaceRef,
-  plugin: CodexPluginSource,
-): Promise<PluginReadResult> {
-  try {
-    const response = await requestSourceCodexAppServerJson<v2.PluginReadResponse>(options, {
-      method: "plugin/read",
-      requestParams: pluginReadParams(marketplace, plugin.pluginName ?? plugin.name),
-    });
-    return { ok: true, detail: response.plugin };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-async function refreshSourceAppInventory(
-  options: SourceAppServerRequestOptions,
-): Promise<Awaited<ReturnType<typeof defaultCodexAppInventoryCache.refreshNow>>> {
-  const key = buildCodexPluginAppCacheKey({
-    appServer: { start: options.startOptions },
-  });
-  const request: CodexAppInventoryRequest = async (method, requestParams) =>
-    await requestSourceCodexAppServerJson<v2.AppsListResponse>(options, {
-      method,
-      requestParams,
-    });
-  return await defaultCodexAppInventoryCache.refreshNow({
-    key,
-    request,
-    forceRefetch: true,
-  });
-}
-
-function sourcePluginAppFact(app: v2.AppSummary): CodexPluginMigrationAppFact {
-  return {
-    id: app.id,
-    name: app.name,
-    needsAuth: app.needsAuth,
-  };
-}
-
-function sourcePluginAppFactWithInventory(
-  app: CodexPluginMigrationAppFact,
-  info: v2.AppInfo | undefined,
-): CodexPluginMigrationAppFact {
-  if (!info) {
-    return app;
-  }
-  return {
-    ...app,
-    isAccessible: info.isAccessible,
-    isEnabled: info.isEnabled,
-  };
-}
-
-function migrationBlockCodeForApps(
-  apps: readonly CodexPluginMigrationAppFact[],
-): CodexPluginMigrationBlockCode | undefined {
-  if (apps.some((app) => app.isAccessible === false)) {
-    return "app_inaccessible";
-  }
-  if (apps.some((app) => app.isEnabled === false)) {
-    return "app_disabled";
-  }
-  if (apps.some((app) => app.isAccessible === undefined || app.isEnabled === undefined)) {
-    return "app_missing";
-  }
-  return undefined;
-}
-
-function appInventoryBlockMessage(
-  plugin: CodexPluginSource,
-  apps: readonly CodexPluginMigrationAppFact[],
-  code: CodexPluginMigrationBlockCode,
-): string {
-  const status =
-    code === "app_inaccessible" ? "inaccessible" : code === "app_disabled" ? "disabled" : "missing";
-  const blocking =
-    apps.find((app) =>
-      code === "app_inaccessible"
-        ? app.isAccessible === false
-        : code === "app_disabled"
-          ? app.isEnabled === false
-          : app.isAccessible === undefined || app.isEnabled === undefined,
-    ) ?? apps[0];
-  const appLabel = blocking ? ` app "${blocking.name}"` : " an owned app";
-  return `Codex plugin "${plugin.pluginName ?? plugin.name}" owns${appLabel} but the source app inventory reports it is ${status}; authenticate or enable the app in Codex before migrating it to AutoBot.`;
-}
-
-export function codexPluginMigrationSubscriptionWarning(): string {
-  return "Codex app-backed plugin migration requires the Codex app-server source account to be logged in with a ChatGPT subscription account. Log in to the Codex app with subscription auth; AutoBot auth or API-key auth does not satisfy Codex app connector access.";
-}
-
-function codexSubscriptionRequiredMessage(plugin: CodexPluginSource): string {
-  return `Codex plugin "${plugin.pluginName ?? plugin.name}" owns apps, but ${codexPluginMigrationSubscriptionWarning()}`;
-}
-
-function pluginNameFromSummary(summary: v2.PluginSummary): string | undefined {
-  const candidates = [summary.id, summary.name];
-  for (const candidate of candidates) {
-    const trimmed = candidate.trim();
-    if (!trimmed) {
-      continue;
-    }
-    const withoutMarketplaceSuffix = trimmed.endsWith(`@${CODEX_PLUGINS_MARKETPLACE_NAME}`)
-      ? trimmed.slice(0, -`@${CODEX_PLUGINS_MARKETPLACE_NAME}`.length)
-      : trimmed;
-    const pathSegment = withoutMarketplaceSuffix.split("/").at(-1)?.trim();
-    const normalized = pathSegment?.toLowerCase().replaceAll(/\s+/gu, "-");
-    if (normalized) {
-      return normalized;
-    }
-  }
-  return undefined;
-}
-
-export async function discoverCodexSource(
-  inputOrOptions?: string | CodexSourceDiscoveryOptions,
-): Promise<CodexSource> {
-  const options =
-    typeof inputOrOptions === "string" || inputOrOptions === undefined
-      ? { input: inputOrOptions }
-      : inputOrOptions;
-  const codexHome = resolveHomePath(options.input?.trim() || defaultCodexHome());
-  const codexSkillsDir = path.join(codexHome, "skills");
-  const agentsSkillsDir = personalAgentsSkillsDir();
-  const configPath = path.join(codexHome, "config.toml");
-  const hooksPath = path.join(codexHome, "hooks", "hooks.json");
-  const codexSkills = await discoverSkillDirs({
-    root: codexSkillsDir,
-    sourceLabel: "Codex skill",
-    excludeSystem: true,
-  });
-  const personalAgentSkills = await discoverSkillDirs({
-    root: agentsSkillsDir,
-    sourceLabel: "personal AgentSkill",
-  });
-  const sourcePluginDiscovery = await discoverInstalledCuratedPlugins(codexHome, options);
-  const sourcePluginNames = new Set(
-    sourcePluginDiscovery.plugins.flatMap((plugin) =>
-      plugin.pluginName ? [plugin.pluginName] : [],
-    ),
-  );
-  const cachedPlugins = (await discoverPluginDirs(codexHome)).filter((plugin) => {
-    const normalizedName = sanitizePluginName(plugin.name);
-    return !sourcePluginNames.has(normalizedName);
-  });
-  const plugins = [...sourcePluginDiscovery.plugins, ...cachedPlugins].toSorted((a, b) =>
-    a.source.localeCompare(b.source),
-  );
-  const archivePaths: CodexArchiveSource[] = [];
-  if (await exists(configPath)) {
-    archivePaths.push({
-      id: "archive:config.toml",
-      path: configPath,
-      relativePath: "config.toml",
-      message: "Codex config is archived for manual review; it is not activated automatically",
-    });
-  }
-  if (await exists(hooksPath)) {
-    archivePaths.push({
-      id: "archive:hooks/hooks.json",
-      path: hooksPath,
-      relativePath: "hooks/hooks.json",
-      message:
-        "Codex native hooks are archived for manual review because they can execute commands",
-    });
-  }
-  const skills = [...codexSkills, ...personalAgentSkills].toSorted((a, b) =>
-    a.source.localeCompare(b.source),
-  );
-  const high = Boolean(codexSkills.length || plugins.length || archivePaths.length);
-  const medium = personalAgentSkills.length > 0;
-  return {
-    root: codexHome,
-    confidence: high ? "high" : medium ? "medium" : "low",
-    codexHome,
-    ...((await isDirectory(codexSkillsDir)) ? { codexSkillsDir } : {}),
-    ...((await isDirectory(agentsSkillsDir)) ? { personalAgentsSkillsDir: agentsSkillsDir } : {}),
-    ...((await exists(configPath)) ? { configPath } : {}),
-    ...((await exists(hooksPath)) ? { hooksPath } : {}),
-    skills,
-    plugins,
-    ...(sourcePluginDiscovery.error ? { pluginDiscoveryError: sourcePluginDiscovery.error } : {}),
-    archivePaths,
-  };
-}
-
-export function hasCodexSource(source: CodexSource): boolean {
-  return source.confidence !== "low";
-}
-
-function sanitizePluginName(value: string): string {
-  return value.trim().toLowerCase().replaceAll(/\s+/gu, "-");
-}

package/src/migration/targets.ts

@@ -1,25 +0,0 @@
-import path from "node:path";
-import {
-  resolveAgentConfig,
-  resolveAgentWorkspaceDir,
-  resolveDefaultAgentId,
-} from "autobot/plugin-sdk/agent-runtime";
-import type { MigrationProviderContext } from "autobot/plugin-sdk/plugin-entry";
-import { resolveHomePath } from "./helpers.js";
-
-type CodexMigrationTargets = {
-  workspaceDir: string;
-  agentDir: string;
-};
-
-export function resolveCodexMigrationTargets(ctx: MigrationProviderContext): CodexMigrationTargets {
-  const cfg = ctx.config;
-  const agentId = resolveDefaultAgentId(cfg);
-  const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
-  const configuredAgentDir = resolveAgentConfig(cfg, agentId)?.agentDir?.trim();
-  const agentDir =
-    ctx.runtime?.agent?.resolveAgentDir(cfg, agentId) ??
-    (configuredAgentDir ? resolveHomePath(configuredAgentDir) : undefined) ??
-    path.join(ctx.stateDir, "agents", agentId, "agent");
-  return { workspaceDir, agentDir };
-}