notoken-core 1.8.0 → 1.8.1

package/dist/nlp/llmFallback.js

@@ -10,6 +10,18 @@
 import { execSync } from "node:child_process";
 import { loadIntents } from "../utils/config.js";
 import { detectLocalPlatform } from "../utils/platform.js";
+/** Conversation history for multi-turn LLM disambiguation */
+const _llmConversation = [];
+/** Add a turn to the LLM conversation for multi-turn context */
+export function addLLMContext(role, content) {
+    _llmConversation.push({ role, content });
+    if (_llmConversation.length > 10)
+        _llmConversation.splice(0, _llmConversation.length - 10);
+}
+/** Clear LLM conversation when topic changes */
+export function clearLLMContext() { _llmConversation.length = 0; }
+/** Get conversation for context in multi-turn */
+export function getLLMContext() { return [..._llmConversation]; }
 /**
  * Check if any LLM is configured.
  */
@@ -98,6 +110,55 @@ export async function llmFallback(rawText, context) {
     }
     return null;
 }
+/**
+ * Multi-turn LLM disambiguation.
+ *
+ * 1. Ask the LLM what to do
+ * 2. If it needs more info → run gatherCommands → feed results back
+ * 3. Repeat up to maxTurns times
+ * 4. Return the final result
+ */
+export async function llmMultiTurn(rawText, context, options) {
+    const maxTurns = options?.maxTurns ?? 3;
+    const onProgress = options?.onProgress ?? (() => { });
+    // Turn 1: initial LLM call
+    onProgress("Asking LLM to interpret...");
+    let result = await llmFallback(rawText, context);
+    if (!result)
+        return null;
+    // Multi-turn loop: if LLM needs more info, run commands and ask again
+    for (let turn = 1; turn < maxTurns && result?.needsMoreInfo && result.gatherCommands?.length; turn++) {
+        const commands = result.gatherCommands;
+        onProgress(`Turn ${turn + 1}: Running ${commands.length} command(s) to gather info...`);
+        // Run each gather command
+        const commandResults = [];
+        for (const cmd of commands) {
+            onProgress(`  Running: ${cmd.command}`);
+            try {
+                const { execSync } = await import("node:child_process");
+                const output = execSync(cmd.command, {
+                    encoding: "utf-8",
+                    timeout: 15_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                }).trim();
+                commandResults.push({ ...cmd, output: output.substring(0, 1000) });
+            }
+            catch (err) {
+                const e = err;
+                commandResults.push({ ...cmd, output: `ERROR: ${e.message?.split("\n")[0] ?? "failed"}` });
+            }
+        }
+        // Build follow-up prompt with command outputs
+        const outputSummary = commandResults.map(r => `Command: ${r.command}\nPurpose: ${r.purpose}\nOutput:\n${r.output}`).join("\n\n");
+        const followUpText = `${rawText}\n\n--- COMMAND OUTPUTS ---\n${outputSummary}\n\nBased on these results, complete this JSON template. Replace FILL with values:\n\`\`\`json\n{"understood": FILL, "restatement": "FILL", "suggestedIntents": [{"intent": "FILL", "fields": {}, "confidence": FILL, "reasoning": "FILL"}], "needsMoreInfo": false}\n\`\`\``;
+        onProgress("Analyzing results...");
+        result = await llmFallback(followUpText, context);
+        // Track conversation
+        addLLMContext("user", rawText);
+        addLLMContext("assistant", JSON.stringify(commandResults));
+    }
+    return result;
+}
 async function tryLLMCli(rawText, context) {
     const cli = process.env.NOTOKEN_LLM_CLI;
     if (!cli)
@@ -193,16 +254,21 @@ async function tryOllama(rawText, context) {
     const prompt = buildPrompt(rawText, context);
     const model = process.env.NOTOKEN_OLLAMA_MODEL ?? "llama3.2";
     try {
-        const response = await fetch("http://localhost:11434/api/generate", {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 90_000);
+        // Use 127.0.0.1 explicitly — Node 18 fetch resolves localhost to IPv6 ::1 which Ollama doesn't listen on
+        const response = await fetch("http://127.0.0.1:11434/api/generate", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
+            signal: controller.signal,
             body: JSON.stringify({
                 model,
                 prompt,
                 stream: false,
-                options: { temperature: 0.1, num_predict: 1024 },
+                options: { temperature: 0.1, num_predict: 512 },
             }),
         });
+        clearTimeout(timeout);
         if (!response.ok)
             return null;
         const data = (await response.json());
@@ -211,7 +277,8 @@ async function tryOllama(rawText, context) {
             return null;
         return parseResponse(text);
     }
-    catch {
+    catch (err) {
+        console.error(`\x1b[2m[llm-ollama] ${err.message?.substring(0, 100)}\x1b[0m`);
         return null;
     }
 }
@@ -234,7 +301,7 @@ export function isOllamaInstalled() {
  */
 export async function getOllamaModels() {
     try {
-        const response = await fetch("http://localhost:11434/api/tags");
+        const response = await fetch("http://127.0.0.1:11434/api/tags");
         if (!response.ok)
             return [];
         const data = (await response.json());
@@ -246,50 +313,95 @@ export async function getOllamaModels() {
 }
 function buildPrompt(rawText, context) {
     const intents = loadIntents();
-    const intentSummary = intents.map((i) => {
-        const fields = Object.entries(i.fields)
-            .map(([k, v]) => `${k}:${v.type}${v.required ? "*" : ""}`)
-            .join(", ");
-        return `  ${i.name}: ${i.description} [${fields}]`;
-    }).join("\n");
     const platform = detectLocalPlatform();
-    return `You are a server operations CLI assistant. The user said something I couldn't parse with my rule-based system.
+    // Group intents by domain — much shorter than listing all 298
+    const domains = new Map();
+    for (const i of intents) {
+        const domain = i.name.split(".")[0];
+        if (!domains.has(domain))
+            domains.set(domain, []);
+        domains.get(domain).push(`${i.name}: ${i.description}`);
+    }
+    // Only include top-level summary + relevant domains based on user input
+    const relevantDomains = [];
+    const inputLower = rawText.toLowerCase();
+    for (const [domain, items] of domains) {
+        // Include domains that might be relevant to the query
+        const domainKeywords = {
+            service: ["service", "restart", "start", "stop", "status", "running"],
+            server: ["server", "cpu", "memory", "disk", "load", "uptime"],
+            docker: ["docker", "container", "image", "compose"],
+            network: ["network", "ip", "port", "ping", "dns", "curl", "speed"],
+            git: ["git", "commit", "push", "pull", "branch", "merge"],
+            deploy: ["deploy", "release", "rollback"],
+            logs: ["log", "error", "tail", "search"],
+            security: ["security", "attack", "firewall", "scan", "block"],
+            disk: ["disk", "space", "cleanup", "scan", "drive"],
+            db: ["database", "mysql", "postgres", "query", "sql"],
+            openclaw: ["openclaw", "claw", "gateway", "discord"],
+            ollama: ["ollama", "llm", "model"],
+            ai: ["image", "generate", "stable diffusion"],
+            files: ["file", "find", "copy", "move", "delete"],
+            process: ["process", "kill", "pid"],
+            user: ["user", "who", "login"],
+            backup: ["backup", "restore", "snapshot"],
+            notoken: ["notoken", "status", "version", "update", "help"],
+        };
+        const keywords = domainKeywords[domain] ?? [domain];
+        if (keywords.some(k => inputLower.includes(k)) || items.length <= 5) {
+            relevantDomains.push(`\n  [${domain}] (${items.length} commands)\n${items.slice(0, 8).map(i => `    ${i}`).join("\n")}`);
+        }
+    }
+    // If no relevant domains found, include a general summary
+    if (relevantDomains.length === 0) {
+        for (const [domain, items] of [...domains].slice(0, 10)) {
+            relevantDomains.push(`  [${domain}]: ${items.slice(0, 3).map(i => i.split(":")[0]).join(", ")}...`);
+        }
+    }
+    // Recent conversation context
+    const recentIntents = context.recentIntents ?? [];
+    const recentContext = recentIntents.length > 0
+        ? `\nRECENT COMMANDS (what the user has been doing):\n  ${recentIntents.slice(0, 5).join(", ")}\n`
+        : "";
+    // Known entities
+    const entities = context.knownEntities ?? [];
+    const entityContext = entities.length > 0
+        ? `\nKNOWN ENTITIES:\n  ${entities.slice(0, 10).map(e => `${e.entity} (${e.type})`).join(", ")}\n`
+        : "";
+    return `You are NoToken, a server operations CLI assistant. The user said something my NLP couldn't parse. Help me understand what they want.
 
 ENVIRONMENT:
-  OS: ${platform.distro}${platform.isWSL ? " (WSL)" : ""}
-  Kernel: ${platform.kernel}
-  Arch: ${platform.arch}
-  Shell: ${platform.shell}
-  Package manager: ${platform.packageManager}
-  Init system: ${platform.initSystem}
-
+  OS: ${platform.distro}${platform.isWSL ? " (WSL)" : ""} | Shell: ${platform.shell}
+  Package manager: ${platform.packageManager} | Init: ${platform.initSystem}
+${recentContext}${entityContext}
 USER INPUT: "${rawText}"
 
-CONTEXT:
-${JSON.stringify(context, null, 2)}
+AVAILABLE COMMANDS (grouped by domain — ${intents.length} total):
+${relevantDomains.join("\n")}
 
-AVAILABLE INTENTS (these are the tools I can execute):
-${intentSummary}
+Complete this JSON template. Replace every FILL with actual values based on the user's input. Remove fields you don't need. Output ONLY the completed JSON:
 
-Respond with ONLY a JSON object:
+\`\`\`json
 {
-  "understood": true/false,
-  "restatement": "In plain English, what the user wants to do",
+  "understood": FILL_true_or_false,
+  "restatement": "FILL_what_user_wants_in_plain_english",
   "suggestedIntents": [
-    {
-      "intent": "intent.name from list above",
-      "fields": { "field": "value" },
-      "confidence": 0.0-1.0,
-      "reasoning": "why this intent"
-    }
+    {"intent": "FILL_best_matching_command_from_list_above", "fields": {}, "confidence": FILL_0_to_1, "reasoning": "FILL_why_this_command"}
   ],
-  "todoSteps": [
-    { "step": 1, "description": "what to do first", "intent": "optional intent name" }
+  "needsMoreInfo": FILL_true_if_you_need_to_run_commands_first,
+  "gatherCommands": [
+    {"command": "FILL_shell_command_to_run", "purpose": "FILL_why_run_this"}
   ],
-  "missingInfo": ["things I'd need to ask the user"]
+  "shellCommands": ["FILL_raw_shell_command_if_no_intent_fits"],
+  "missingInfo": ["FILL_question_to_ask_user_if_unclear"]
 }
+\`\`\`
 
-Return ONLY JSON.`;
+Rules:
+- If one of my commands fits, use suggestedIntents and set needsMoreInfo=false.
+- If you need to investigate first, set needsMoreInfo=true and list gatherCommands with real shell commands (uptime, df -h, ps aux, curl, etc).
+- I will run those commands and send you the output for a second round.
+- Remove empty arrays. Output ONLY the JSON.`;
 }
 function parseResponse(raw) {
     try {

package/dist/nlp/llmParser.d.ts

@@ -5,4 +5,8 @@ import type { DynamicIntent } from "../types/intent.js";
  * Sends the raw text + context to an LLM and asks for structured JSON.
  * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
-export declare function parseByLLM(rawText: string): Promise<DynamicIntent | null>;
+export declare function parseByLLM(rawText: string, nearMisses?: Array<{
+    intent: string;
+    score: number;
+    source: string;
+}>): Promise<DynamicIntent | null>;

package/dist/nlp/llmParser.js

@@ -7,14 +7,14 @@ import { loadRules } from "../utils/config.js";
  * Sends the raw text + context to an LLM and asks for structured JSON.
  * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
-export async function parseByLLM(rawText) {
+export async function parseByLLM(rawText, nearMisses) {
     const endpoint = process.env.NOTOKEN_LLM_ENDPOINT;
     if (!endpoint)
         return null;
     const apiKey = process.env.NOTOKEN_LLM_API_KEY ?? "";
     const rules = loadRules();
     const intents = loadIntents();
-    const systemPrompt = buildSystemPrompt(intents, rules);
+    const systemPrompt = buildSystemPrompt(intents, rules, nearMisses);
     const userPrompt = `Parse this command into structured intent JSON:\n\n"${rawText}"`;
     try {
         const response = await fetch(endpoint, {
@@ -59,35 +59,54 @@ export async function parseByLLM(rawText) {
         return null;
     }
 }
-function buildSystemPrompt(intents, rules) {
-    const intentList = intents
-        .map((i) => {
-        const fields = Object.entries(i.fields)
-            .map(([k, v]) => `${k}(${v.type}${v.required ? ",required" : ""})`)
-            .join(", ");
-        return `- ${i.name}: ${i.description} [${fields}]`;
-    })
-        .join("\n");
+function buildSystemPrompt(intents, rules, nearMisses) {
+    // Build a concise intent list grouped by domain
+    const domains = new Map();
+    for (const i of intents) {
+        const domain = i.name.split(".")[0];
+        if (!domains.has(domain))
+            domains.set(domain, []);
+        const fields = Object.entries(i.fields).map(([k, v]) => `${k}:${v.type}`).join(", ");
+        domains.get(domain).push(`${i.name}${fields ? ` [${fields}]` : ""}`);
+    }
+    // If we have near-misses, show their full details + related intents
+    let nearMissSection = "";
+    if (nearMisses && nearMisses.length > 0) {
+        const nearMissDetails = nearMisses
+            .filter((v, i, a) => a.findIndex(x => x.intent === v.intent) === i) // dedup
+            .slice(0, 5)
+            .map(nm => {
+            const def = intents.find(i => i.name === nm.intent);
+            const fields = def ? Object.entries(def.fields).map(([k, v]) => `${k}:${v.type}`).join(", ") : "";
+            return `  - ${nm.intent} (${(nm.score * 100).toFixed(0)}% from ${nm.source}): ${def?.description ?? ""}${fields ? ` [${fields}]` : ""}`;
+        }).join("\n");
+        // Also include related intents from the same domains
+        const nearDomains = new Set(nearMisses.map(nm => nm.intent.split(".")[0]));
+        const relatedIntents = [...nearDomains].flatMap(d => (domains.get(d) ?? []).slice(0, 5)).join("\n    ");
+        nearMissSection = `\nNEAR MATCHES (my classifiers think it might be one of these — pick the best or suggest another):
+${nearMissDetails}
+
+RELATED COMMANDS in those domains:
+    ${relatedIntents}\n`;
+    }
+    // Compact domain summary for everything else
+    const domainSummary = [...domains].map(([d, items]) => `  [${d}]: ${items.slice(0, 4).join(", ")}${items.length > 4 ? ` +${items.length - 4} more` : ""}`).join("\n");
     const envs = Object.keys(rules.environmentAliases).join(", ");
     const services = Object.keys(rules.serviceAliases).join(", ");
-    return `You are a command parser for a server operations CLI.
-Parse the user's natural language command into a JSON object.
-
-Supported intents:
-${intentList}
+    return `You are NoToken, a server operations CLI command parser.
+Parse the user's natural language into a structured JSON intent.
+${nearMissSection}
+ALL AVAILABLE COMMANDS (${intents.length} total):
+${domainSummary}
 
 Known environments: ${envs}
 Known services: ${services}
 
-Return ONLY valid JSON with:
-- "intent": one of the intent names above, or "unknown"
-- "confidence": 0.0 to 1.0
-- "fields": object with all relevant fields for that intent
-
-Example: {"intent": "service.restart", "confidence": 0.9, "fields": {"service": "nginx", "environment": "prod"}}
+Return ONLY valid JSON:
+{"intent": "domain.command", "confidence": 0.0-1.0, "fields": {"field": "value"}}
 
-If you cannot determine the intent, return: {"intent": "unknown", "confidence": 0.1, "fields": {"reason": "..."}}
-Return ONLY the JSON object, no markdown.`;
+If unclear, return: {"intent": "unknown", "confidence": 0.1, "fields": {"reason": "...", "clarification": "What did you mean? Did you want to..."}}
+Return ONLY JSON, no markdown.`;
 }
 function extractContent(data) {
     if (data.choices && Array.isArray(data.choices)) {

package/dist/nlp/parseIntent.js

@@ -153,8 +153,26 @@ export async function parseIntent(rawText) {
         }
     }
     catch { /* semantic similarity not available */ }
-    // Stage 3: LLM fallback
-    const llmResult = await parseByLLM(rawText);
+    // Stage 3: LLM fallback — pass near-miss candidates as context
+    // Gather partial matches from classifiers for the LLM to consider
+    const nearMisses = [];
+    if (multiResult.best)
+        nearMisses.push({ intent: multiResult.best.intent, score: multiResult.best.score, source: "classifier" });
+    // Include runner-up from classifier votes if available
+    const allScores = multiResult.votes.reduce((acc, v) => { acc[v.intent] = Math.max(acc[v.intent] ?? 0, v.confidence); return acc; }, {});
+    const sortedIntents = Object.entries(allScores).sort((a, b) => b[1] - a[1]);
+    if (sortedIntents.length > 1)
+        nearMisses.push({ intent: sortedIntents[1][0], score: sortedIntents[1][1], source: "classifier" });
+    try {
+        const { findSimilarIntents } = await import("./semanticSimilarity.js");
+        for (const s of findSimilarIntents(rawText, 3)) {
+            nearMisses.push({ intent: s.intent, score: s.score, source: "similarity" });
+        }
+    }
+    catch { }
+    if (ruleResult)
+        nearMisses.push({ intent: ruleResult.intent, score: ruleResult.confidence, source: "rules" });
+    const llmResult = await parseByLLM(rawText, nearMisses);
     if (llmResult && llmResult.confidence >= 0.5) {
         return disambiguate(llmResult);
     }

package/dist/nlp/ruleParser.js

@@ -232,13 +232,44 @@ export function parseByRules(rawText) {
         const intentName = isDirList ? "dir.list" : "project.detect";
         return { intent: intentName, confidence: 0.9, rawText, fields: { path: "." } };
     }
-    // Pre-check: "how is openclaw doing" / "how is discord doing" → *.status
+    // Pre-check: "how is openclaw doing" / "status of openclaw" / "can you talk to openclaw"
     const howIsMatch = text.match(/^how(?:'s| is| are) (openclaw|claw|discord|ollama|notoken) (?:doing|going|running|working)/);
     if (howIsMatch) {
         const target = howIsMatch[1] === "claw" ? "openclaw" : howIsMatch[1];
         const intentName = target === "notoken" ? "notoken.status" : `${target}.status`;
         return { intent: intentName, confidence: 0.9, rawText, fields: {} };
     }
+    // "status of X" / "can you talk to X" / "diagnose X" / "check X"
+    // Also catches "can you talk to it" / "are you able to talk to it" with "it" passthrough
+    const statusOfMatch = text.match(/(?:status of|check on|talk to|communicate with|connect to|reach|diagnos\w*)\s+(openclaw|claw|discord|ollama|notoken)\b/);
+    if (statusOfMatch) {
+        const target = statusOfMatch[1] === "claw" ? "openclaw" : statusOfMatch[1];
+        const intentName = target === "notoken" ? "notoken.status" : `${target}.status`;
+        return { intent: intentName, confidence: 0.9, rawText, fields: {} };
+    }
+    // Pre-check: "uninstall ollama" → ollama.uninstall (not generic package.uninstall)
+    if (/\b(uninstall|remove|delete|get rid of)\s+ollama\b/i.test(text)) {
+        return { intent: "ollama.uninstall", confidence: 0.95, rawText, fields: {} };
+    }
+    // Pre-check: "do we have X" / "is X installed" → tool.info or specific status
+    const haveMatch = text.match(/\b(do we have|is|are)\s+(ollama|docker|nginx|node|python|git)\s+(installed|running|available|there|set ?up)\b/i)
+        ?? text.match(/\b(do we have|do i have)\s+(ollama|docker|nginx|node|python|git)\b/i);
+    if (haveMatch) {
+        const tool = haveMatch[2].toLowerCase();
+        if (tool === "ollama")
+            return { intent: "ollama.status", confidence: 0.9, rawText, fields: {} };
+        if (tool === "docker")
+            return { intent: "docker.list", confidence: 0.9, rawText, fields: {} };
+        return { intent: "tool.info", confidence: 0.9, rawText, fields: { tool } };
+    }
+    // Pre-check: file organization
+    if (/\b(organize|sort|tidy|clean ?up|arrange|categorize)\b.*\b(files?|folder|directory|downloads?|this)\b/i.test(text)
+        || /\b(files?|folder|directory|downloads?)\b.*\b(organize|sort|tidy|arrange|categorize)\b/i.test(text)) {
+        return { intent: "files.organize", confidence: 0.9, rawText, fields: {} };
+    }
+    if (/\bwhere\s+(should|do|can)\s+i\s+put\b/i.test(text) || /\bwhere\s+does\s+this\s+(go|belong)\b/i.test(text)) {
+        return { intent: "files.place", confidence: 0.9, rawText, fields: {} };
+    }
     // Match intent by synonyms defined in intents.json
     const matched = matchIntent(text, intents);
     if (!matched)

package/dist/utils/discordDiag.js

@@ -18,6 +18,7 @@
  * User only needs to handle captcha/MFA when patchright prompts.
  */
 import { execSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
 const c = {
     reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
     green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
@@ -66,18 +67,19 @@ async function discordApi(endpoint, token, method = "GET", body) {
     }
 }
 function getDiscordToken() {
-    const config = tryExec("cat /root/.openclaw/openclaw.json 2>/dev/null");
-    if (!config)
-        return "";
+    const home = process.env.USERPROFILE || process.env.HOME || "/root";
+    const sep = process.platform === "win32" ? "\\" : "/";
+    const configPath = `${home}${sep}.openclaw${sep}openclaw.json`;
     try {
-        const parsed = JSON.parse(config);
-        return parsed?.channels?.discord?.token
-            ?? parsed?.channels?.discord?.accounts?.default?.token
-            ?? "";
-    }
-    catch {
-        return "";
+        if (existsSync(configPath)) {
+            const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+            return parsed?.channels?.discord?.token
+                ?? parsed?.channels?.discord?.accounts?.default?.token
+                ?? "";
+        }
     }
+    catch { }
+    return "";
 }
 /** Sleep helper */
 function sleep(ms) {
@@ -404,7 +406,8 @@ export async function diagnoseDiscord() {
     // ── 1. Token valid? ──
     token = getDiscordToken();
     if (!token) {
-        const savedResult = tryExec("cat /mnt/c/temp/discord-bot-result.json 2>/dev/null");
+        const resultPath = process.platform === "win32" ? "C:\\temp\\discord-bot-result.json" : "/mnt/c/temp/discord-bot-result.json";
+        const savedResult = tryExec(`cat "${resultPath}" 2>/dev/null`);
         try {
             token = JSON.parse(savedResult)?.token ?? "";
         }
@@ -443,7 +446,12 @@ export async function diagnoseDiscord() {
             lines.push(`    ${c.dim}Patchright unavailable: ${e.message?.substring(0, 50)}${c.reset}`);
             // Fallback: open URL in browser
             const inviteUrl = `https://discord.com/oauth2/authorize?client_id=${appId}&permissions=68608&scope=bot`;
-            tryExec(`/mnt/c/Windows/System32/cmd.exe /c "start ${inviteUrl}" 2>/dev/null`);
+            if (process.platform === "win32") {
+                tryExec(`powershell -Command "Start-Process '${inviteUrl}'" 2>/dev/null`);
+            }
+            else {
+                tryExec(`/mnt/c/Windows/System32/cmd.exe /c "start ${inviteUrl}" 2>/dev/null`);
+            }
             lines.push(`    ${c.dim}Opened invite URL — add bot to server, then re-run this.${c.reset}`);
         }
         if (authorized) {

package/dist/utils/openclawDiag.d.ts

@@ -10,6 +10,104 @@
  *   6. What's the config state?
  *   7. Any errors in recent logs?
  */
+/**
+ * Check Claude CLI status and sync OAuth token to OpenClaw if needed.
+ * Full diagnostic:
+ *   1. Is Claude CLI installed?
+ *   2. Does Claude have a valid OAuth token?
+ *   3. Is OpenClaw's copy stale?
+ *   4. Sync if needed.
+ */
+/**
+ * Full OpenClaw auth refresh — uses expect for proper TTY flow,
+ * falls back to direct file write if expect unavailable.
+ *
+ * Flow:
+ *   1. Read fresh token from Claude CLI credentials
+ *   2. Try: expect → openclaw models auth paste-token --provider anthropic
+ *   3. Fallback: write directly to auth-profiles.json
+ *   4. Update lastGood pointer
+ */
+export declare function refreshOpenclawAuth(): {
+    success: boolean;
+    method: string;
+    message: string;
+};
+/**
+ * Sync Codex (OpenAI) OAuth token to OpenClaw.
+ * Reads from ~/.codex/auth.json
+ */
+/**
+ * Parse `openclaw models` output to understand current configuration.
+ */
+export declare function parseOpenclawModels(output: string): {
+    defaultModel: string | null;
+    configuredModels: string[];
+    providers: Array<{
+        name: string;
+        status: string;
+        hasAuth: boolean;
+    }>;
+    errors: string[];
+};
+/**
+ * Parse `openclaw status --deep` for health and channel details.
+ */
+export declare function parseOpenclawDeepStatus(output: string): {
+    health: Array<{
+        item: string;
+        status: string;
+        detail: string;
+    }>;
+    channels: Array<{
+        channel: string;
+        enabled: boolean;
+        state: string;
+        detail: string;
+    }>;
+    sessions: Array<{
+        key: string;
+        kind: string;
+        age: string;
+        model: string;
+        tokens: string;
+    }>;
+};
+/**
+ * Parse `openclaw status` output to understand gateway and system state.
+ */
+export declare function parseOpenclawStatus(output: string): {
+    dashboard: string | null;
+    gateway: {
+        status: string;
+        url: string | null;
+        reachable: boolean;
+        latency: string | null;
+    };
+    agents: {
+        count: number;
+        lastActive: string | null;
+    };
+    sessions: {
+        count: number;
+        defaultModel: string | null;
+        contextSize: string | null;
+    };
+    update: {
+        available: boolean;
+        version: string | null;
+    };
+    security: {
+        critical: number;
+        warn: number;
+        info: number;
+        issues: string[];
+    };
+    services: {
+        gateway: string;
+        node: string;
+    };
+};
 /**
  * Quick connectivity check — escalates from simplest to most thorough.
  * Used for "can you talk to openclaw?" / "is openclaw reachable?"