@full-self-developing/fsd 1.0.0

package/extensions/codex/src/migration/provider.ts

@@ -0,0 +1,41 @@
+import type {
+  MigrationPlan,
+  MigrationProviderContext,
+  MigrationProviderPlugin,
+} from "openclaw/plugin-sdk/plugin-entry";
+import { applyCodexMigrationPlan, prepareTargetCodexAppServer } from "./apply.js";
+import { buildCodexMigrationPlan } from "./plan.js";
+import { discoverCodexSource, hasCodexSource } from "./source.js";
+
+export function buildCodexMigrationProvider(
+  params: {
+    runtime?: MigrationProviderContext["runtime"];
+  } = {},
+): MigrationProviderPlugin {
+  return {
+    id: "codex",
+    label: "Codex",
+    description:
+      "Inventory and promote Codex CLI skills while keeping Codex native plugins and hooks explicit.",
+    async detect(ctx) {
+      const source = await discoverCodexSource({
+        input: ctx.source,
+      });
+      const found = hasCodexSource(source);
+      return {
+        found,
+        source: source.root,
+        label: "Codex",
+        confidence: found ? source.confidence : "low",
+        message: found ? "Codex state found." : "Codex state not found.",
+      };
+    },
+    plan: buildCodexMigrationPlan,
+    prepareApply(ctx) {
+      return prepareTargetCodexAppServer(ctx);
+    },
+    async apply(ctx, plan?: MigrationPlan) {
+      return await applyCodexMigrationPlan({ ctx, plan, runtime: params.runtime });
+    },
+  };
+}

package/extensions/codex/src/migration/source.ts

@@ -0,0 +1,643 @@
+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 OpenClaw.`,
+      });
+      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 OpenClaw.`;
+}
+
+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; OpenClaw 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/extensions/codex/src/migration/targets.ts

@@ -0,0 +1,25 @@
+import path from "node:path";
+import {
+  resolveAgentConfig,
+  resolveAgentWorkspaceDir,
+  resolveDefaultAgentId,
+} from "openclaw/plugin-sdk/agent-runtime";
+import type { MigrationProviderContext } from "openclaw/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 };
+}