notoken-core 1.6.0 → 1.8.1

package/dist/utils/stabilityMatrixManager.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Stability Matrix Manager.
+ *
+ * Controls Stability Matrix without browser automation — reads/writes
+ * settings.json directly, launches packages via their launch commands,
+ * and manages models via the shared folder structure.
+ *
+ * SM stores config in:
+ *   <SM_DIR>/Data/settings.json     — main config
+ *   <SM_DIR>/Packages/<name>/       — installed packages
+ *   <SM_DIR>/Models/                — shared models folder
+ */
+export interface SMLocation {
+    path: string;
+    platform: "windows" | "wsl";
+    settingsPath: string;
+    packagesDir: string;
+    modelsDir: string;
+}
+export declare function findStabilityMatrix(): SMLocation | null;
+export interface SMSettings {
+    InstalledPackages: SMPackage[];
+    ActiveInstalledPackage: string;
+    FirstLaunchSetupComplete: boolean;
+    Theme: string;
+    PreferredGpu?: {
+        Name: string;
+        MemoryBytes: number;
+        IsNvidia: boolean;
+    };
+    [key: string]: unknown;
+}
+export interface SMPackage {
+    Id: string;
+    DisplayName: string;
+    PackageName: string;
+    Version: {
+        InstalledBranch: string;
+        InstalledCommitSha: string;
+    };
+    LibraryPath: string;
+    LaunchCommand: string;
+    LaunchArgs: Array<{
+        Name: string;
+        Type: string;
+        OptionValue: unknown;
+    }>;
+    PythonVersion: string;
+}
+export declare function readSMSettings(sm: SMLocation): SMSettings | null;
+export declare function writeSMSettings(sm: SMLocation, settings: SMSettings): void;
+export declare function getInstalledPackages(sm: SMLocation): SMPackage[];
+export declare function getActivePackage(sm: SMLocation): SMPackage | null;
+export declare function isPackageRunning(sm: SMLocation): {
+    running: boolean;
+    port: number;
+    url: string;
+};
+export declare function launchPackage(sm: SMLocation, pkg?: SMPackage): {
+    success: boolean;
+    message: string;
+};
+export declare function stopPackage(): {
+    success: boolean;
+    message: string;
+};
+export interface ModelInfo {
+    name: string;
+    path: string;
+    size: string;
+    type: "checkpoint" | "lora" | "vae" | "embedding" | "controlnet" | "other";
+}
+export declare function listModels(sm: SMLocation): ModelInfo[];
+export declare function downloadModel(sm: SMLocation, url: string, name?: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function formatSMStatus(sm: SMLocation): string;
+export declare function setLaunchArgs(sm: SMLocation, args: Record<string, boolean>): void;
+export declare function enableAPI(sm: SMLocation): void;

package/dist/utils/stabilityMatrixManager.js

@@ -0,0 +1,268 @@
+/**
+ * Stability Matrix Manager.
+ *
+ * Controls Stability Matrix without browser automation — reads/writes
+ * settings.json directly, launches packages via their launch commands,
+ * and manages models via the shared folder structure.
+ *
+ * SM stores config in:
+ *   <SM_DIR>/Data/settings.json     — main config
+ *   <SM_DIR>/Packages/<name>/       — installed packages
+ *   <SM_DIR>/Models/                — shared models folder
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+};
+function tryExec(cmd, timeout = 5000) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function findStabilityMatrix() {
+    const candidates = [
+        // WSL paths to Windows drives
+        "/mnt/d/notoken/ai/StabilityMatrix",
+        "/mnt/c/notoken/ai/StabilityMatrix",
+        "/mnt/d/StabilityMatrix",
+        resolve(homedir(), "StabilityMatrix"),
+        resolve(homedir(), "AppData", "Local", "StabilityMatrix"),
+        // Native Windows paths
+        "D:\\notoken\\ai\\StabilityMatrix",
+        "C:\\notoken\\ai\\StabilityMatrix",
+    ];
+    for (const p of candidates) {
+        const settingsPath = resolve(p, "Data", "settings.json");
+        if (existsSync(settingsPath)) {
+            const isWSL = p.startsWith("/mnt/");
+            return {
+                path: p,
+                platform: isWSL ? "wsl" : "windows",
+                settingsPath,
+                packagesDir: resolve(p, "Data", "Packages"),
+                modelsDir: resolve(p, "Data", "Models"),
+            };
+        }
+        // Also check if SM exe exists without settings yet
+        if (existsSync(resolve(p, "StabilityMatrix.exe"))) {
+            const isWSL = p.startsWith("/mnt/");
+            return {
+                path: p,
+                platform: isWSL ? "wsl" : "windows",
+                settingsPath: resolve(p, "Data", "settings.json"),
+                packagesDir: resolve(p, "Data", "Packages"),
+                modelsDir: resolve(p, "Data", "Models"),
+            };
+        }
+    }
+    return null;
+}
+export function readSMSettings(sm) {
+    try {
+        return JSON.parse(readFileSync(sm.settingsPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSMSettings(sm, settings) {
+    mkdirSync(resolve(sm.settingsPath, ".."), { recursive: true });
+    writeFileSync(sm.settingsPath, JSON.stringify(settings, null, 2));
+}
+// ─── Package Management ────────────────────────────────────────────────────
+export function getInstalledPackages(sm) {
+    const settings = readSMSettings(sm);
+    return settings?.InstalledPackages ?? [];
+}
+export function getActivePackage(sm) {
+    const settings = readSMSettings(sm);
+    if (!settings)
+        return null;
+    return settings.InstalledPackages.find(p => p.Id === settings.ActiveInstalledPackage) ?? null;
+}
+export function isPackageRunning(sm) {
+    // Check common ports
+    for (const port of [7860, 7861, 8188, 9090]) {
+        const check = tryExec(`curl -sf --max-time 2 http://localhost:${port}/sdapi/v1/sd-models 2>/dev/null`);
+        if (check)
+            return { running: true, port, url: `http://localhost:${port}` };
+        // ComfyUI
+        const comfyCheck = tryExec(`curl -sf --max-time 2 http://localhost:${port}/system_stats 2>/dev/null`);
+        if (comfyCheck)
+            return { running: true, port, url: `http://localhost:${port}` };
+    }
+    return { running: false, port: 0, url: "" };
+}
+export function launchPackage(sm, pkg) {
+    const active = pkg ?? getActivePackage(sm);
+    if (!active)
+        return { success: false, message: "No active package found in Stability Matrix" };
+    const pkgDir = resolve(sm.packagesDir, active.LibraryPath.replace(/\\/g, "/"));
+    if (!existsSync(pkgDir))
+        return { success: false, message: `Package directory not found: ${pkgDir}` };
+    // Build launch args
+    const args = active.LaunchArgs
+        .filter(a => a.OptionValue === true)
+        .map(a => a.Name)
+        .join(" ");
+    const launchCmd = active.LaunchCommand;
+    const pythonDir = resolve(sm.path, "Data", "Assets", `python-${active.PythonVersion}`);
+    const venvDir = resolve(pkgDir, "venv");
+    // Launch via Windows PowerShell (SM packages run on Windows)
+    if (sm.platform === "wsl") {
+        const winPkgDir = tryExec(`wslpath -w "${pkgDir}"`);
+        if (!winPkgDir)
+            return { success: false, message: "Could not convert path" };
+        try {
+            execSync(`/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe -Command "Start-Process -WorkingDirectory '${winPkgDir}' -FilePath 'python' -ArgumentList '${launchCmd} --api ${args}' -WindowStyle Normal" 2>/dev/null`, { stdio: "ignore", timeout: 10000 });
+            return { success: true, message: `${c.green}✓${c.reset} Launched ${active.DisplayName} (${launchCmd} --api ${args})` };
+        }
+        catch (err) {
+            return { success: false, message: `Launch failed: ${err instanceof Error ? err.message : err}` };
+        }
+    }
+    // Native Windows
+    try {
+        execSync(`start "" /D "${pkgDir}" python ${launchCmd} --api ${args}`, { stdio: "ignore", shell: "cmd.exe", timeout: 10000 });
+        return { success: true, message: `${c.green}✓${c.reset} Launched ${active.DisplayName}` };
+    }
+    catch (err) {
+        return { success: false, message: `Launch failed: ${err instanceof Error ? err.message : err}` };
+    }
+}
+export function stopPackage() {
+    // Kill python processes running SD
+    try {
+        const killed = tryExec("pkill -f 'launch.py\\|webui.py\\|main.py' 2>/dev/null");
+        // Also try Windows side
+        tryExec(`/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe -Command "Get-Process python -ErrorAction SilentlyContinue | Where-Object {\\$_.CommandLine -like '*launch.py*'} | Stop-Process -Force" 2>/dev/null`);
+        return { success: true, message: `${c.green}✓${c.reset} Stopped SD processes` };
+    }
+    catch {
+        return { success: false, message: "Could not stop processes" };
+    }
+}
+export function listModels(sm) {
+    const models = [];
+    const modelsDir = sm.modelsDir;
+    if (!existsSync(modelsDir))
+        return models;
+    const typeMap = {
+        "StableDiffusion": "checkpoint",
+        "Lora": "lora",
+        "VAE": "vae",
+        "TextualInversion": "embedding",
+        "ControlNet": "controlnet",
+    };
+    for (const [dirName, type] of Object.entries(typeMap)) {
+        const typeDir = resolve(modelsDir, dirName);
+        if (!existsSync(typeDir))
+            continue;
+        try {
+            for (const file of readdirSync(typeDir, { recursive: true })) {
+                const fName = String(file);
+                if (fName.endsWith(".safetensors") || fName.endsWith(".ckpt") || fName.endsWith(".pt")) {
+                    const fullPath = resolve(typeDir, fName);
+                    const size = tryExec(`du -sh "${fullPath}" 2>/dev/null`)?.split("\t")[0] ?? "?";
+                    models.push({ name: fName, path: fullPath, size, type });
+                }
+            }
+        }
+        catch { }
+    }
+    return models;
+}
+export async function downloadModel(sm, url, name) {
+    const modelsDir = resolve(sm.modelsDir, "StableDiffusion");
+    mkdirSync(modelsDir, { recursive: true });
+    const fileName = name ?? url.split("/").pop() ?? "model.safetensors";
+    const destPath = resolve(modelsDir, fileName);
+    if (existsSync(destPath)) {
+        return { success: true, message: `${c.green}✓${c.reset} Model already exists: ${fileName}` };
+    }
+    console.log(`${c.dim}Downloading model to ${destPath}...${c.reset}`);
+    try {
+        execSync(`curl -L --progress-bar -o "${destPath}" "${url}"`, { stdio: "inherit", timeout: 600000 });
+        return { success: true, message: `${c.green}✓${c.reset} Model downloaded: ${fileName}` };
+    }
+    catch (err) {
+        return { success: false, message: `Download failed: ${err instanceof Error ? err.message : err}` };
+    }
+}
+// ─── Status Formatting ─────────────────────────────────────────────────────
+export function formatSMStatus(sm) {
+    const lines = [];
+    const settings = readSMSettings(sm);
+    const packages = getInstalledPackages(sm);
+    const active = getActivePackage(sm);
+    const running = isPackageRunning(sm);
+    const models = listModels(sm);
+    lines.push(`${c.bold}${c.cyan}Stability Matrix${c.reset}`);
+    lines.push(`  ${c.dim}Location: ${sm.path} (${sm.platform})${c.reset}`);
+    if (settings?.PreferredGpu) {
+        const gpu = settings.PreferredGpu;
+        const vram = (gpu.MemoryBytes / 1073741824).toFixed(1);
+        lines.push(`  ${c.dim}GPU: ${gpu.Name} (${vram}GB)${c.reset}`);
+    }
+    lines.push("");
+    // Packages
+    lines.push(`${c.bold}Installed Packages:${c.reset}`);
+    if (packages.length === 0) {
+        lines.push(`  ${c.dim}None — open SM and click "+" to install one${c.reset}`);
+    }
+    else {
+        for (const pkg of packages) {
+            const isActive = pkg.Id === settings?.ActiveInstalledPackage;
+            const icon = isActive ? (running.running ? `${c.green}⬤${c.reset}` : `${c.yellow}⬤${c.reset}`) : `${c.dim}○${c.reset}`;
+            const status = isActive && running.running ? `${c.green}running${c.reset} at ${running.url}` :
+                isActive ? `${c.yellow}active (stopped)${c.reset}` : `${c.dim}inactive${c.reset}`;
+            lines.push(`  ${icon} ${c.bold}${pkg.DisplayName}${c.reset} — ${status}`);
+            lines.push(`    ${c.dim}Python ${pkg.PythonVersion} | ${pkg.LaunchCommand} | Branch: ${pkg.Version.InstalledBranch}${c.reset}`);
+        }
+    }
+    lines.push("");
+    // Models
+    if (models.length > 0) {
+        lines.push(`${c.bold}Models:${c.reset}`);
+        for (const m of models) {
+            lines.push(`  ${c.dim}${m.type}:${c.reset} ${m.name} (${m.size})`);
+        }
+    }
+    else {
+        lines.push(`${c.bold}Models:${c.reset} ${c.dim}None yet — SM will download on first launch${c.reset}`);
+    }
+    return lines.join("\n");
+}
+// ─── Configure Launch Args ─────────────────────────────────────────────────
+export function setLaunchArgs(sm, args) {
+    const settings = readSMSettings(sm);
+    if (!settings)
+        return;
+    const active = settings.InstalledPackages.find(p => p.Id === settings.ActiveInstalledPackage);
+    if (!active)
+        return;
+    for (const [name, value] of Object.entries(args)) {
+        const existing = active.LaunchArgs.find(a => a.Name === name);
+        if (existing) {
+            existing.OptionValue = value;
+        }
+        else {
+            active.LaunchArgs.push({ Name: name, Type: "Bool", OptionValue: value });
+        }
+    }
+    // Ensure --api is always enabled for NoToken integration
+    if (!active.LaunchArgs.find(a => a.Name === "--api")) {
+        active.LaunchArgs.push({ Name: "--api", Type: "Bool", OptionValue: true });
+    }
+    writeSMSettings(sm, settings);
+}
+export function enableAPI(sm) {
+    setLaunchArgs(sm, { "--api": true, "--listen": true });
+}

package/dist/utils/teachMode.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Teach Mode — let users define custom command mappings.
+ *
+ * "remember that deploy means git pull && npm install && pm2 restart"
+ * Next time: "deploy" → runs that command chain
+ *
+ * Stored in ~/.notoken/learned-commands.json
+ */
+interface LearnedCommand {
+    trigger: string;
+    command: string;
+    description?: string;
+    learnedAt: string;
+    usedCount: number;
+}
+/**
+ * Teach a new command.
+ * "remember that deploy means git pull && npm install && pm2 restart api"
+ */
+export declare function teachCommand(trigger: string, command: string, description?: string): void;
+/**
+ * Look up a learned command by trigger.
+ */
+export declare function getLearnedCommand(trigger: string): LearnedCommand | null;
+/**
+ * List all learned commands.
+ */
+export declare function listLearnedCommands(): LearnedCommand[];
+/**
+ * Forget a learned command.
+ */
+export declare function forgetCommand(trigger: string): boolean;
+/**
+ * Parse a "remember that X means Y" statement.
+ * Returns { trigger, command } or null.
+ */
+export declare function parseTeachStatement(text: string): {
+    trigger: string;
+    command: string;
+} | null;
+export {};

package/dist/utils/teachMode.js

@@ -0,0 +1,100 @@
+/**
+ * Teach Mode — let users define custom command mappings.
+ *
+ * "remember that deploy means git pull && npm install && pm2 restart"
+ * Next time: "deploy" → runs that command chain
+ *
+ * Stored in ~/.notoken/learned-commands.json
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+const LEARNED_PATH = resolve(homedir(), ".notoken", "learned-commands.json");
+let _commands = null;
+function load() {
+    if (_commands)
+        return _commands;
+    if (existsSync(LEARNED_PATH)) {
+        try {
+            _commands = JSON.parse(readFileSync(LEARNED_PATH, "utf-8"));
+            return _commands;
+        }
+        catch { }
+    }
+    _commands = [];
+    return _commands;
+}
+function save() {
+    const dir = resolve(LEARNED_PATH, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(LEARNED_PATH, JSON.stringify(load(), null, 2));
+}
+/**
+ * Teach a new command.
+ * "remember that deploy means git pull && npm install && pm2 restart api"
+ */
+export function teachCommand(trigger, command, description) {
+    const cmds = load();
+    const existing = cmds.findIndex(c => c.trigger.toLowerCase() === trigger.toLowerCase());
+    if (existing >= 0) {
+        cmds[existing].command = command;
+        cmds[existing].description = description;
+        cmds[existing].learnedAt = new Date().toISOString();
+    }
+    else {
+        cmds.push({ trigger: trigger.toLowerCase(), command, description, learnedAt: new Date().toISOString(), usedCount: 0 });
+    }
+    save();
+}
+/**
+ * Look up a learned command by trigger.
+ */
+export function getLearnedCommand(trigger) {
+    const cmds = load();
+    const found = cmds.find(c => c.trigger.toLowerCase() === trigger.toLowerCase());
+    if (found) {
+        found.usedCount++;
+        if (found.usedCount % 5 === 0)
+            save(); // periodic save
+    }
+    return found ?? null;
+}
+/**
+ * List all learned commands.
+ */
+export function listLearnedCommands() {
+    return [...load()].sort((a, b) => b.usedCount - a.usedCount);
+}
+/**
+ * Forget a learned command.
+ */
+export function forgetCommand(trigger) {
+    const cmds = load();
+    const idx = cmds.findIndex(c => c.trigger.toLowerCase() === trigger.toLowerCase());
+    if (idx >= 0) {
+        cmds.splice(idx, 1);
+        save();
+        return true;
+    }
+    return false;
+}
+/**
+ * Parse a "remember that X means Y" statement.
+ * Returns { trigger, command } or null.
+ */
+export function parseTeachStatement(text) {
+    // "remember that deploy means git pull && npm install"
+    const m1 = text.match(/^remember\s+(?:that\s+)?(.+?)\s+(?:means|is|equals|does|runs|executes)\s+(.+)$/i);
+    if (m1)
+        return { trigger: m1[1].trim(), command: m1[2].trim() };
+    // "when I say deploy, run git pull && npm install"
+    const m2 = text.match(/^when\s+(?:i\s+)?say\s+(.+?),?\s+(?:run|execute|do)\s+(.+)$/i);
+    if (m2)
+        return { trigger: m2[1].trim(), command: m2[2].trim() };
+    // "teach: deploy = git pull && npm install"
+    const m3 = text.match(/^teach:?\s+(.+?)\s*=\s*(.+)$/i);
+    if (m3)
+        return { trigger: m3[1].trim(), command: m3[2].trim() };
+    return null;
+}

package/dist/utils/timer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Timer / Reminders — lightweight in-process countdown timers.
+ *
+ * When a timer expires it pushes a message to `pendingNotifications`
+ * so the next REPL tick can display it.
+ */
+export interface Timer {
+    id: number;
+    label: string;
+    endsAt: number;
+    timeout: NodeJS.Timeout;
+}
+/** Messages ready for the REPL to display on next tick. */
+export declare const pendingNotifications: string[];
+/** Start a countdown timer.  Returns the timer ID. */
+export declare function startTimer(minutes: number, label?: string): number;
+/** List active timers with remaining time. */
+export declare function listTimers(): string;
+/** Cancel a timer by ID. Returns true if found. */
+export declare function cancelTimer(id: number): boolean;
+/** Drain all pending notifications (caller should display them). */
+export declare function drainNotifications(): string[];

package/dist/utils/timer.js

@@ -0,0 +1,52 @@
+/**
+ * Timer / Reminders — lightweight in-process countdown timers.
+ *
+ * When a timer expires it pushes a message to `pendingNotifications`
+ * so the next REPL tick can display it.
+ */
+let nextId = 1;
+const timers = new Map();
+/** Messages ready for the REPL to display on next tick. */
+export const pendingNotifications = [];
+/** Start a countdown timer.  Returns the timer ID. */
+export function startTimer(minutes, label) {
+    const id = nextId++;
+    const tag = label ?? `Timer #${id}`;
+    const ms = minutes * 60_000;
+    const endsAt = Date.now() + ms;
+    const timeout = setTimeout(() => {
+        timers.delete(id);
+        pendingNotifications.push(`\x1b[33m⏰ ${tag} — ${minutes} min timer finished!\x1b[0m`);
+    }, ms);
+    // Allow the Node process to exit even if timers are running
+    if (timeout.unref)
+        timeout.unref();
+    timers.set(id, { id, label: tag, endsAt, timeout });
+    return id;
+}
+/** List active timers with remaining time. */
+export function listTimers() {
+    if (timers.size === 0)
+        return "No active timers.";
+    const lines = [];
+    for (const t of timers.values()) {
+        const remaining = Math.max(0, Math.ceil((t.endsAt - Date.now()) / 1000));
+        const m = Math.floor(remaining / 60);
+        const s = remaining % 60;
+        lines.push(`  #${t.id}  ${t.label}  — ${m}m ${s}s remaining`);
+    }
+    return `Active timers:\n${lines.join("\n")}`;
+}
+/** Cancel a timer by ID. Returns true if found. */
+export function cancelTimer(id) {
+    const t = timers.get(id);
+    if (!t)
+        return false;
+    clearTimeout(t.timeout);
+    timers.delete(id);
+    return true;
+}
+/** Drain all pending notifications (caller should display them). */
+export function drainNotifications() {
+    return pendingNotifications.splice(0, pendingNotifications.length);
+}

package/dist/utils/updater.d.ts

@@ -30,3 +30,4 @@ export declare function runUpdate(): string;
  * Format update banner for terminal.
  */
 export declare function formatUpdateBanner(info: UpdateInfo): string;
+export declare function isNewer(latest: string, current: string): boolean;

package/dist/utils/updater.js

@@ -113,7 +113,7 @@ function getInstalledVersion() {
         return "0.0.0";
     }
 }
-function isNewer(latest, current) {
+export function isNewer(latest, current) {
     const l = latest.split(".").map(Number);
     const c = current.split(".").map(Number);
     for (let i = 0; i < 3; i++) {

package/dist/utils/userContext.d.ts

@@ -0,0 +1,57 @@
+/**
+ * User Context — detect who's running notoken and where their configs live.
+ *
+ * Handles: root, regular user, WSL user running as root, Windows user
+ * Prevents: auth conflicts, wrong config paths, stale tokens from other users
+ */
+export interface UserContext {
+    /** Effective user running the process */
+    effectiveUser: string;
+    /** Logged-in user (may differ from effective in sudo/WSL) */
+    loginUser: string;
+    /** Home directory of the effective user */
+    homeDir: string;
+    /** Home directory of the login user (for finding their configs) */
+    loginHomeDir: string;
+    /** Whether running as root */
+    isRoot: boolean;
+    /** Whether running in WSL */
+    isWSL: boolean;
+    /** Whether running on native Windows */
+    isWindows: boolean;
+    /** Windows user profile path (if in WSL or Windows) */
+    windowsProfile: string | null;
+    /** Path to this user's OpenClaw config */
+    openclawHome: string;
+    /** Path to this user's Claude credentials */
+    claudeCredsPath: string;
+    /** Path to this user's Codex auth */
+    codexAuthPath: string;
+    /** Path to this user's notoken data */
+    notokenHome: string;
+}
+/**
+ * Detect the current user context.
+ */
+export declare function getUserContext(): UserContext;
+/**
+ * Get the right OpenClaw auth profiles path for the current user.
+ */
+export declare function getAuthProfilesPath(): string;
+/**
+ * Detect if there's a user mismatch (running as root but configs belong to another user).
+ */
+export declare function detectUserMismatch(): {
+    mismatch: boolean;
+    message: string;
+};
+/**
+ * Find the freshest Claude token across all users.
+ */
+export declare function findFreshestClaudeToken(): {
+    token: string;
+    expires: number;
+    source: string;
+} | null;
+/** Reset cache (for testing). */
+export declare function resetUserContext(): void;