@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/infra/state-migrations.js

@@ -2,56 +2,67 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
-import { resolveOAuthDir, resolveStateDir } from "../config/paths.js";
+import { resolveLegacyStateDirs, resolveNewStateDir, resolveOAuthDir, resolveStateDir, } from "../config/paths.js";
 import { saveSessionStore } from "../config/sessions.js";
+import { canonicalizeMainSessionAlias } from "../config/sessions/main-session.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
 import { buildAgentMainSessionKey, DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, normalizeAgentId, } from "../routing/session-key.js";
-import { canonicalizeMainSessionAlias } from "../config/sessions/main-session.js";
 import { ensureDir, existsDir, fileExists, isLegacyWhatsAppAuthFile, readSessionStoreJson5, safeReadDir, } from "./state-migrations.fs.js";
 let autoMigrateChecked = false;
+let autoMigrateStateDirChecked = false;
 function isSurfaceGroupKey(key) {
     return key.includes(":group:") || key.includes(":channel:");
 }
 function isLegacyGroupKey(key) {
     const trimmed = key.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (trimmed.startsWith("group:"))
+    }
+    if (trimmed.startsWith("group:")) {
         return true;
+    }
     const lower = trimmed.toLowerCase();
-    if (!lower.includes("@g.us"))
+    if (!lower.includes("@g.us")) {
         return false;
+    }
     // Legacy WhatsApp group keys: bare JID or "whatsapp:<jid>" without explicit ":group:" kind.
-    if (!trimmed.includes(":"))
+    if (!trimmed.includes(":")) {
         return true;
-    if (lower.startsWith("whatsapp:") && !trimmed.includes(":group:"))
+    }
+    if (lower.startsWith("whatsapp:") && !trimmed.includes(":group:")) {
         return true;
+    }
     return false;
 }
 function canonicalizeSessionKeyForAgent(params) {
     const agentId = normalizeAgentId(params.agentId);
     const raw = params.key.trim();
-    if (!raw)
+    if (!raw) {
         return raw;
-    if (raw.toLowerCase() === "global" || raw.toLowerCase() === "unknown")
+    }
+    if (raw.toLowerCase() === "global" || raw.toLowerCase() === "unknown") {
         return raw.toLowerCase();
+    }
     const canonicalMain = canonicalizeMainSessionAlias({
         cfg: { session: { scope: params.scope, mainKey: params.mainKey } },
         agentId,
         sessionKey: raw,
     });
-    if (canonicalMain !== raw)
+    if (canonicalMain !== raw) {
         return canonicalMain.toLowerCase();
-    if (raw.toLowerCase().startsWith("agent:"))
+    }
+    if (raw.toLowerCase().startsWith("agent:")) {
         return raw.toLowerCase();
+    }
     if (raw.toLowerCase().startsWith("subagent:")) {
         const rest = raw.slice("subagent:".length);
         return `agent:${agentId}:subagent:${rest}`.toLowerCase();
     }
     if (raw.startsWith("group:")) {
         const id = raw.slice("group:".length).trim();
-        if (!id)
+        if (!id) {
             return raw;
+        }
         const channel = id.toLowerCase().includes("@g.us") ? "whatsapp" : "unknown";
         return `agent:${agentId}:${channel}:group:${id}`.toLowerCase();
     }
@@ -74,19 +85,25 @@ function pickLatestLegacyDirectEntry(store) {
     let best = null;
     let bestUpdated = -1;
     for (const [key, entry] of Object.entries(store)) {
-        if (!entry || typeof entry !== "object")
+        if (!entry || typeof entry !== "object") {
             continue;
+        }
         const normalized = key.trim();
-        if (!normalized)
+        if (!normalized) {
             continue;
-        if (normalized === "global")
+        }
+        if (normalized === "global") {
             continue;
-        if (normalized.startsWith("agent:"))
+        }
+        if (normalized.startsWith("agent:")) {
             continue;
-        if (normalized.toLowerCase().startsWith("subagent:"))
+        }
+        if (normalized.toLowerCase().startsWith("subagent:")) {
             continue;
-        if (isLegacyGroupKey(normalized) || isSurfaceGroupKey(normalized))
+        }
+        if (isLegacyGroupKey(normalized) || isSurfaceGroupKey(normalized)) {
             continue;
+        }
         const updatedAt = typeof entry.updatedAt === "number" ? entry.updatedAt : 0;
         if (updatedAt > bestUpdated) {
             bestUpdated = updatedAt;
@@ -97,8 +114,9 @@ function pickLatestLegacyDirectEntry(store) {
 }
 function normalizeSessionEntry(entry) {
     const sessionId = typeof entry.sessionId === "string" ? entry.sessionId : null;
-    if (!sessionId)
+    if (!sessionId) {
         return null;
+    }
     const updatedAt = typeof entry.updatedAt === "number" && Number.isFinite(entry.updatedAt)
         ? entry.updatedAt
         : Date.now();
@@ -116,14 +134,17 @@ function resolveUpdatedAt(entry) {
         : 0;
 }
 function mergeSessionEntry(params) {
-    if (!params.existing)
+    if (!params.existing) {
         return params.incoming;
+    }
     const existingUpdated = resolveUpdatedAt(params.existing);
     const incomingUpdated = resolveUpdatedAt(params.incoming);
-    if (incomingUpdated > existingUpdated)
+    if (incomingUpdated > existingUpdated) {
         return params.incoming;
-    if (incomingUpdated < existingUpdated)
+    }
+    if (incomingUpdated < existingUpdated) {
         return params.existing;
+    }
     return params.preferIncomingOnTie ? params.incoming : params.existing;
 }
 function canonicalizeSessionStore(params) {
@@ -131,8 +152,9 @@ function canonicalizeSessionStore(params) {
     const meta = new Map();
     const legacyKeys = [];
     for (const [key, entry] of Object.entries(params.store)) {
-        if (!entry || typeof entry !== "object")
+        if (!entry || typeof entry !== "object") {
             continue;
+        }
         const canonicalKey = canonicalizeSessionKeyForAgent({
             key,
             agentId: params.agentId,
@@ -140,8 +162,9 @@ function canonicalizeSessionStore(params) {
             scope: params.scope,
         });
         const isCanonical = canonicalKey === key;
-        if (!isCanonical)
+        if (!isCanonical) {
             legacyKeys.push(key);
+        }
         const existing = canonical[canonicalKey];
         if (!existing) {
             canonical[canonicalKey] = entry;
@@ -156,10 +179,12 @@ function canonicalizeSessionStore(params) {
             meta.set(canonicalKey, { isCanonical, updatedAt: incomingUpdated });
             continue;
         }
-        if (incomingUpdated < existingUpdated)
+        if (incomingUpdated < existingUpdated) {
             continue;
-        if (existingMeta?.isCanonical && !isCanonical)
+        }
+        if (existingMeta?.isCanonical && !isCanonical) {
             continue;
+        }
         if (!existingMeta?.isCanonical && isCanonical) {
             canonical[canonicalKey] = entry;
             meta.set(canonicalKey, { isCanonical, updatedAt: incomingUpdated });
@@ -177,21 +202,25 @@ function listLegacySessionKeys(params) {
             mainKey: params.mainKey,
             scope: params.scope,
         });
-        if (canonical !== key)
+        if (canonical !== key) {
             legacy.push(key);
+        }
     }
     return legacy;
 }
 function emptyDirOrMissing(dir) {
-    if (!existsDir(dir))
+    if (!existsDir(dir)) {
         return true;
+    }
     return safeReadDir(dir).length === 0;
 }
 function removeDirIfEmpty(dir) {
-    if (!existsDir(dir))
+    if (!existsDir(dir)) {
         return;
-    if (!emptyDirOrMissing(dir))
+    }
+    if (!emptyDirOrMissing(dir)) {
         return;
+    }
     try {
         fs.rmdirSync(dir);
     }
@@ -205,6 +234,218 @@ export function resetAutoMigrateLegacyStateForTest() {
 export function resetAutoMigrateLegacyAgentDirForTest() {
     resetAutoMigrateLegacyStateForTest();
 }
+export function resetAutoMigrateLegacyStateDirForTest() {
+    autoMigrateStateDirChecked = false;
+}
+function resolveSymlinkTarget(linkPath) {
+    try {
+        const target = fs.readlinkSync(linkPath);
+        return path.resolve(path.dirname(linkPath), target);
+    }
+    catch {
+        return null;
+    }
+}
+function formatStateDirMigration(legacyDir, targetDir) {
+    return `State dir: ${legacyDir} → ${targetDir} (legacy path now symlinked)`;
+}
+function isDirPath(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isWithinDir(targetPath, rootDir) {
+    const relative = path.relative(path.resolve(rootDir), path.resolve(targetPath));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function isLegacyTreeSymlinkMirror(currentDir, realTargetDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    if (entries.length === 0) {
+        return false;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(currentDir, entry.name);
+        let stat;
+        try {
+            stat = fs.lstatSync(entryPath);
+        }
+        catch {
+            return false;
+        }
+        if (stat.isSymbolicLink()) {
+            const resolvedTarget = resolveSymlinkTarget(entryPath);
+            if (!resolvedTarget) {
+                return false;
+            }
+            let resolvedRealTarget;
+            try {
+                resolvedRealTarget = fs.realpathSync(resolvedTarget);
+            }
+            catch {
+                return false;
+            }
+            if (!isWithinDir(resolvedRealTarget, realTargetDir)) {
+                return false;
+            }
+            continue;
+        }
+        if (stat.isDirectory()) {
+            if (!isLegacyTreeSymlinkMirror(entryPath, realTargetDir)) {
+                return false;
+            }
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function isLegacyDirSymlinkMirror(legacyDir, targetDir) {
+    let realTargetDir;
+    try {
+        realTargetDir = fs.realpathSync(targetDir);
+    }
+    catch {
+        return false;
+    }
+    return isLegacyTreeSymlinkMirror(legacyDir, realTargetDir);
+}
+export async function autoMigrateLegacyStateDir(params) {
+    if (autoMigrateStateDirChecked) {
+        return { migrated: false, skipped: true, changes: [], warnings: [] };
+    }
+    autoMigrateStateDirChecked = true;
+    const env = params.env ?? process.env;
+    if (env.CLAWDBOT_STATE_DIR?.trim()) {
+        return { migrated: false, skipped: true, changes: [], warnings: [] };
+    }
+    const homedir = params.homedir ?? os.homedir;
+    const targetDir = resolveNewStateDir(homedir);
+    const legacyDirs = resolveLegacyStateDirs(homedir);
+    let legacyDir = legacyDirs.find((dir) => {
+        try {
+            return fs.existsSync(dir);
+        }
+        catch {
+            return false;
+        }
+    });
+    const warnings = [];
+    const changes = [];
+    let legacyStat = null;
+    try {
+        legacyStat = legacyDir ? fs.lstatSync(legacyDir) : null;
+    }
+    catch {
+        legacyStat = null;
+    }
+    if (!legacyStat) {
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    if (!legacyStat.isDirectory() && !legacyStat.isSymbolicLink()) {
+        warnings.push(`Legacy state path is not a directory: ${legacyDir}`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    let symlinkDepth = 0;
+    while (legacyStat.isSymbolicLink()) {
+        const legacyTarget = legacyDir ? resolveSymlinkTarget(legacyDir) : null;
+        if (!legacyTarget) {
+            warnings.push(`Legacy state dir is a symlink (${legacyDir ?? "unknown"}); could not resolve target.`);
+            return { migrated: false, skipped: false, changes, warnings };
+        }
+        if (path.resolve(legacyTarget) === path.resolve(targetDir)) {
+            return { migrated: false, skipped: false, changes, warnings };
+        }
+        if (legacyDirs.some((dir) => path.resolve(dir) === path.resolve(legacyTarget))) {
+            legacyDir = legacyTarget;
+            try {
+                legacyStat = fs.lstatSync(legacyDir);
+            }
+            catch {
+                legacyStat = null;
+            }
+            if (!legacyStat) {
+                warnings.push(`Legacy state dir missing after symlink resolution: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            if (!legacyStat.isDirectory() && !legacyStat.isSymbolicLink()) {
+                warnings.push(`Legacy state path is not a directory: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            symlinkDepth += 1;
+            if (symlinkDepth > 2) {
+                warnings.push(`Legacy state dir symlink chain too deep: ${legacyDir}`);
+                return { migrated: false, skipped: false, changes, warnings };
+            }
+            continue;
+        }
+        warnings.push(`Legacy state dir is a symlink (${legacyDir ?? "unknown"} → ${legacyTarget}); skipping auto-migration.`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    if (isDirPath(targetDir)) {
+        if (legacyDir && isLegacyDirSymlinkMirror(legacyDir, targetDir)) {
+            return { migrated: false, skipped: false, changes, warnings };
+        }
+        warnings.push(`State dir migration skipped: target already exists (${targetDir}). Remove or merge manually.`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    try {
+        if (!legacyDir) {
+            throw new Error("Legacy state dir not found");
+        }
+        fs.renameSync(legacyDir, targetDir);
+    }
+    catch (err) {
+        warnings.push(`Failed to move legacy state dir (${legacyDir ?? "unknown"} → ${targetDir}): ${String(err)}`);
+        return { migrated: false, skipped: false, changes, warnings };
+    }
+    try {
+        if (!legacyDir) {
+            throw new Error("Legacy state dir not found");
+        }
+        fs.symlinkSync(targetDir, legacyDir, "dir");
+        changes.push(formatStateDirMigration(legacyDir, targetDir));
+    }
+    catch (err) {
+        try {
+            if (process.platform === "win32") {
+                if (!legacyDir) {
+                    throw new Error("Legacy state dir not found", { cause: err });
+                }
+                fs.symlinkSync(targetDir, legacyDir, "junction");
+                changes.push(formatStateDirMigration(legacyDir, targetDir));
+            }
+            else {
+                throw err;
+            }
+        }
+        catch (fallbackErr) {
+            try {
+                if (!legacyDir) {
+                    // oxlint-disable-next-line preserve-caught-error
+                    throw new Error("Legacy state dir not found", { cause: fallbackErr });
+                }
+                fs.renameSync(targetDir, legacyDir);
+                warnings.push(`State dir migration rolled back (failed to link legacy path): ${String(fallbackErr)}`);
+                return { migrated: false, skipped: false, changes: [], warnings };
+            }
+            catch (rollbackErr) {
+                warnings.push(`State dir moved but failed to link legacy path (${legacyDir ?? "unknown"} → ${targetDir}): ${String(fallbackErr)}`);
+                warnings.push(`Rollback failed; set CLAWDBOT_STATE_DIR=${targetDir} to avoid split state: ${String(rollbackErr)}`);
+                changes.push(`State dir: ${legacyDir ?? "unknown"} → ${targetDir}`);
+            }
+        }
+    }
+    return { migrated: changes.length > 0, skipped: false, changes, warnings };
+}
 export async function detectLegacyStateMigrations(params) {
     const env = params.env ?? process.env;
     const homedir = params.homedir ?? os.homedir;
@@ -283,8 +524,9 @@ export async function detectLegacyStateMigrations(params) {
 async function migrateLegacySessions(detected, now) {
     const changes = [];
     const warnings = [];
-    if (!detected.sessions.hasLegacy)
+    if (!detected.sessions.hasLegacy) {
         return { changes, warnings };
+    }
     ensureDir(detected.sessions.targetDir);
     const legacyParsed = fileExists(detected.sessions.legacyStorePath)
         ? readSessionStoreJson5(detected.sessions.legacyStorePath)
@@ -333,11 +575,14 @@ async function migrateLegacySessions(detected, now) {
         const normalized = {};
         for (const [key, entry] of Object.entries(merged)) {
             const normalizedEntry = normalizeSessionEntry(entry);
-            if (!normalizedEntry)
+            if (!normalizedEntry) {
                 continue;
+            }
             normalized[key] = normalizedEntry;
         }
-        await saveSessionStore(detected.sessions.targetStorePath, normalized);
+        await saveSessionStore(detected.sessions.targetStorePath, normalized, {
+            skipMaintenance: true,
+        });
         changes.push(`Merged sessions store → ${detected.sessions.targetStorePath}`);
         if (canonicalizedTarget.legacyKeys.length > 0) {
             changes.push(`Canonicalized ${canonicalizedTarget.legacyKeys.length} legacy session key(s)`);
@@ -345,14 +590,17 @@ async function migrateLegacySessions(detected, now) {
     }
     const entries = safeReadDir(detected.sessions.legacyDir);
     for (const entry of entries) {
-        if (!entry.isFile())
+        if (!entry.isFile()) {
             continue;
-        if (entry.name === "sessions.json")
+        }
+        if (entry.name === "sessions.json") {
             continue;
+        }
         const from = path.join(detected.sessions.legacyDir, entry.name);
         const to = path.join(detected.sessions.targetDir, entry.name);
-        if (fileExists(to))
+        if (fileExists(to)) {
             continue;
+        }
         try {
             fs.renameSync(from, to);
             changes.push(`Moved ${entry.name} → agents/${detected.targetAgentId}/sessions`);
@@ -388,15 +636,17 @@ async function migrateLegacySessions(detected, now) {
 export async function migrateLegacyAgentDir(detected, now) {
     const changes = [];
     const warnings = [];
-    if (!detected.agentDir.hasLegacy)
+    if (!detected.agentDir.hasLegacy) {
         return { changes, warnings };
+    }
     ensureDir(detected.agentDir.targetDir);
     const entries = safeReadDir(detected.agentDir.legacyDir);
     for (const entry of entries) {
         const from = path.join(detected.agentDir.legacyDir, entry.name);
         const to = path.join(detected.agentDir.targetDir, entry.name);
-        if (fs.existsSync(to))
+        if (fs.existsSync(to)) {
             continue;
+        }
         try {
             fs.renameSync(from, to);
             changes.push(`Moved agent file ${entry.name} → agents/${detected.targetAgentId}/agent`);
@@ -421,21 +671,26 @@ export async function migrateLegacyAgentDir(detected, now) {
 async function migrateLegacyWhatsAppAuth(detected) {
     const changes = [];
     const warnings = [];
-    if (!detected.whatsappAuth.hasLegacy)
+    if (!detected.whatsappAuth.hasLegacy) {
         return { changes, warnings };
+    }
     ensureDir(detected.whatsappAuth.targetDir);
     const entries = safeReadDir(detected.whatsappAuth.legacyDir);
     for (const entry of entries) {
-        if (!entry.isFile())
+        if (!entry.isFile()) {
             continue;
-        if (entry.name === "oauth.json")
+        }
+        if (entry.name === "oauth.json") {
             continue;
-        if (!isLegacyWhatsAppAuthFile(entry.name))
+        }
+        if (!isLegacyWhatsAppAuthFile(entry.name)) {
             continue;
+        }
         const from = path.join(detected.whatsappAuth.legacyDir, entry.name);
         const to = path.join(detected.whatsappAuth.targetDir, entry.name);
-        if (fileExists(to))
+        if (fileExists(to)) {
             continue;
+        }
         try {
             fs.renameSync(from, to);
             changes.push(`Moved WhatsApp auth ${entry.name} → whatsapp/default`);
@@ -466,8 +721,18 @@ export async function autoMigrateLegacyState(params) {
     }
     autoMigrateChecked = true;
     const env = params.env ?? process.env;
+    const stateDirResult = await autoMigrateLegacyStateDir({
+        env,
+        homedir: params.homedir,
+        log: params.log,
+    });
     if (env.CLAWDBOT_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
-        return { migrated: false, skipped: true, changes: [], warnings: [] };
+        return {
+            migrated: stateDirResult.migrated,
+            skipped: true,
+            changes: stateDirResult.changes,
+            warnings: stateDirResult.warnings,
+        };
     }
     const detected = await detectLegacyStateMigrations({
         cfg: params.cfg,
@@ -475,13 +740,18 @@ export async function autoMigrateLegacyState(params) {
         homedir: params.homedir,
     });
     if (!detected.sessions.hasLegacy && !detected.agentDir.hasLegacy) {
-        return { migrated: false, skipped: false, changes: [], warnings: [] };
+        return {
+            migrated: stateDirResult.migrated,
+            skipped: false,
+            changes: stateDirResult.changes,
+            warnings: stateDirResult.warnings,
+        };
     }
     const now = params.now ?? (() => Date.now());
     const sessions = await migrateLegacySessions(detected, now);
     const agentDir = await migrateLegacyAgentDir(detected, now);
-    const changes = [...sessions.changes, ...agentDir.changes];
-    const warnings = [...sessions.warnings, ...agentDir.warnings];
+    const changes = [...stateDirResult.changes, ...sessions.changes, ...agentDir.changes];
+    const warnings = [...stateDirResult.warnings, ...sessions.warnings, ...agentDir.warnings];
     const logger = params.log ?? createSubsystemLogger("state-migrations");
     if (changes.length > 0) {
         logger.info(`Auto-migrated legacy state:\n${changes.map((entry) => `- ${entry}`).join("\n")}`);

package/dist/infra/update-global.js

@@ -83,3 +83,38 @@ export function globalInstallArgs(manager, spec) {
         return ["bun", "add", "-g", spec];
     return ["npm", "i", "-g", spec];
 }
+const GLOBAL_RENAME_PREFIX = ".";
+export async function cleanupGlobalRenameDirs(params) {
+    const removed = [];
+    const root = params.globalRoot.trim();
+    const name = params.packageName.trim();
+    if (!root || !name) {
+        return { removed };
+    }
+    const prefix = `${GLOBAL_RENAME_PREFIX}${name}-`;
+    let entries = [];
+    try {
+        entries = await fs.readdir(root);
+    }
+    catch {
+        return { removed };
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith(prefix)) {
+            continue;
+        }
+        const target = path.join(root, entry);
+        try {
+            const stat = await fs.lstat(target);
+            if (!stat.isDirectory()) {
+                continue;
+            }
+            await fs.rm(target, { recursive: true, force: true });
+            removed.push(entry);
+        }
+        catch {
+            // ignore cleanup failures
+        }
+    }
+    return { removed };
+}