notoken-core 1.6.0 → 2.0.0

package/dist/utils/installTracker.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Install Tracker.
+ *
+ * Tracks what NoToken has installed so it can cleanly uninstall later.
+ * Persisted to ~/.notoken/install-history.json
+ *
+ * Records:
+ *   - What was installed (tool name, engine, package)
+ *   - Where it was installed (path, drive)
+ *   - When it was installed
+ *   - How it was installed (npm, git clone, docker pull, apt, brew, winget)
+ *   - Dependencies that were also installed
+ */
+export interface InstalledItem {
+    name: string;
+    type: "tool" | "engine" | "model" | "docker-image" | "system-package" | "build-tools";
+    method: "npm" | "git-clone" | "docker-pull" | "apt" | "dnf" | "brew" | "winget" | "curl" | "pip";
+    path?: string;
+    size?: string;
+    version?: string;
+    installedAt: string;
+    dependencies?: string[];
+    uninstallCmd?: string;
+    notes?: string;
+}
+export interface InstallHistory {
+    items: InstalledItem[];
+    lastUpdated: string;
+}
+/**
+ * Record that something was installed.
+ */
+export declare function trackInstall(item: Omit<InstalledItem, "installedAt">): void;
+/**
+ * Get all installed items.
+ */
+export declare function getInstallHistory(): InstalledItem[];
+/**
+ * Get installed items by type.
+ */
+export declare function getInstalledByType(type: InstalledItem["type"]): InstalledItem[];
+/**
+ * Get a specific installed item.
+ */
+export declare function getInstalledItem(name: string): InstalledItem | undefined;
+/**
+ * Remove an item from tracking (after uninstall).
+ */
+export declare function untrackInstall(name: string): void;
+/**
+ * Format install history for display.
+ */
+export declare function formatInstallHistory(): string;
+/**
+ * Generate uninstall commands for an item.
+ */
+export declare function getUninstallSteps(name: string): string[];

package/dist/utils/installTracker.js

@@ -0,0 +1,160 @@
+/**
+ * Install Tracker.
+ *
+ * Tracks what NoToken has installed so it can cleanly uninstall later.
+ * Persisted to ~/.notoken/install-history.json
+ *
+ * Records:
+ *   - What was installed (tool name, engine, package)
+ *   - Where it was installed (path, drive)
+ *   - When it was installed
+ *   - How it was installed (npm, git clone, docker pull, apt, brew, winget)
+ *   - Dependencies that were also installed
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { USER_HOME } from "./paths.js";
+const HISTORY_FILE = resolve(USER_HOME, "install-history.json");
+function loadHistory() {
+    try {
+        if (existsSync(HISTORY_FILE)) {
+            return JSON.parse(readFileSync(HISTORY_FILE, "utf-8"));
+        }
+    }
+    catch { }
+    return { items: [], lastUpdated: new Date().toISOString() };
+}
+function saveHistory(history) {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        history.lastUpdated = new Date().toISOString();
+        writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+    }
+    catch { }
+}
+/**
+ * Record that something was installed.
+ */
+export function trackInstall(item) {
+    const history = loadHistory();
+    // Don't duplicate — update if same name+type exists
+    const existing = history.items.findIndex(i => i.name === item.name && i.type === item.type);
+    const entry = { ...item, installedAt: new Date().toISOString() };
+    if (existing >= 0) {
+        history.items[existing] = entry;
+    }
+    else {
+        history.items.push(entry);
+    }
+    saveHistory(history);
+}
+/**
+ * Get all installed items.
+ */
+export function getInstallHistory() {
+    return loadHistory().items;
+}
+/**
+ * Get installed items by type.
+ */
+export function getInstalledByType(type) {
+    return loadHistory().items.filter(i => i.type === type);
+}
+/**
+ * Get a specific installed item.
+ */
+export function getInstalledItem(name) {
+    return loadHistory().items.find(i => i.name === name);
+}
+/**
+ * Remove an item from tracking (after uninstall).
+ */
+export function untrackInstall(name) {
+    const history = loadHistory();
+    history.items = history.items.filter(i => i.name !== name);
+    saveHistory(history);
+}
+/**
+ * Format install history for display.
+ */
+export function formatInstallHistory() {
+    const c = {
+        reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+        green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+    };
+    const items = getInstallHistory();
+    if (items.length === 0)
+        return `${c.dim}No installations tracked by NoToken.${c.reset}`;
+    const lines = [];
+    lines.push(`${c.bold}NoToken Install History${c.reset} (${items.length} items)\n`);
+    // Group by type
+    const grouped = new Map();
+    for (const item of items) {
+        const list = grouped.get(item.type) ?? [];
+        list.push(item);
+        grouped.set(item.type, list);
+    }
+    for (const [type, typeItems] of grouped) {
+        lines.push(`${c.bold}${type}:${c.reset}`);
+        for (const item of typeItems) {
+            const ver = item.version ? ` v${item.version}` : "";
+            const size = item.size ? ` (${item.size})` : "";
+            const path = item.path ? `\n    ${c.dim}${item.path}${c.reset}` : "";
+            const method = `${c.dim}via ${item.method}${c.reset}`;
+            const date = new Date(item.installedAt).toLocaleDateString();
+            lines.push(`  ${c.green}✓${c.reset} ${c.bold}${item.name}${c.reset}${ver}${size} — ${method} ${c.dim}${date}${c.reset}${path}`);
+            if (item.uninstallCmd) {
+                lines.push(`    ${c.dim}Uninstall: ${item.uninstallCmd}${c.reset}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate uninstall commands for an item.
+ */
+export function getUninstallSteps(name) {
+    const item = getInstalledItem(name);
+    if (!item)
+        return [];
+    const steps = [];
+    switch (item.method) {
+        case "npm":
+            steps.push(`npm uninstall -g ${name}`);
+            break;
+        case "git-clone":
+            if (item.path)
+                steps.push(`rm -rf "${item.path}"`);
+            break;
+        case "docker-pull":
+            steps.push(`docker rmi ${name}`);
+            steps.push(`docker rm -f sd-webui 2>/dev/null`);
+            break;
+        case "apt":
+            steps.push(`sudo apt-get remove -y ${name}`);
+            break;
+        case "dnf":
+            steps.push(`sudo dnf remove -y ${name}`);
+            break;
+        case "brew":
+            steps.push(`brew uninstall ${name}`);
+            break;
+        case "winget":
+            steps.push(`winget uninstall ${name}`);
+            break;
+        case "pip":
+            if (item.path)
+                steps.push(`rm -rf "${item.path}"`);
+            break;
+        case "curl":
+            if (item.path)
+                steps.push(`rm -f "${item.path}"`);
+            break;
+    }
+    // Clean up dependencies
+    if (item.dependencies?.length) {
+        steps.push(`# Dependencies installed: ${item.dependencies.join(", ")}`);
+    }
+    return steps;
+}

package/dist/utils/multiExec.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Multi-environment execution.
+ *
+ * Detects phrases like "on all servers", "everywhere", "on prod and staging"
+ * and executes the resolved command on each target environment sequentially.
+ */
+import type { DynamicIntent } from "../types/intent.js";
+/**
+ * Detect whether the user's raw text targets multiple environments.
+ *
+ * Returns an array of environment names, or `null` if the text does not
+ * indicate multi-environment execution.
+ */
+export declare function detectMultiTarget(rawText: string): string[] | null;
+/**
+ * Execute an intent's command on each of the given environments sequentially,
+ * printing progress along the way.
+ *
+ * Returns a formatted summary string.
+ */
+export declare function executeMulti(intent: DynamicIntent, environments: string[]): Promise<string>;

package/dist/utils/multiExec.js

@@ -0,0 +1,141 @@
+/**
+ * Multi-environment execution.
+ *
+ * Detects phrases like "on all servers", "everywhere", "on prod and staging"
+ * and executes the resolved command on each target environment sequentially.
+ */
+import { loadHosts, getIntentDef } from "./config.js";
+import { runRemoteCommand } from "../execution/ssh.js";
+// ─── Detection ──────────────────────────────────────────────────────────────
+/** Phrases that mean "all configured environments". */
+const ALL_PATTERNS = [
+    /\bon all servers\b/i,
+    /\bon all environments\b/i,
+    /\ball servers\b/i,
+    /\ball environments\b/i,
+    /\beverywhere\b/i,
+    /\bon all\b/i,
+];
+/**
+ * "on X and Y" / "on X, Y, and Z" — extract specific environment names.
+ * Must come after a preposition like "on" or "across".
+ */
+const SPECIFIC_PATTERN = /\b(?:on|across|for)\s+([\w]+(?:\s*(?:,\s*|\band\b\s*)[\w]+)+)/i;
+/**
+ * Detect whether the user's raw text targets multiple environments.
+ *
+ * Returns an array of environment names, or `null` if the text does not
+ * indicate multi-environment execution.
+ */
+export function detectMultiTarget(rawText) {
+    const hosts = loadHosts();
+    const knownEnvs = Object.keys(hosts);
+    // 1. Check for "all" patterns
+    for (const pattern of ALL_PATTERNS) {
+        if (pattern.test(rawText)) {
+            return knownEnvs.length > 0 ? knownEnvs : null;
+        }
+    }
+    // 2. Check for "on X and Y" with specific names
+    const match = SPECIFIC_PATTERN.exec(rawText);
+    if (match) {
+        const envList = match[1]
+            .split(/\s*(?:,\s*|\band\b\s*)+/)
+            .map((e) => e.trim().toLowerCase())
+            .filter(Boolean);
+        // Only count environments that are actually configured
+        const valid = envList.filter((e) => knownEnvs.includes(e));
+        if (valid.length > 1) {
+            return valid;
+        }
+    }
+    return null;
+}
+/**
+ * Execute an intent's command on each of the given environments sequentially,
+ * printing progress along the way.
+ *
+ * Returns a formatted summary string.
+ */
+export async function executeMulti(intent, environments) {
+    const def = getIntentDef(intent.intent);
+    if (!def) {
+        throw new Error(`No intent definition found for: ${intent.intent}`);
+    }
+    const cc = {
+        reset: "\x1b[0m",
+        bold: "\x1b[1m",
+        dim: "\x1b[2m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        red: "\x1b[31m",
+        cyan: "\x1b[36m",
+    };
+    const command = interpolateFields(def.command, intent.fields);
+    console.log(`\n${cc.bold}${cc.cyan}── Multi-environment: ${environments.join(", ")} ──${cc.reset}`);
+    console.log(`${cc.dim}Command: ${command}${cc.reset}\n`);
+    const results = [];
+    for (let i = 0; i < environments.length; i++) {
+        const env = environments[i];
+        const label = `[${i + 1}/${environments.length}] ${env}`;
+        process.stderr.write(`  ${cc.cyan}${label}${cc.reset} ... `);
+        const start = Date.now();
+        let output;
+        let success;
+        try {
+            output = await runRemoteCommand(env, command);
+            success = true;
+            process.stderr.write(`${cc.green}OK${cc.reset} (${Date.now() - start}ms)\n`);
+        }
+        catch (err) {
+            output = err instanceof Error ? err.message : String(err);
+            success = false;
+            process.stderr.write(`${cc.red}FAIL${cc.reset} (${Date.now() - start}ms)\n`);
+        }
+        results.push({
+            environment: env,
+            success,
+            output: output.trim(),
+            durationMs: Date.now() - start,
+        });
+    }
+    // ── Summary ──
+    return formatSummary(results, cc);
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function interpolateFields(template, fields) {
+    let cmd = template;
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined && value !== null) {
+            cmd = cmd.replaceAll(`{{${key}}}`, String(value));
+        }
+    }
+    // Remove any remaining placeholders
+    cmd = cmd.replace(/\{\{[a-zA-Z_]+\}\}/g, "");
+    return cmd.trim();
+}
+function formatSummary(results, cc) {
+    const lines = [];
+    const passed = results.filter((r) => r.success).length;
+    const failed = results.length - passed;
+    lines.push(`\n${cc.bold}── Summary ──${cc.reset}  ${cc.green}${passed} passed${cc.reset}` +
+        (failed > 0 ? `  ${cc.red}${failed} failed${cc.reset}` : ""));
+    lines.push("");
+    for (const r of results) {
+        const icon = r.success
+            ? `${cc.green}✓${cc.reset}`
+            : `${cc.red}✗${cc.reset}`;
+        const dur = `${cc.dim}(${r.durationMs}ms)${cc.reset}`;
+        lines.push(`  ${icon} ${cc.bold}${r.environment}${cc.reset} ${dur}`);
+        // Show first few lines of output (truncated)
+        const outputLines = r.output.split("\n").filter(Boolean);
+        const preview = outputLines.slice(0, 3);
+        for (const line of preview) {
+            lines.push(`    ${cc.dim}${line}${cc.reset}`);
+        }
+        if (outputLines.length > 3) {
+            lines.push(`    ${cc.dim}... (${outputLines.length - 3} more lines)${cc.reset}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/utils/openclawDiag.d.ts

@@ -0,0 +1,29 @@
+/**
+ * OpenClaw advanced diagnostics.
+ *
+ * Runs a multi-step check:
+ *   1. Is the gateway process running?
+ *   2. Is the HTTP health endpoint responding?
+ *   3. Can we reach the WebSocket gateway?
+ *   4. What channels are configured (Telegram, Discord, Matrix)?
+ *   5. Are channels connected and healthy?
+ *   6. What's the config state?
+ *   7. Any errors in recent logs?
+ */
+/**
+ * Quick connectivity check — escalates from simplest to most thorough.
+ * Used for "can you talk to openclaw?" / "is openclaw reachable?"
+ *
+ * Steps:
+ *   1. Is the process alive? (ps aux — instant)
+ *   2. Does the health endpoint respond? (curl — fast)
+ *   3. Can the CLI communicate? (openclaw health — slower)
+ *
+ * Stops at the first failure and reports what's wrong.
+ */
+export declare function quickConnectivityCheck(runRemote?: (cmd: string) => Promise<string>): Promise<string>;
+export declare function diagnoseOpenclaw(isRemote: boolean, runRemote?: (cmd: string) => Promise<string>): Promise<string>;
+/**
+ * Apply auto-fixes from the last diagnosis.
+ */
+export declare function autoFixOpenclaw(runRemote?: (cmd: string) => Promise<string>): Promise<string>;