fix: migrate legacy state/config paths

src/config/io.compat.test.ts

@@ -14,10 +14,15 @@ async function withTempHome(run: (home: string) => Promise<void>): Promise<void>
   }
 }
 
-async function writeConfig(home: string, dirname: ".moltbot" | ".clawdbot", port: number) {
+async function writeConfig(
+  home: string,
+  dirname: ".moltbot" | ".clawdbot",
+  port: number,
+  filename: "moltbot.json" | "clawdbot.json" = "moltbot.json",
+) {
   const dir = path.join(home, dirname);
   await fs.mkdir(dir, { recursive: true });
-  const configPath = path.join(dir, "moltbot.json");
+  const configPath = path.join(dir, filename);
   await fs.writeFile(configPath, JSON.stringify({ gateway: { port } }, null, 2));
   return configPath;
 }
@@ -51,6 +56,35 @@ describe("config io compat (new + legacy folders)", () => {
     });
   });
 
+  it("falls back to ~/.clawdbot/clawdbot.json when only legacy filename exists", async () => {
+    await withTempHome(async (home) => {
+      const legacyConfigPath = await writeConfig(home, ".clawdbot", 20002, "clawdbot.json");
+
+      const io = createConfigIO({
+        env: {} as NodeJS.ProcessEnv,
+        homedir: () => home,
+      });
+
+      expect(io.configPath).toBe(legacyConfigPath);
+      expect(io.loadConfig().gateway?.port).toBe(20002);
+    });
+  });
+
+  it("prefers moltbot.json over legacy filename in the same dir", async () => {
+    await withTempHome(async (home) => {
+      const preferred = await writeConfig(home, ".clawdbot", 20003, "moltbot.json");
+      await writeConfig(home, ".clawdbot", 20004, "clawdbot.json");
+
+      const io = createConfigIO({
+        env: {} as NodeJS.ProcessEnv,
+        homedir: () => home,
+      });
+
+      expect(io.configPath).toBe(preferred);
+      expect(io.loadConfig().gateway?.port).toBe(20003);
+    });
+  });
+
   it("honors explicit legacy config path env override", async () => {
     await withTempHome(async (home) => {
       const newConfigPath = await writeConfig(home, ".moltbot", 19002);

src/config/io.ts

@@ -555,7 +555,8 @@ function clearConfigCache(): void {
 }
 
 export function loadConfig(): MoltbotConfig {
-  const configPath = resolveConfigPath();
+  const io = createConfigIO();
+  const configPath = io.configPath;
   const now = Date.now();
   if (shouldUseConfigCache(process.env)) {
     const cached = configCache;
@@ -563,7 +564,7 @@ export function loadConfig(): MoltbotConfig {
       return cached.config;
     }
   }
-  const config = createConfigIO({ configPath }).loadConfig();
+  const config = io.loadConfig();
   if (shouldUseConfigCache(process.env)) {
     const cacheMs = resolveConfigCacheMs(process.env);
     if (cacheMs > 0) {
@@ -578,12 +579,10 @@ export function loadConfig(): MoltbotConfig {
 }
 
 export async function readConfigFileSnapshot(): Promise<ConfigFileSnapshot> {
-  return await createConfigIO({
-    configPath: resolveConfigPath(),
-  }).readConfigFileSnapshot();
+  return await createConfigIO().readConfigFileSnapshot();
 }
 
 export async function writeConfigFile(cfg: MoltbotConfig): Promise<void> {
   clearConfigCache();
-  await createConfigIO({ configPath: resolveConfigPath() }).writeConfigFile(cfg);
+  await createConfigIO().writeConfigFile(cfg);
 }

src/config/paths.test.ts

@@ -1,5 +1,7 @@
+import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import {
   resolveDefaultConfigCandidates,
@@ -47,6 +49,61 @@ describe("state + config path candidates", () => {
     const home = "/home/test";
     const candidates = resolveDefaultConfigCandidates({} as NodeJS.ProcessEnv, () => home);
     expect(candidates[0]).toBe(path.join(home, ".moltbot", "moltbot.json"));
-    expect(candidates[1]).toBe(path.join(home, ".clawdbot", "moltbot.json"));
+    expect(candidates[1]).toBe(path.join(home, ".moltbot", "clawdbot.json"));
+    expect(candidates[2]).toBe(path.join(home, ".clawdbot", "moltbot.json"));
+    expect(candidates[3]).toBe(path.join(home, ".clawdbot", "clawdbot.json"));
+  });
+
+  it("prefers ~/.moltbot when it exists and legacy dir is missing", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-state-"));
+    try {
+      const newDir = path.join(root, ".moltbot");
+      await fs.mkdir(newDir, { recursive: true });
+      const resolved = resolveStateDir({} as NodeJS.ProcessEnv, () => root);
+      expect(resolved).toBe(newDir);
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("CONFIG_PATH prefers existing legacy filename when present", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-config-"));
+    const previousHome = process.env.HOME;
+    const previousMoltbotConfig = process.env.MOLTBOT_CONFIG_PATH;
+    const previousClawdbotConfig = process.env.CLAWDBOT_CONFIG_PATH;
+    const previousMoltbotState = process.env.MOLTBOT_STATE_DIR;
+    const previousClawdbotState = process.env.CLAWDBOT_STATE_DIR;
+    try {
+      const legacyDir = path.join(root, ".clawdbot");
+      await fs.mkdir(legacyDir, { recursive: true });
+      const legacyPath = path.join(legacyDir, "clawdbot.json");
+      await fs.writeFile(legacyPath, "{}", "utf-8");
+
+      process.env.HOME = root;
+      delete process.env.MOLTBOT_CONFIG_PATH;
+      delete process.env.CLAWDBOT_CONFIG_PATH;
+      delete process.env.MOLTBOT_STATE_DIR;
+      delete process.env.CLAWDBOT_STATE_DIR;
+
+      vi.resetModules();
+      const { CONFIG_PATH } = await import("./paths.js");
+      expect(CONFIG_PATH).toBe(legacyPath);
+    } finally {
+      if (previousHome === undefined) {
+        delete process.env.HOME;
+      } else {
+        process.env.HOME = previousHome;
+      }
+      if (previousMoltbotConfig === undefined) delete process.env.MOLTBOT_CONFIG_PATH;
+      else process.env.MOLTBOT_CONFIG_PATH = previousMoltbotConfig;
+      if (previousClawdbotConfig === undefined) delete process.env.CLAWDBOT_CONFIG_PATH;
+      else process.env.CLAWDBOT_CONFIG_PATH = previousClawdbotConfig;
+      if (previousMoltbotState === undefined) delete process.env.MOLTBOT_STATE_DIR;
+      else process.env.MOLTBOT_STATE_DIR = previousMoltbotState;
+      if (previousClawdbotState === undefined) delete process.env.CLAWDBOT_STATE_DIR;
+      else process.env.CLAWDBOT_STATE_DIR = previousClawdbotState;
+      await fs.rm(root, { recursive: true, force: true });
+      vi.resetModules();
+    }
   });
 });

src/config/paths.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { MoltbotConfig } from "./types.js";
@@ -18,6 +19,7 @@ export const isNixMode = resolveIsNixMode();
 const LEGACY_STATE_DIRNAME = ".clawdbot";
 const NEW_STATE_DIRNAME = ".moltbot";
 const CONFIG_FILENAME = "moltbot.json";
+const LEGACY_CONFIG_FILENAME = "clawdbot.json";
 
 function legacyStateDir(homedir: () => string = os.homedir): string {
   return path.join(homedir(), LEGACY_STATE_DIRNAME);
@@ -27,10 +29,19 @@ function newStateDir(homedir: () => string = os.homedir): string {
   return path.join(homedir(), NEW_STATE_DIRNAME);
 }
 
+export function resolveLegacyStateDir(homedir: () => string = os.homedir): string {
+  return legacyStateDir(homedir);
+}
+
+export function resolveNewStateDir(homedir: () => string = os.homedir): string {
+  return newStateDir(homedir);
+}
+
 /**
  * State directory for mutable data (sessions, logs, caches).
  * Can be overridden via MOLTBOT_STATE_DIR (preferred) or CLAWDBOT_STATE_DIR (legacy).
  * Default: ~/.clawdbot (legacy default for compatibility)
+ * If ~/.moltbot exists and ~/.clawdbot does not, prefer ~/.moltbot.
  */
 export function resolveStateDir(
   env: NodeJS.ProcessEnv = process.env,
@@ -38,7 +49,12 @@ export function resolveStateDir(
 ): string {
   const override = env.MOLTBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
   if (override) return resolveUserPath(override);
-  return legacyStateDir(homedir);
+  const legacyDir = legacyStateDir(homedir);
+  const newDir = newStateDir(homedir);
+  const hasLegacy = fs.existsSync(legacyDir);
+  const hasNew = fs.existsSync(newDir);
+  if (!hasLegacy && hasNew) return newDir;
+  return legacyDir;
 }
 
 function resolveUserPath(input: string): string {
@@ -58,7 +74,7 @@ export const STATE_DIR = resolveStateDir();
  * Can be overridden via MOLTBOT_CONFIG_PATH (preferred) or CLAWDBOT_CONFIG_PATH (legacy).
  * Default: ~/.clawdbot/moltbot.json (or $*_STATE_DIR/moltbot.json)
  */
-export function resolveConfigPath(
+export function resolveCanonicalConfigPath(
   env: NodeJS.ProcessEnv = process.env,
   stateDir: string = resolveStateDir(env, os.homedir),
 ): string {
@@ -67,7 +83,56 @@ export function resolveConfigPath(
   return path.join(stateDir, CONFIG_FILENAME);
 }
 
-export const CONFIG_PATH = resolveConfigPath();
+/**
+ * Resolve the active config path by preferring existing config candidates
+ * (new/legacy filenames) before falling back to the canonical path.
+ */
+export function resolveConfigPathCandidate(
+  env: NodeJS.ProcessEnv = process.env,
+  homedir: () => string = os.homedir,
+): string {
+  const candidates = resolveDefaultConfigCandidates(env, homedir);
+  const existing = candidates.find((candidate) => {
+    try {
+      return fs.existsSync(candidate);
+    } catch {
+      return false;
+    }
+  });
+  if (existing) return existing;
+  return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+}
+
+/**
+ * Active config path (prefers existing legacy/new config files).
+ */
+export function resolveConfigPath(
+  env: NodeJS.ProcessEnv = process.env,
+  stateDir: string = resolveStateDir(env, os.homedir),
+  homedir: () => string = os.homedir,
+): string {
+  const override = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
+  if (override) return resolveUserPath(override);
+  const candidates = [
+    path.join(stateDir, CONFIG_FILENAME),
+    path.join(stateDir, LEGACY_CONFIG_FILENAME),
+  ];
+  const existing = candidates.find((candidate) => {
+    try {
+      return fs.existsSync(candidate);
+    } catch {
+      return false;
+    }
+  });
+  if (existing) return existing;
+  const defaultStateDir = resolveStateDir(env, homedir);
+  if (path.resolve(stateDir) === path.resolve(defaultStateDir)) {
+    return resolveConfigPathCandidate(env, homedir);
+  }
+  return path.join(stateDir, CONFIG_FILENAME);
+}
+
+export const CONFIG_PATH = resolveConfigPathCandidate();
 
 /**
  * Resolve default config path candidates across new + legacy locations.
@@ -84,14 +149,18 @@ export function resolveDefaultConfigCandidates(
   const moltbotStateDir = env.MOLTBOT_STATE_DIR?.trim();
   if (moltbotStateDir) {
     candidates.push(path.join(resolveUserPath(moltbotStateDir), CONFIG_FILENAME));
+    candidates.push(path.join(resolveUserPath(moltbotStateDir), LEGACY_CONFIG_FILENAME));
   }
   const legacyStateDirOverride = env.CLAWDBOT_STATE_DIR?.trim();
   if (legacyStateDirOverride) {
     candidates.push(path.join(resolveUserPath(legacyStateDirOverride), CONFIG_FILENAME));
+    candidates.push(path.join(resolveUserPath(legacyStateDirOverride), LEGACY_CONFIG_FILENAME));
   }
 
   candidates.push(path.join(newStateDir(homedir), CONFIG_FILENAME));
+  candidates.push(path.join(newStateDir(homedir), LEGACY_CONFIG_FILENAME));
   candidates.push(path.join(legacyStateDir(homedir), CONFIG_FILENAME));
+  candidates.push(path.join(legacyStateDir(homedir), LEGACY_CONFIG_FILENAME));
   return candidates;
 }