codexuse-cli 2.4.2 → 2.4.4

package/dist/index.js

@@ -34,15 +34,45 @@ var DEFAULT_AUTO_ROLL_ENABLED = false;
 var DEFAULT_AUTO_ROLL_WARNING_THRESHOLD = 85;
 var DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD = 95;
 var AUTO_ROLL_WARNING_MIN = 50;
+var AUTO_ROLL_WARNING_MAX = 99;
+var AUTO_ROLL_SWITCH_MAX = 100;
 function clampNumber(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
+function resolveFiniteNumber(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function sanitizeAutoRollWarningThreshold(value) {
+  const numeric = resolveFiniteNumber(value, DEFAULT_AUTO_ROLL_WARNING_THRESHOLD);
+  return clampNumber(numeric, AUTO_ROLL_WARNING_MIN, AUTO_ROLL_WARNING_MAX);
+}
+function sanitizeAutoRollSwitchThreshold(value, warningThreshold) {
+  const sanitizedWarning = sanitizeAutoRollWarningThreshold(warningThreshold);
+  const numeric = resolveFiniteNumber(value, DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD);
+  return clampNumber(numeric, sanitizedWarning + 1, AUTO_ROLL_SWITCH_MAX);
+}
+function sanitizeAutoRollThresholds(warningThreshold, switchThreshold) {
+  const sanitizedWarning = sanitizeAutoRollWarningThreshold(warningThreshold);
+  const sanitizedSwitch = sanitizeAutoRollSwitchThreshold(switchThreshold, sanitizedWarning);
+  return {
+    warningThreshold: sanitizedWarning,
+    switchThreshold: sanitizedSwitch
+  };
+}
 function normalizeAutoRollSettings(raw) {
   const enabled = typeof raw?.enabled === "boolean" ? raw.enabled : DEFAULT_AUTO_ROLL_ENABLED;
-  const rawWarning = typeof raw?.warningThreshold === "number" && Number.isFinite(raw.warningThreshold) ? raw.warningThreshold : DEFAULT_AUTO_ROLL_WARNING_THRESHOLD;
-  const rawSwitch = typeof raw?.switchThreshold === "number" && Number.isFinite(raw.switchThreshold) ? raw.switchThreshold : DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD;
-  const normalizedWarning = clampNumber(rawWarning, AUTO_ROLL_WARNING_MIN, 99);
-  const normalizedSwitch = clampNumber(rawSwitch, normalizedWarning + 1, 100);
+  const rawWarning = resolveFiniteNumber(
+    typeof raw?.warningThreshold === "number" ? raw.warningThreshold : NaN,
+    DEFAULT_AUTO_ROLL_WARNING_THRESHOLD
+  );
+  const rawSwitch = resolveFiniteNumber(
+    typeof raw?.switchThreshold === "number" ? raw.switchThreshold : NaN,
+    DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD
+  );
+  const { warningThreshold: normalizedWarning, switchThreshold: normalizedSwitch } = sanitizeAutoRollThresholds(
+    rawWarning,
+    rawSwitch
+  );
   return {
     enabled,
     warningThreshold: normalizedWarning,
@@ -375,6 +405,11 @@ async function withWriteLock(task) {
     release?.();
   }
 }
+async function initializeAppState(userDataDir) {
+  configuredUserDataDir = userDataDir;
+  const state = await ensureInitialized();
+  return clone(state);
+}
 async function getAppState() {
   const state = await ensureInitialized();
   return clone(state);
@@ -3659,7 +3694,6 @@ async function getCloudSyncStatus() {
     }
   }
   return {
-    endpoint: getCloudSyncApiBaseUrl(),
     canSync: eligibility.canSync,
     reason: eligibility.reason,
     licenseState: eligibility.licenseState,
@@ -4071,8 +4105,790 @@ function maxUsedPercent(snapshot) {
   return Math.max(...candidates);
 }
 
+// ../../lib/storage-migration-v1.ts
+var import_node_fs7 = require("fs");
+var import_node_path9 = __toESM(require("path"));
+var import_node_os3 = __toESM(require("os"));
+
+// ../../lib/legacy-localstorage-keys.ts
+var LEGACY_LOCALSTORAGE_KEYS = [
+  "settings-storage",
+  "provider",
+  "sandbox-storage",
+  "project-settings-storage",
+  "folder-storage",
+  "conversation-categories-storage",
+  "codex:auto-roll-settings"
+];
+
+// ../../lib/storage-migration-v1.ts
+var SQLITE_STORAGE_DIR = ".f86eb5e712267207";
+var LEGACY_SETTINGS_FILE = "settings.json";
+var LEGACY_SETTINGS_BACKUP_FILE = "settings.json.bak";
+var LEGACY_SYNC_STATE_FILE = "sync-state.json";
+var LEGACY_PROFILE_HOMES_DIR = "profile-homes";
+var LEGACY_SKILLS_DIR = "skills";
+var LEGACY_SKILL_CACHE_DIR = "skill-cache";
+var LEGACY_SKILLS_REPOS_FILE = "repos.json";
+var LEGACY_SKILL_MANIFEST = ".codexuse-skill.json";
+var LEGACY_LICENSE_SECRET_FILE = "license.secret";
+function isRecord5(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asString3(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolveHomeDir2() {
+  const home = process.env.HOME || process.env.USERPROFILE || import_node_os3.default.homedir();
+  if (!home) {
+    throw new Error("HOME is not set.");
+  }
+  return home;
+}
+function resolveCodexDir() {
+  return import_node_path9.default.join(resolveHomeDir2(), ".codex");
+}
+function resolveLegacyPath(...segments) {
+  return import_node_path9.default.join(resolveCodexDir(), ...segments);
+}
+async function readJsonFile(filePath) {
+  const raw = await import_node_fs7.promises.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function readJsonFileIfExists(filePath) {
+  try {
+    return await readJsonFile(filePath);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function copyDirectoryManual(source, destination) {
+  await import_node_fs7.promises.mkdir(destination, { recursive: true });
+  const entries = await import_node_fs7.promises.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_node_path9.default.join(source, entry.name);
+    const destPath = import_node_path9.default.join(destination, entry.name);
+    if (entry.isSymbolicLink()) {
+      const linkTarget = await import_node_fs7.promises.readlink(srcPath);
+      await import_node_fs7.promises.symlink(linkTarget, destPath).catch((error) => {
+        if (error.code !== "EEXIST") {
+          throw error;
+        }
+      });
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await copyDirectoryManual(srcPath, destPath);
+      continue;
+    }
+    if (entry.isFile()) {
+      await import_node_fs7.promises.copyFile(srcPath, destPath);
+    }
+  }
+}
+async function copyDirIfExists(source, destination) {
+  let stats = null;
+  try {
+    stats = await import_node_fs7.promises.stat(source);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  if (!stats.isDirectory()) {
+    return;
+  }
+  await import_node_fs7.promises.rm(destination, { recursive: true, force: true });
+  await import_node_fs7.promises.mkdir(import_node_path9.default.dirname(destination), { recursive: true });
+  try {
+    await import_node_fs7.promises.cp(source, destination, {
+      recursive: true,
+      errorOnExist: false,
+      force: true,
+      dereference: false,
+      verbatimSymlinks: true
+    });
+  } catch (error) {
+    if (error.code === "ERR_FS_CP_EINVAL") {
+      await copyDirectoryManual(source, destination);
+      return;
+    }
+    throw error;
+  }
+}
+async function copyFileIfExists(source, destination, options) {
+  try {
+    const sourceStat = await import_node_fs7.promises.stat(source);
+    if (!sourceStat.isFile()) {
+      return;
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  try {
+    const destinationStat = await import_node_fs7.promises.stat(destination);
+    if (destinationStat.isFile()) {
+      return;
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  await import_node_fs7.promises.mkdir(import_node_path9.default.dirname(destination), { recursive: true });
+  await import_node_fs7.promises.copyFile(source, destination);
+  if (typeof options?.mode === "number") {
+    await import_node_fs7.promises.chmod(destination, options.mode).catch(() => void 0);
+  }
+}
+async function cleanupCopiedSkillsMetadata(skillsDir) {
+  await removeIfExists(import_node_path9.default.join(skillsDir, LEGACY_SKILLS_REPOS_FILE));
+  let entries = [];
+  try {
+    entries = await import_node_fs7.promises.readdir(skillsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    await removeIfExists(import_node_path9.default.join(skillsDir, entry.name, LEGACY_SKILL_MANIFEST));
+  }
+}
+async function migrateLegacyDirectoriesToUserData() {
+  const userDataDir = getUserDataDir();
+  const legacyCodexDir = resolveCodexDir();
+  await copyDirIfExists(
+    import_node_path9.default.join(legacyCodexDir, LEGACY_PROFILE_HOMES_DIR),
+    import_node_path9.default.join(userDataDir, LEGACY_PROFILE_HOMES_DIR)
+  );
+  await copyDirIfExists(
+    import_node_path9.default.join(legacyCodexDir, LEGACY_SKILLS_DIR),
+    import_node_path9.default.join(userDataDir, LEGACY_SKILLS_DIR)
+  );
+  await copyDirIfExists(
+    import_node_path9.default.join(legacyCodexDir, LEGACY_SKILL_CACHE_DIR),
+    import_node_path9.default.join(userDataDir, LEGACY_SKILL_CACHE_DIR)
+  );
+  await copyFileIfExists(
+    import_node_path9.default.join(legacyCodexDir, LEGACY_LICENSE_SECRET_FILE),
+    import_node_path9.default.join(userDataDir, LEGACY_LICENSE_SECRET_FILE),
+    { mode: 384 }
+  );
+  await cleanupCopiedSkillsMetadata(import_node_path9.default.join(userDataDir, LEGACY_SKILLS_DIR));
+}
+function pickAutoRoll(raw) {
+  if (!raw) {
+    return null;
+  }
+  try {
+    return normalizeAutoRollSettings(raw);
+  } catch {
+    return null;
+  }
+}
+function parseLegacyLicense(raw) {
+  if (!isRecord5(raw)) {
+    return {
+      licenseKey: null,
+      purchaseEmail: null,
+      lastVerifiedAt: null,
+      nextCheckAt: null,
+      lastVerificationError: null,
+      status: "inactive",
+      signature: null
+    };
+  }
+  const statusCandidate = asString3(raw.status);
+  const status = ["inactive", "active", "grace", "error"].includes(statusCandidate ?? "") ? statusCandidate : "inactive";
+  return {
+    licenseKey: asString3(raw.licenseKey ?? raw.license_key),
+    purchaseEmail: asString3(raw.purchaseEmail ?? raw.purchase_email),
+    lastVerifiedAt: asString3(raw.lastVerifiedAt ?? raw.last_verified_at),
+    nextCheckAt: asString3(raw.nextCheckAt ?? raw.next_check_at),
+    lastVerificationError: asString3(raw.lastVerificationError ?? raw.last_verification_error),
+    status,
+    signature: asString3(raw.signature)
+  };
+}
+function parseLegacyProfileRecord(name, raw) {
+  if (!isRecord5(raw)) {
+    return null;
+  }
+  const dataRaw = raw.data;
+  let data = null;
+  if (isRecord5(dataRaw)) {
+    data = dataRaw;
+  } else if (typeof dataRaw === "string") {
+    try {
+      data = JSON.parse(dataRaw);
+    } catch {
+      data = null;
+    }
+  }
+  if (!data) {
+    return null;
+  }
+  return {
+    name,
+    displayName: asString3(raw.displayName ?? raw.display_name) ?? name,
+    data,
+    metadata: isRecord5(raw.metadata) ? raw.metadata : void 0,
+    accountId: asString3(raw.accountId ?? raw.account_id),
+    workspaceId: asString3(raw.workspaceId ?? raw.workspace_id),
+    workspaceName: asString3(raw.workspaceName ?? raw.workspace_name),
+    email: asString3(raw.email),
+    authMethod: asString3(raw.authMethod ?? raw.auth_method),
+    createdAt: asString3(raw.createdAt ?? raw.created_at),
+    updatedAt: asString3(raw.updatedAt ?? raw.updated_at)
+  };
+}
+async function loadLegacySettingsPatch() {
+  const filePath = resolveLegacyPath(LEGACY_SETTINGS_FILE);
+  const raw = await readJsonFileIfExists(filePath);
+  if (!isRecord5(raw)) {
+    return {};
+  }
+  const cliChannel = parseCodexCliChannel(raw.cliChannel ?? raw.cli_channel);
+  const autoRoll = pickAutoRoll(raw.autoRoll ?? raw.auto_roll);
+  const license = parseLegacyLicense(raw.license ?? raw.license_data ?? raw.license_state);
+  return {
+    app: {
+      lastAppVersion: asString3(raw.lastAppVersion ?? raw.last_app_version),
+      pendingUpdateVersion: asString3(raw.pendingUpdateVersion ?? raw.pending_update_version),
+      cliChannel: cliChannel ?? void 0,
+      lastProfileName: asString3(raw.lastProfileName ?? raw.last_profile_name)
+    },
+    license,
+    autoRoll: autoRoll ? {
+      enabled: autoRoll.enabled,
+      warningThreshold: autoRoll.warningThreshold,
+      switchThreshold: autoRoll.switchThreshold
+    } : void 0
+  };
+}
+async function loadLegacySyncPatch() {
+  const filePath = resolveLegacyPath(LEGACY_SYNC_STATE_FILE);
+  const raw = await readJsonFileIfExists(filePath);
+  if (!isRecord5(raw)) {
+    return {};
+  }
+  return {
+    sync: {
+      lastPushAt: asString3(raw.lastPushAt),
+      lastPullAt: asString3(raw.lastPullAt),
+      lastError: asString3(raw.lastError),
+      remoteUpdatedAt: asString3(raw.remoteUpdatedAt)
+    }
+  };
+}
+async function loadLegacyProfilesPatch() {
+  const root = resolveLegacyPath(LEGACY_PROFILE_HOMES_DIR);
+  let entries = [];
+  try {
+    entries = await import_node_fs7.promises.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+  const profilesByName = {};
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    const profileFile = import_node_path9.default.join(root, entry.name, "profile.json");
+    const raw = await readJsonFileIfExists(profileFile);
+    if (!raw) {
+      continue;
+    }
+    const parsed = parseLegacyProfileRecord(entry.name, raw);
+    if (!parsed) {
+      continue;
+    }
+    profilesByName[entry.name] = parsed;
+  }
+  if (Object.keys(profilesByName).length === 0) {
+    return {};
+  }
+  return { profilesByName };
+}
+function parseSkillInstallMetadata(raw) {
+  if (!isRecord5(raw)) {
+    return null;
+  }
+  const id = asString3(raw.id);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    repo: asString3(raw.repo),
+    repoPath: asString3(raw.repoPath),
+    sourceLabel: asString3(raw.sourceLabel),
+    sourceType: raw.sourceType === "official" || raw.sourceType === "community" || raw.sourceType === "local" ? raw.sourceType : void 0,
+    viewUrl: asString3(raw.viewUrl),
+    createdAt: asString3(raw.createdAt)
+  };
+}
+async function loadLegacySkillsPatch() {
+  const skillsRoot = resolveLegacyPath(LEGACY_SKILLS_DIR);
+  const reposPath = import_node_path9.default.join(skillsRoot, LEGACY_SKILLS_REPOS_FILE);
+  const reposRaw = await readJsonFileIfExists(reposPath);
+  const installsBySlug = {};
+  let dirEntries = [];
+  try {
+    dirEntries = await import_node_fs7.promises.readdir(skillsRoot, { withFileTypes: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  for (const entry of dirEntries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+    const manifestPath = import_node_path9.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST);
+    const manifestRaw = await readJsonFileIfExists(manifestPath);
+    const parsed = parseSkillInstallMetadata(manifestRaw);
+    if (!parsed) {
+      continue;
+    }
+    installsBySlug[entry.name] = parsed;
+  }
+  const sources = isRecord5(reposRaw) && Array.isArray(reposRaw.sources) ? reposRaw.sources : [];
+  if (sources.length === 0 && Object.keys(installsBySlug).length === 0) {
+    return {};
+  }
+  return {
+    skills: {
+      sources,
+      installsBySlug
+    }
+  };
+}
+function mergeLegacyLocalStoragePatch(payload) {
+  const patch = {};
+  const consumedKeys = /* @__PURE__ */ new Set();
+  const skippedKeys = /* @__PURE__ */ new Set();
+  const legacyPayloadKeys = new Set(
+    Object.keys(payload).filter(
+      (key) => LEGACY_LOCALSTORAGE_KEYS.includes(key)
+    )
+  );
+  const hasKey = (key) => legacyPayloadKeys.has(key);
+  const markSkippedIfPresent = (key, consumed) => {
+    if (!hasKey(key)) {
+      return;
+    }
+    if (consumed) {
+      consumedKeys.add(key);
+    } else {
+      skippedKeys.add(key);
+    }
+  };
+  const settingsStorage = payload["settings-storage"];
+  if (isRecord5(settingsStorage)) {
+    const nextExcludeFolders = Array.isArray(settingsStorage.excludeFolders) ? settingsStorage.excludeFolders.filter((item) => typeof item === "string") : void 0;
+    const nextBeep = typeof settingsStorage.enableTaskCompleteBeep === "boolean" ? settingsStorage.enableTaskCompleteBeep : void 0;
+    const nextSleep = typeof settingsStorage.preventSleepDuringTasks === "boolean" ? settingsStorage.preventSleepDuringTasks : void 0;
+    patch.preferences = {
+      excludeFolders: nextExcludeFolders,
+      enableTaskCompleteBeep: nextBeep,
+      preventSleepDuringTasks: nextSleep
+    };
+    markSkippedIfPresent(
+      "settings-storage",
+      nextExcludeFolders !== void 0 || nextBeep !== void 0 || nextSleep !== void 0
+    );
+  } else {
+    markSkippedIfPresent("settings-storage", false);
+  }
+  const provider = payload.provider;
+  if (isRecord5(provider)) {
+    const list = Array.isArray(provider.providers) ? provider.providers.filter(isRecord5).map((item) => ({
+      id: asString3(item.id) ?? "",
+      name: asString3(item.name) ?? "",
+      models: Array.isArray(item.models) ? item.models.filter((model) => typeof model === "string") : [],
+      apiKey: asString3(item.apiKey) ?? void 0,
+      baseUrl: asString3(item.baseUrl) ?? void 0
+    })).filter((item) => item.id && item.name) : void 0;
+    const overridesByPath = isRecord5(provider.selectionsByCwd) ? provider.selectionsByCwd : void 0;
+    patch.providers = {
+      list,
+      selectedProviderId: asString3(provider.selectedProviderId) ?? void 0,
+      defaultModel: asString3(provider.defaultModel ?? provider.selectedModel),
+      defaultReasoningEffort: typeof provider.defaultReasoningEffort === "string" ? provider.defaultReasoningEffort : typeof provider.reasoningEffort === "string" ? provider.reasoningEffort : void 0,
+      overridesByPath
+    };
+    markSkippedIfPresent(
+      "provider",
+      list !== void 0 || asString3(provider.selectedProviderId) !== null || asString3(provider.defaultModel ?? provider.selectedModel) !== null || typeof provider.defaultReasoningEffort === "string" || typeof provider.reasoningEffort === "string" || overridesByPath !== void 0
+    );
+  } else {
+    markSkippedIfPresent("provider", false);
+  }
+  const sandbox = payload["sandbox-storage"];
+  if (isRecord5(sandbox)) {
+    const defaultMode = asString3(sandbox.defaultMode ?? sandbox.mode) ?? void 0;
+    const defaultApprovalPolicy = asString3(sandbox.defaultApprovalPolicy ?? sandbox.approvalPolicy) ?? void 0;
+    const overridesByPath = isRecord5(sandbox.selectionsByCwd) ? sandbox.selectionsByCwd : void 0;
+    patch.sandbox = {
+      defaultMode,
+      defaultApprovalPolicy,
+      overridesByPath
+    };
+    markSkippedIfPresent(
+      "sandbox-storage",
+      defaultMode !== void 0 || defaultApprovalPolicy !== void 0 || overridesByPath !== void 0
+    );
+  } else {
+    markSkippedIfPresent("sandbox-storage", false);
+  }
+  const projectSettings = payload["project-settings-storage"];
+  if (isRecord5(projectSettings) && isRecord5(projectSettings.settingsByPath)) {
+    patch.projectSettingsByPath = projectSettings.settingsByPath;
+    markSkippedIfPresent("project-settings-storage", true);
+  } else {
+    markSkippedIfPresent("project-settings-storage", false);
+  }
+  const folder = payload["folder-storage"];
+  if (isRecord5(folder)) {
+    const folderHistory = Array.isArray(folder.folderHistory) ? folder.folderHistory.filter(isRecord5) : void 0;
+    const pinnedPaths = Array.isArray(folder.pinnedPaths) ? folder.pinnedPaths.filter((item) => typeof item === "string") : void 0;
+    patch.preferences = {
+      ...patch.preferences ?? {},
+      folderHistory,
+      pinnedPaths
+    };
+    markSkippedIfPresent("folder-storage", folderHistory !== void 0 || pinnedPaths !== void 0);
+  } else {
+    markSkippedIfPresent("folder-storage", false);
+  }
+  const categories = payload["conversation-categories-storage"];
+  let consumedCategories = false;
+  if (isRecord5(categories)) {
+    if (isRecord5(categories.categoriesByCwd)) {
+      patch.conversationCategoriesByCwd = categories.categoriesByCwd;
+      consumedCategories = true;
+    }
+    if (isRecord5(categories.conversationCategoryByCwd)) {
+      patch.conversationCategoryAssignmentsByCwd = categories.conversationCategoryByCwd;
+      consumedCategories = true;
+    }
+  }
+  markSkippedIfPresent("conversation-categories-storage", consumedCategories);
+  const legacyAutoRoll = payload["codex:auto-roll-settings"];
+  const autoRoll = pickAutoRoll(legacyAutoRoll);
+  if (autoRoll) {
+    patch.autoRoll = {
+      enabled: autoRoll.enabled,
+      warningThreshold: autoRoll.warningThreshold,
+      switchThreshold: autoRoll.switchThreshold
+    };
+    markSkippedIfPresent("codex:auto-roll-settings", true);
+  } else {
+    markSkippedIfPresent("codex:auto-roll-settings", false);
+  }
+  return {
+    patch,
+    consumedKeys: Array.from(consumedKeys),
+    skippedKeys: Array.from(skippedKeys)
+  };
+}
+async function removeIfExists(target) {
+  await import_node_fs7.promises.rm(target, { recursive: true, force: true });
+}
+async function cleanupLegacyCanonicalSources() {
+  const homeDir = resolveHomeDir2();
+  await removeIfExists(import_node_path9.default.join(homeDir, SQLITE_STORAGE_DIR));
+  await removeIfExists(resolveLegacyPath(LEGACY_SETTINGS_FILE));
+  await removeIfExists(resolveLegacyPath(LEGACY_SETTINGS_BACKUP_FILE));
+  await removeIfExists(resolveLegacyPath(LEGACY_SYNC_STATE_FILE));
+  await removeIfExists(resolveLegacyPath(LEGACY_LICENSE_SECRET_FILE));
+  await removeIfExists(resolveLegacyPath(LEGACY_SKILLS_DIR, LEGACY_SKILLS_REPOS_FILE));
+  const profileHomesRoot = resolveLegacyPath(LEGACY_PROFILE_HOMES_DIR);
+  try {
+    const profileHomes = await import_node_fs7.promises.readdir(profileHomesRoot, { withFileTypes: true });
+    for (const profileHome of profileHomes) {
+      if (!profileHome.isDirectory()) {
+        continue;
+      }
+      const profileDir = import_node_path9.default.join(profileHomesRoot, profileHome.name);
+      let files = [];
+      try {
+        files = await import_node_fs7.promises.readdir(profileDir);
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        if (!file.startsWith("profile.json")) {
+          continue;
+        }
+        await removeIfExists(import_node_path9.default.join(profileDir, file));
+      }
+    }
+  } catch (error) {
+    logWarn("Failed cleaning legacy profile metadata:", {
+      profileHomesRoot,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const skillsRoot = resolveLegacyPath(LEGACY_SKILLS_DIR);
+  try {
+    const skillDirs = await import_node_fs7.promises.readdir(skillsRoot, { withFileTypes: true });
+    for (const entry of skillDirs) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) {
+        continue;
+      }
+      await removeIfExists(import_node_path9.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST));
+    }
+  } catch (error) {
+    logWarn("Failed cleaning legacy skills metadata:", {
+      skillsRoot,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function runStorageMigrationV1() {
+  const current = await getAppState();
+  if (current.migration.status === "complete" || current.migration.status === "pending_local_storage") {
+    return current;
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await migrateLegacyDirectoriesToUserData();
+    const patches = await Promise.all([
+      loadLegacySettingsPatch(),
+      loadLegacySyncPatch(),
+      loadLegacyProfilesPatch(),
+      loadLegacySkillsPatch()
+    ]);
+    const mergedPatch = patches.reduce((acc, patch) => {
+      return {
+        ...acc,
+        ...patch,
+        app: { ...acc.app ?? {}, ...patch.app ?? {} },
+        license: { ...acc.license ?? {}, ...patch.license ?? {} },
+        autoRoll: { ...acc.autoRoll ?? {}, ...patch.autoRoll ?? {} },
+        providers: { ...acc.providers ?? {}, ...patch.providers ?? {} },
+        sandbox: { ...acc.sandbox ?? {}, ...patch.sandbox ?? {} },
+        preferences: { ...acc.preferences ?? {}, ...patch.preferences ?? {} },
+        sync: { ...acc.sync ?? {}, ...patch.sync ?? {} },
+        profilesByName: { ...acc.profilesByName ?? {}, ...patch.profilesByName ?? {} },
+        projectSettingsByPath: {
+          ...acc.projectSettingsByPath ?? {},
+          ...patch.projectSettingsByPath ?? {}
+        },
+        conversationCategoriesByCwd: {
+          ...acc.conversationCategoriesByCwd ?? {},
+          ...patch.conversationCategoriesByCwd ?? {}
+        },
+        conversationCategoryAssignmentsByCwd: {
+          ...acc.conversationCategoryAssignmentsByCwd ?? {},
+          ...patch.conversationCategoryAssignmentsByCwd ?? {}
+        },
+        skills: {
+          ...acc.skills ?? {},
+          ...patch.skills ?? {},
+          sources: patch.skills?.sources ?? acc.skills?.sources,
+          installsBySlug: {
+            ...acc.skills?.installsBySlug ?? {},
+            ...patch.skills?.installsBySlug ?? {}
+          }
+        }
+      };
+    }, {});
+    return await updateAppState((state) => ({
+      ...state,
+      ...mergedPatch,
+      app: { ...state.app, ...mergedPatch.app ?? {} },
+      license: { ...state.license, ...mergedPatch.license ?? {} },
+      autoRoll: { ...state.autoRoll, ...mergedPatch.autoRoll ?? {} },
+      providers: {
+        ...state.providers,
+        ...mergedPatch.providers ?? {},
+        overridesByPath: {
+          ...state.providers.overridesByPath,
+          ...mergedPatch.providers?.overridesByPath ?? {}
+        }
+      },
+      sandbox: {
+        ...state.sandbox,
+        ...mergedPatch.sandbox ?? {},
+        overridesByPath: {
+          ...state.sandbox.overridesByPath,
+          ...mergedPatch.sandbox?.overridesByPath ?? {}
+        }
+      },
+      preferences: { ...state.preferences, ...mergedPatch.preferences ?? {} },
+      sync: { ...state.sync, ...mergedPatch.sync ?? {} },
+      profilesByName: {
+        ...state.profilesByName,
+        ...mergedPatch.profilesByName ?? {}
+      },
+      projectSettingsByPath: {
+        ...state.projectSettingsByPath,
+        ...mergedPatch.projectSettingsByPath ?? {}
+      },
+      conversationCategoriesByCwd: {
+        ...state.conversationCategoriesByCwd,
+        ...mergedPatch.conversationCategoriesByCwd ?? {}
+      },
+      conversationCategoryAssignmentsByCwd: {
+        ...state.conversationCategoryAssignmentsByCwd,
+        ...mergedPatch.conversationCategoryAssignmentsByCwd ?? {}
+      },
+      skills: {
+        ...state.skills,
+        ...mergedPatch.skills ?? {},
+        installsBySlug: {
+          ...state.skills.installsBySlug,
+          ...mergedPatch.skills?.installsBySlug ?? {}
+        }
+      },
+      migration: {
+        ...state.migration,
+        status: "pending_local_storage",
+        startedAt: state.migration.startedAt ?? startedAt,
+        completedAt: null,
+        localStorageImportedAt: null,
+        lastError: null
+      }
+    }), {
+      mode: "replace",
+      allowBeforeMigrationComplete: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await updateAppState((state) => ({
+      ...state,
+      migration: {
+        ...state.migration,
+        status: "pending",
+        startedAt: state.migration.startedAt ?? startedAt,
+        lastError: message
+      }
+    }), {
+      mode: "replace",
+      allowBeforeMigrationComplete: true
+    });
+    throw error;
+  }
+}
+async function importLegacyLocalStorageOnce(payload) {
+  const current = await getAppState();
+  if (current.migration.status === "complete") {
+    return { completed: true, importedKeys: [], skippedKeys: [] };
+  }
+  if (current.migration.status !== "pending_local_storage") {
+    return { completed: false, importedKeys: [], skippedKeys: [] };
+  }
+  if (!payload || !isRecord5(payload)) {
+    return { completed: false, importedKeys: [], skippedKeys: [] };
+  }
+  const { patch, consumedKeys, skippedKeys } = mergeLegacyLocalStoragePatch(payload);
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const next = await updateAppState((state) => {
+    if (state.migration.status !== "pending_local_storage") {
+      return state;
+    }
+    return {
+      ...state,
+      ...patch,
+      app: { ...state.app, ...patch.app ?? {} },
+      autoRoll: { ...state.autoRoll, ...patch.autoRoll ?? {} },
+      license: { ...state.license, ...patch.license ?? {} },
+      providers: {
+        ...state.providers,
+        ...patch.providers ?? {},
+        overridesByPath: {
+          ...state.providers.overridesByPath,
+          ...patch.providers?.overridesByPath ?? {}
+        }
+      },
+      sandbox: {
+        ...state.sandbox,
+        ...patch.sandbox ?? {},
+        overridesByPath: {
+          ...state.sandbox.overridesByPath,
+          ...patch.sandbox?.overridesByPath ?? {}
+        }
+      },
+      preferences: { ...state.preferences, ...patch.preferences ?? {} },
+      projectSettingsByPath: {
+        ...state.projectSettingsByPath,
+        ...patch.projectSettingsByPath ?? {}
+      },
+      conversationCategoriesByCwd: {
+        ...state.conversationCategoriesByCwd,
+        ...patch.conversationCategoriesByCwd ?? {}
+      },
+      conversationCategoryAssignmentsByCwd: {
+        ...state.conversationCategoryAssignmentsByCwd,
+        ...patch.conversationCategoryAssignmentsByCwd ?? {}
+      },
+      migration: {
+        ...state.migration,
+        status: "complete",
+        completedAt,
+        localStorageImportedAt: completedAt,
+        lastError: null
+      }
+    };
+  }, {
+    mode: "replace",
+    allowBeforeMigrationComplete: true
+  });
+  if (next.migration.status !== "complete") {
+    return { completed: false, importedKeys: [], skippedKeys: [] };
+  }
+  await cleanupLegacyCanonicalSources();
+  return { completed: true, importedKeys: consumedKeys, skippedKeys };
+}
+
 // src/index.ts
-var VERSION = true ? "2.4.2" : "0.0.0";
+var VERSION = true ? "2.4.4" : "0.0.0";
+var cliStorageReadyPromise = null;
+async function ensureCliStorageReady() {
+  if (cliStorageReadyPromise) {
+    return cliStorageReadyPromise;
+  }
+  cliStorageReadyPromise = (async () => {
+    await initializeAppState(getUserDataDir());
+    const migrated = await runStorageMigrationV1();
+    if (migrated.migration.status === "pending_local_storage") {
+      await importLegacyLocalStorageOnce({});
+    }
+    const state = await getAppState();
+    if (state.migration.status !== "complete") {
+      throw new Error(
+        `Storage migration is not complete (status: ${state.migration.status}). Open CodexUse desktop once and try again.`
+      );
+    }
+  })().catch((error) => {
+    cliStorageReadyPromise = null;
+    throw error;
+  });
+  return cliStorageReadyPromise;
+}
 function printHelp() {
   console.log(`CodexUse CLI v${VERSION}
 
@@ -4591,12 +5407,15 @@ async function main() {
   const rest = args.slice(1);
   switch (command) {
     case "profile":
+      await ensureCliStorageReady();
       await handleProfile(rest);
       return;
     case "license":
+      await ensureCliStorageReady();
       await handleLicense(rest);
       return;
     case "sync":
+      await ensureCliStorageReady();
       await handleSync(rest);
       return;
     default: