notoken-core 1.5.1 → 2.0.0

package/dist/automation/discordSetup.js

@@ -0,0 +1,338 @@
+/**
+ * Automated Discord bot setup via Playwright.
+ *
+ * Opens the Discord Developer Portal, walks the user through login,
+ * then automates: create application, create bot, copy token, enable
+ * Message Content Intent, generate OAuth2 invite URL, open it.
+ *
+ * The user only needs to:
+ *   1. Log in to Discord (notoken never touches credentials)
+ *   2. Pick which server to add the bot to
+ *
+ * Returns the bot token for OpenClaw channel registration.
+ */
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+};
+/**
+ * Detect available browser executable on the system.
+ * Prefers Edge (available on Windows), falls back to Chrome, then Chromium.
+ */
+async function findBrowserPath() {
+    const { execSync } = await import("node:child_process");
+    const candidates = [
+        // Windows browsers via WSL
+        "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe",
+        "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
+        "/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe",
+        // Linux browsers
+        "/usr/bin/google-chrome",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/chromium",
+        "/usr/bin/microsoft-edge",
+    ];
+    for (const path of candidates) {
+        try {
+            execSync(`ls "${path}" 2>/dev/null`, { stdio: "pipe" });
+            return path;
+        }
+        catch { /* not found */ }
+    }
+    return null;
+}
+/**
+ * Run the automated Discord bot setup.
+ *
+ * @param appName - Name for the Discord application (default: "OpenClaw")
+ * @param headless - Run headless (default: false — user needs to see login)
+ */
+export async function automateDiscordBotSetup(appName = "OpenClaw", headless = false) {
+    // Dynamic import — Playwright is optional, not a core dependency
+    let playwright;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        playwright = await Function('return import("playwright")')();
+    }
+    catch {
+        return {
+            success: false,
+            error: "Playwright not installed. Run: npm install -g playwright && npx playwright install chromium",
+        };
+    }
+    const browserPath = await findBrowserPath();
+    console.log(`\n${c.bold}${c.cyan}── Discord Bot Setup ──${c.reset}\n`);
+    let browser;
+    let context;
+    let page;
+    try {
+        // Launch browser — use Windows Edge if available for visible UI
+        console.log(`  ${c.dim}Launching browser...${c.reset}`);
+        if (browserPath?.includes("/mnt/c/")) {
+            // Windows browser via WSL — use channel launch
+            const winPath = browserPath
+                .replace("/mnt/c/", "C:\\")
+                .replace(/\//g, "\\");
+            browser = await playwright.chromium.launch({
+                headless: false, // Must be visible for user login
+                executablePath: browserPath,
+                args: ["--no-sandbox"],
+            });
+        }
+        else {
+            browser = await playwright.chromium.launch({
+                headless,
+                args: ["--no-sandbox"],
+            });
+        }
+        context = await browser.newContext({
+            viewport: { width: 1280, height: 900 },
+        });
+        page = await context.newPage();
+        // ── Step 1: Navigate to Discord Developer Portal ──
+        console.log(`  ${c.bold}1.${c.reset} Opening Discord Developer Portal...`);
+        await page.goto("https://discord.com/developers/applications", {
+            waitUntil: "networkidle",
+            timeout: 30_000,
+        });
+        // Check if login is needed
+        const url = page.url();
+        if (url.includes("/login")) {
+            console.log(`\n  ${c.yellow}${c.bold}Please log in to Discord in the browser window.${c.reset}`);
+            console.log(`  ${c.dim}Waiting for you to complete login...${c.reset}\n`);
+            // Wait for redirect to developer portal after login (up to 5 minutes)
+            await page.waitForURL("**/developers/applications**", { timeout: 300_000 });
+            console.log(`  ${c.green}✓${c.reset} Logged in successfully!\n`);
+        }
+        else {
+            console.log(`  ${c.green}✓${c.reset} Already logged in.\n`);
+        }
+        // ── Step 2: Create New Application ──
+        console.log(`  ${c.bold}2.${c.reset} Creating application "${appName}"...`);
+        await page.waitForTimeout(2000);
+        // Click "New Application" button
+        const newAppBtn = page.locator('button:has-text("New Application"), div[class*="actionButton"]:has-text("New Application")');
+        await newAppBtn.waitFor({ timeout: 10_000 });
+        await newAppBtn.click();
+        // Fill in the application name
+        await page.waitForTimeout(1000);
+        const nameInput = page.locator('input[placeholder*="name"], input[name="name"]').first();
+        await nameInput.waitFor({ timeout: 5_000 });
+        await nameInput.fill(appName);
+        // Check the ToS checkbox if present
+        const tosCheckbox = page.locator('input[type="checkbox"], label:has-text("policy")').first();
+        if (await tosCheckbox.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await tosCheckbox.click();
+        }
+        // Click Create
+        const createBtn = page.locator('button:has-text("Create")').first();
+        await createBtn.click();
+        await page.waitForTimeout(3000);
+        // Get the application ID from the URL
+        const appUrl = page.url();
+        const appIdMatch = appUrl.match(/applications\/(\d+)/);
+        const applicationId = appIdMatch?.[1] ?? "";
+        console.log(`  ${c.green}✓${c.reset} Application created${applicationId ? ` (ID: ${applicationId})` : ""}\n`);
+        // ── Step 3: Navigate to Bot tab and create bot ──
+        console.log(`  ${c.bold}3.${c.reset} Setting up bot...`);
+        // Click "Bot" in sidebar
+        const botTab = page.locator('a:has-text("Bot"), div[class*="item"]:has-text("Bot")').first();
+        await botTab.click();
+        await page.waitForTimeout(2000);
+        // Click "Reset Token" or "Add Bot" if needed
+        const resetTokenBtn = page.locator('button:has-text("Reset Token")').first();
+        const addBotBtn = page.locator('button:has-text("Add Bot")').first();
+        if (await addBotBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await addBotBtn.click();
+            await page.waitForTimeout(1000);
+            // Confirm
+            const confirmBtn = page.locator('button:has-text("Yes, do it!")').first();
+            if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+                await confirmBtn.click();
+            }
+            await page.waitForTimeout(2000);
+        }
+        // Reset/reveal token
+        if (await resetTokenBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
+            await resetTokenBtn.click();
+            await page.waitForTimeout(1000);
+            // Confirm reset
+            const confirmReset = page.locator('button:has-text("Yes, do it!")').first();
+            if (await confirmReset.isVisible({ timeout: 2000 }).catch(() => false)) {
+                await confirmReset.click();
+            }
+        }
+        // Wait for token to appear and copy it
+        await page.waitForTimeout(2000);
+        let botToken = "";
+        // Try to find the token in an input or code element
+        const tokenInput = page.locator('input[value*="."], span[class*="token"], div[class*="token"] input').first();
+        if (await tokenInput.isVisible({ timeout: 3000 }).catch(() => false)) {
+            botToken = await tokenInput.inputValue().catch(() => "");
+            if (!botToken) {
+                botToken = await tokenInput.textContent().catch(() => "") ?? "";
+            }
+        }
+        // Try clicking "Copy" button if token not grabbed directly
+        if (!botToken) {
+            const copyBtn = page.locator('button:has-text("Copy")').first();
+            if (await copyBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+                await copyBtn.click();
+                // Token is now in clipboard — try to read it
+                try {
+                    botToken = await page.evaluate(() => navigator.clipboard.readText());
+                }
+                catch {
+                    // Clipboard access denied — ask user
+                }
+            }
+        }
+        if (botToken) {
+            console.log(`  ${c.green}✓${c.reset} Bot token captured\n`);
+        }
+        else {
+            console.log(`  ${c.yellow}⚠${c.reset} Could not auto-capture token.`);
+            console.log(`  ${c.bold}Please copy the bot token from the browser and paste it here.${c.reset}\n`);
+        }
+        // ── Step 4: Enable Message Content Intent ──
+        console.log(`  ${c.bold}4.${c.reset} Enabling Message Content Intent...`);
+        // Scroll down to Privileged Gateway Intents
+        await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+        await page.waitForTimeout(1000);
+        // Find and enable Message Content Intent toggle
+        const messageContentLabel = page.locator('text=Message Content Intent, label:has-text("MESSAGE CONTENT INTENT")').first();
+        if (await messageContentLabel.isVisible({ timeout: 3000 }).catch(() => false)) {
+            // Find the toggle near this label
+            const toggle = page.locator('div:has-text("MESSAGE CONTENT INTENT") input[type="checkbox"], div:has-text("Message Content Intent") [role="switch"]').first();
+            if (await toggle.isVisible({ timeout: 2000 }).catch(() => false)) {
+                const isChecked = await toggle.isChecked().catch(() => false);
+                if (!isChecked) {
+                    await toggle.click();
+                    await page.waitForTimeout(500);
+                }
+            }
+        }
+        // Save changes
+        const saveBtn = page.locator('button:has-text("Save Changes")').first();
+        if (await saveBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
+            await saveBtn.click();
+            await page.waitForTimeout(1000);
+        }
+        console.log(`  ${c.green}✓${c.reset} Message Content Intent enabled\n`);
+        // ── Step 5: Generate OAuth2 invite URL ──
+        console.log(`  ${c.bold}5.${c.reset} Generating invite URL...`);
+        // Navigate to OAuth2 → URL Generator
+        const oauth2Tab = page.locator('a:has-text("OAuth2"), div[class*="item"]:has-text("OAuth2")').first();
+        await oauth2Tab.click();
+        await page.waitForTimeout(1000);
+        // Look for URL Generator sub-tab
+        const urlGenTab = page.locator('a:has-text("URL Generator"), div:has-text("URL Generator")').first();
+        if (await urlGenTab.isVisible({ timeout: 3000 }).catch(() => false)) {
+            await urlGenTab.click();
+            await page.waitForTimeout(1000);
+        }
+        // Select "bot" scope
+        const botScope = page.locator('label:has-text("bot"), input[value="bot"]').first();
+        if (await botScope.isVisible({ timeout: 3000 }).catch(() => false)) {
+            await botScope.click();
+            await page.waitForTimeout(1000);
+        }
+        // Select permissions: Send Messages, Read Messages
+        for (const perm of ["Send Messages", "Read Message History", "View Channels"]) {
+            const permLabel = page.locator(`label:has-text("${perm}")`).first();
+            if (await permLabel.isVisible({ timeout: 1000 }).catch(() => false)) {
+                await permLabel.click();
+                await page.waitForTimeout(300);
+            }
+        }
+        // Copy the generated URL
+        await page.waitForTimeout(1000);
+        let inviteUrl = "";
+        const urlInput = page.locator('input[value*="discord.com/oauth2"], input[value*="discord.com/api/oauth2"]').first();
+        if (await urlInput.isVisible({ timeout: 3000 }).catch(() => false)) {
+            inviteUrl = await urlInput.inputValue();
+        }
+        if (inviteUrl) {
+            console.log(`  ${c.green}✓${c.reset} Invite URL generated\n`);
+            // ── Step 6: Open invite URL to add bot to server ──
+            console.log(`  ${c.bold}6.${c.reset} Opening bot invite page...`);
+            console.log(`  ${c.yellow}${c.bold}Pick your Discord server in the browser to add the bot.${c.reset}\n`);
+            await page.goto(inviteUrl);
+            // Wait for user to authorize (page changes after clicking Authorize)
+            await page.waitForURL("**/oauth2/authorized**", { timeout: 120_000 }).catch(() => { });
+            console.log(`  ${c.green}✓${c.reset} Bot added to server!\n`);
+        }
+        else {
+            console.log(`  ${c.yellow}⚠${c.reset} Could not auto-generate invite URL.`);
+            if (applicationId) {
+                inviteUrl = `https://discord.com/api/oauth2/authorize?client_id=${applicationId}&permissions=68608&scope=bot`;
+                console.log(`  ${c.dim}Manual invite URL: ${inviteUrl}${c.reset}\n`);
+            }
+        }
+        // Close browser
+        await browser.close();
+        return {
+            success: !!botToken,
+            botToken: botToken || undefined,
+            applicationId: applicationId || undefined,
+            inviteUrl: inviteUrl || undefined,
+            error: botToken ? undefined : "Could not auto-capture bot token. Please copy it manually from the Discord Developer Portal.",
+        };
+    }
+    catch (err) {
+        const msg = err.message ?? String(err);
+        console.log(`\n  ${c.red}✗ Automation error: ${msg.split("\n")[0]}${c.reset}`);
+        // Try to close browser gracefully
+        try {
+            await browser?.close();
+        }
+        catch { /* */ }
+        return { success: false, error: msg };
+    }
+}
+/**
+ * Full Discord setup flow — automate browser + register with OpenClaw.
+ */
+export async function setupDiscordChannel(appName = "OpenClaw") {
+    const result = await automateDiscordBotSetup(appName);
+    if (result.success && result.botToken) {
+        // Register with OpenClaw
+        console.log(`${c.bold}${c.cyan}── Registering with OpenClaw ──${c.reset}\n`);
+        try {
+            const { execSync } = await import("node:child_process");
+            const nvmPrefix = `for d in "$HOME/.nvm" "/home/"*"/.nvm" "/root/.nvm"; do [ -s "$d/nvm.sh" ] && export NVM_DIR="$d" && . "$d/nvm.sh" && break; done 2>/dev/null; nvm use 22 > /dev/null 2>&1;`;
+            // Try direct Node 22 path first
+            const node22Paths = ["/home/ino/.nvm/versions/node/v22.22.2/bin/node"];
+            let node22 = "node";
+            for (const p of node22Paths) {
+                try {
+                    execSync(`ls "${p}"`, { stdio: "pipe" });
+                    node22 = p;
+                    break;
+                }
+                catch { /* */ }
+            }
+            const ocBin = execSync("readlink -f $(which openclaw) 2>/dev/null || which openclaw", { encoding: "utf-8" }).trim();
+            execSync(`${node22} ${ocBin} channels add --channel discord --token "${result.botToken}"`, { stdio: "inherit", timeout: 15_000 });
+            console.log(`\n  ${c.green}✓${c.reset} Discord channel registered with OpenClaw!`);
+            // Restart gateway to pick up new channel
+            console.log(`  ${c.dim}Restarting gateway...${c.reset}`);
+            execSync("pkill -f openclaw-gateway 2>/dev/null", { stdio: "pipe" }).toString();
+            return [
+                `\n${c.green}${c.bold}✓ Discord bot setup complete!${c.reset}\n`,
+                `  ${c.bold}Bot:${c.reset} ${appName}`,
+                result.applicationId ? `  ${c.bold}App ID:${c.reset} ${result.applicationId}` : "",
+                `  ${c.bold}Channel:${c.reset} Discord — registered with OpenClaw`,
+                `\n  ${c.dim}Restart OpenClaw: "restart openclaw"${c.reset}`,
+                `  ${c.dim}Then chat with OpenClaw in your Discord server!${c.reset}`,
+            ].filter(Boolean).join("\n");
+        }
+        catch (err) {
+            return `${c.yellow}⚠${c.reset} Bot created but OpenClaw registration failed.\n  Token: ${result.botToken}\n  ${c.dim}Register manually: openclaw channels add --channel discord --token ${result.botToken}${c.reset}`;
+        }
+    }
+    if (result.error) {
+        return `${c.yellow}⚠${c.reset} ${result.error}\n\n  ${c.dim}If you have the token, say: "setup discord with token YOUR_TOKEN"${c.reset}`;
+    }
+    return `${c.red}✗ Discord setup failed.${c.reset}`;
+}

package/dist/conversation/coreference.js

@@ -13,7 +13,7 @@ import { getLastEntity, getRecentTurns } from "./store.js";
  */
 // Patterns that signal a reference to a previous turn
 const REPEAT_PATTERNS = [
-    /^(do it|do that|run it|run that|same thing|again|repeat|redo|re-?run)\b/i,
+    /^(do it|do that|run it|run that|same thing|again|repeat|redo|re-?run|try again|retry|one more time|run again|do it again|try that again|go again|try it now|try now|try it|let.?s try|give it another|another try)\b/i,
     /^same\b/i,
 ];
 const PRONOUN_PATTERNS = [
@@ -24,6 +24,18 @@ const PRONOUN_PATTERNS = [
     { pattern: /\bthat (file|path|directory)\b/i, refType: "path" },
     { pattern: /\bthere\b/i, refType: "environment" },
     { pattern: /\bthat (env|environment|box|machine)\b/i, refType: "environment" },
+    // "the other" — refers to the second-most-recent entity (not the one we just acted on)
+    { pattern: /\bthe other (one|service|server|thing)\b/i, refType: "service", offset: 1 },
+    { pattern: /\bthe other (env|environment|box|machine|server)\b/i, refType: "environment", offset: 1 },
+    { pattern: /\bthe other\b/i, refType: "any", offset: 1 },
+    { pattern: /\bnot that one\b/i, refType: "any", offset: 1 },
+    { pattern: /\bnot this one\b/i, refType: "any", offset: 1 },
+    { pattern: /\bno not this one\b/i, refType: "any", offset: 1 },
+    { pattern: /\bno not that one\b/i, refType: "any", offset: 1 },
+    { pattern: /\bnot that\b/i, refType: "any", offset: 1 },
+    { pattern: /\bthe previous one\b/i, refType: "any", offset: 1 },
+    { pattern: /\bthe one before\b/i, refType: "any", offset: 1 },
+    { pattern: /\bthe first one\b/i, refType: "any", offset: 1 },
 ];
 const OVERRIDE_PATTERNS = [
     { pattern: /\bbut (?:on|in) (\w+)\b/i, field: "environment" },
@@ -42,6 +54,27 @@ export function resolveCoreferences(rawText, conv) {
     let resolvedIntent;
     const recentTurns = getRecentTurns(conv, 5);
     const lastUserTurn = recentTurns[recentTurns.length - 1];
+    // 0. Check for "the other thing" / "try the other thing" — second-to-last command
+    const otherThingPattern = /^(?:try |do |run )?the other (?:thing|one|command)\b/i;
+    if (otherThingPattern.test(rawText.trim())) {
+        isReference = true;
+        const prevTurn = recentTurns[recentTurns.length - 2];
+        if (prevTurn?.intent && prevTurn.fields) {
+            resolvedIntent = {
+                intent: prevTurn.intent,
+                confidence: 0.8,
+                rawText,
+                fields: { ...prevTurn.fields },
+            };
+            resolvedText = prevTurn.rawText;
+            resolutions.push({
+                original: rawText,
+                resolved: prevTurn.rawText,
+                source: "last_turn",
+            });
+        }
+        return { resolvedText, isReference, resolvedIntent, resolutions };
+    }
     // 1. Check for full repeat patterns ("do it again", "same thing")
     for (const pattern of REPEAT_PATTERNS) {
         if (pattern.test(rawText.trim())) {
@@ -73,13 +106,20 @@ export function resolveCoreferences(rawText, conv) {
             return { resolvedText, isReference, resolvedIntent, resolutions };
         }
     }
-    // 2. Resolve pronouns ("restart it", "check that service")
-    for (const { pattern, refType } of PRONOUN_PATTERNS) {
+    // 2. Resolve pronouns ("restart it", "check that service", "the other one")
+    for (const { pattern, refType, offset } of PRONOUN_PATTERNS) {
         const match = rawText.match(pattern);
         if (!match)
             continue;
         let resolved;
-        if (refType === "any") {
+        if (offset && offset > 0) {
+            // "the other" — get the Nth entity (skip the most recent)
+            const candidates = refType === "any"
+                ? [...conv.knowledgeTree].sort((a, b) => b.lastMentioned - a.lastMentioned)
+                : conv.knowledgeTree.filter(n => n.type === refType).sort((a, b) => b.lastMentioned - a.lastMentioned);
+            resolved = candidates[offset]; // offset=1 means second-most-recent
+        }
+        else if (refType === "any") {
             // "it" → most recent service, then most recent entity
             resolved = getLastEntity(conv, "service")
                 ?? getLastEntity(conv, "path")

package/dist/conversation/pendingActions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pending Actions.
+ *
+ * Tracks suggestions NoToken makes so when the user says
+ * "ok", "try that", "do it", "run it", "yes" — it knows what to execute.
+ *
+ * Examples:
+ *   NoToken: "✓ Installed. Start: notoken start stable-diffusion"
+ *   User: "ok try it"
+ *   → executes "notoken start stable-diffusion"
+ *
+ *   NoToken: "Update available: 1.5.0 → 1.7.0"
+ *   User: "yes do it"
+ *   → executes update
+ */
+export interface PendingAction {
+    /** What to execute — either an intent name or a raw command */
+    action: string;
+    /** Human description */
+    description: string;
+    /** Type: intent to parse, or command to run directly */
+    type: "intent" | "command";
+    /** When it was suggested (auto-set by suggestAction) */
+    timestamp?: number;
+    /** The raw text/fields for the intent */
+    fields?: Record<string, unknown>;
+}
+/**
+ * Store an action that NoToken is suggesting to the user.
+ * Most recent is at the end.
+ */
+export declare function suggestAction(action: PendingAction): void;
+/**
+ * Get the most recent pending action (if any, and if not too old).
+ * Actions expire after 5 minutes.
+ */
+export declare function getLastPendingAction(): PendingAction | null;
+/**
+ * Pop (consume) the last pending action.
+ */
+export declare function consumePendingAction(): PendingAction | null;
+/**
+ * Check if user is giving a directive about the pending action.
+ * E.g. "put it on F drive", "install it on D:", "no use /mnt/f"
+ * Returns the resolved new text if yes, null otherwise.
+ */
+export declare function isRedirectingPendingAction(text: string): string | null;
+/**
+ * Check if user input is an affirmation to execute a pending action.
+ */
+export declare function isAffirmation(text: string): boolean;
+/**
+ * Clear all pending actions.
+ */
+export declare function clearPendingActions(): void;

package/dist/conversation/pendingActions.js

@@ -0,0 +1,127 @@
+/**
+ * Pending Actions.
+ *
+ * Tracks suggestions NoToken makes so when the user says
+ * "ok", "try that", "do it", "run it", "yes" — it knows what to execute.
+ *
+ * Examples:
+ *   NoToken: "✓ Installed. Start: notoken start stable-diffusion"
+ *   User: "ok try it"
+ *   → executes "notoken start stable-diffusion"
+ *
+ *   NoToken: "Update available: 1.5.0 → 1.7.0"
+ *   User: "yes do it"
+ *   → executes update
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+const PENDING_FILE = resolve(process.env.NOTOKEN_HOME ?? resolve(homedir(), ".notoken"), "pending-actions.json");
+// Persisted to disk so "try it" works across CLI invocations
+let pendingActions = loadFromDisk();
+function loadFromDisk() {
+    try {
+        if (existsSync(PENDING_FILE)) {
+            return JSON.parse(readFileSync(PENDING_FILE, "utf-8"));
+        }
+    }
+    catch { }
+    return [];
+}
+function saveToDisk() {
+    try {
+        const dir = resolve(PENDING_FILE, "..");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(PENDING_FILE, JSON.stringify(pendingActions));
+    }
+    catch { }
+}
+/**
+ * Store an action that NoToken is suggesting to the user.
+ * Most recent is at the end.
+ */
+export function suggestAction(action) {
+    pendingActions.push({ ...action, timestamp: Date.now() });
+    // Keep last 5
+    if (pendingActions.length > 5)
+        pendingActions = pendingActions.slice(-5);
+    saveToDisk();
+}
+/**
+ * Get the most recent pending action (if any, and if not too old).
+ * Actions expire after 5 minutes.
+ */
+export function getLastPendingAction() {
+    if (pendingActions.length === 0)
+        return null;
+    const last = pendingActions[pendingActions.length - 1];
+    // Expire after 5 minutes
+    if (Date.now() - (last.timestamp ?? 0) > 5 * 60 * 1000)
+        return null;
+    return last;
+}
+/**
+ * Pop (consume) the last pending action.
+ */
+export function consumePendingAction() {
+    const action = getLastPendingAction();
+    if (action) {
+        pendingActions.pop();
+        saveToDisk();
+    }
+    return action;
+}
+/**
+ * Check if user is giving a directive about the pending action.
+ * E.g. "put it on F drive", "install it on D:", "no use /mnt/f"
+ * Returns the resolved new text if yes, null otherwise.
+ */
+export function isRedirectingPendingAction(text) {
+    const pending = getLastPendingAction();
+    if (!pending)
+        return null;
+    const normalized = text.toLowerCase().trim();
+    // "put it on X", "install it on X", "no put it on X", "use X instead"
+    const redirectPatterns = [
+        /(?:put|install|place|move|set|store)\s+(?:it|that|this)\s+(?:on|in|at|to)\s+(.+)/i,
+        /(?:no|nah|nope)\s*,?\s*(?:put|install|place|use|try)\s+(?:it\s+)?(?:on|in|at)?\s*(.+)/i,
+        /(?:use|try)\s+(.+?)\s+instead/i,
+        /(?:on|in|at)\s+(.+?)\s+(?:drive|folder|directory|instead)/i,
+    ];
+    for (const pattern of redirectPatterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+            const location = match[1].trim();
+            // Re-form the pending action with the new location
+            if (pending.action.includes("install") || pending.action.includes("generate")) {
+                return `${pending.action} on ${location}`;
+            }
+            return `install stable diffusion on ${location}`;
+        }
+    }
+    return null;
+}
+/**
+ * Check if user input is an affirmation to execute a pending action.
+ */
+export function isAffirmation(text) {
+    const normalized = text.toLowerCase().trim();
+    const affirmations = [
+        "ok", "okay", "yes", "yeah", "yep", "sure", "go", "go ahead",
+        "do it", "run it", "try it", "try that", "run that", "do that",
+        "execute it", "execute that", "start it", "start that",
+        "ok do it", "ok run it", "ok try it", "yes do it", "yes run it",
+        "ok go", "go for it", "let's do it", "lets do it", "lets go",
+        "proceed", "continue", "confirm", "approve", "yea",
+        "ok try that", "ok run that", "ok do that",
+        "sure thing", "sounds good", "go on",
+    ];
+    return affirmations.includes(normalized);
+}
+/**
+ * Clear all pending actions.
+ */
+export function clearPendingActions() {
+    pendingActions = [];
+    saveToDisk();
+}