notoken-core 1.6.0 → 1.8.1

package/dist/utils/openclawLogParser.d.ts

@@ -0,0 +1,65 @@
+/**
+ * OpenClaw Log Parser — understand what's happening from openclaw logs.
+ *
+ * Parses JSON log lines from `openclaw logs --json` and extracts
+ * meaningful events for diagnostics, monitoring, and troubleshooting.
+ */
+export interface LogEntry {
+    type: "log" | "meta";
+    time: string;
+    level: "info" | "warn" | "error" | "debug";
+    subsystem?: string;
+    message: string;
+}
+export interface LogAnalysis {
+    /** Total log entries analyzed */
+    totalEntries: number;
+    /** Time range of logs */
+    timeRange: {
+        start: string;
+        end: string;
+    } | null;
+    /** Key events extracted */
+    events: Array<{
+        time: string;
+        type: string;
+        message: string;
+        severity: "info" | "warn" | "error";
+    }>;
+    /** Discord connection status */
+    discord: {
+        connected: boolean;
+        botName: string | null;
+        lastEvent: string | null;
+        rateLimited: boolean;
+        error4014: boolean;
+    };
+    /** Gateway health */
+    gateway: {
+        started: boolean;
+        listening: boolean;
+        port: number | null;
+        model: string | null;
+    };
+    /** Auth issues */
+    auth: {
+        errors: string[];
+        refreshFailed: boolean;
+        tokenExpired: boolean;
+    };
+    /** Errors and warnings */
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Parse a single JSON log line.
+ */
+export declare function parseLogLine(line: string): LogEntry | null;
+/**
+ * Analyze a batch of log lines and extract meaningful events.
+ */
+export declare function analyzeLogs(logText: string): LogAnalysis;
+/**
+ * Format log analysis for display.
+ */
+export declare function formatLogAnalysis(analysis: LogAnalysis): string;

package/dist/utils/openclawLogParser.js

@@ -0,0 +1,168 @@
+/**
+ * OpenClaw Log Parser — understand what's happening from openclaw logs.
+ *
+ * Parses JSON log lines from `openclaw logs --json` and extracts
+ * meaningful events for diagnostics, monitoring, and troubleshooting.
+ */
+/**
+ * Parse a single JSON log line.
+ */
+export function parseLogLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === "meta")
+            return { type: "meta", time: "", level: "info", message: `Log file: ${parsed.file}` };
+        return {
+            type: "log",
+            time: parsed.time ?? "",
+            level: (parsed.level ?? "info"),
+            subsystem: parsed.subsystem,
+            message: parsed.message ?? "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Analyze a batch of log lines and extract meaningful events.
+ */
+export function analyzeLogs(logText) {
+    const lines = logText.split("\n").filter(l => l.trim());
+    const entries = lines.map(parseLogLine).filter((e) => e !== null && e.type === "log");
+    const result = {
+        totalEntries: entries.length,
+        timeRange: null,
+        events: [],
+        discord: { connected: false, botName: null, lastEvent: null, rateLimited: false, error4014: false },
+        gateway: { started: false, listening: false, port: null, model: null },
+        auth: { errors: [], refreshFailed: false, tokenExpired: false },
+        errors: [],
+        warnings: [],
+    };
+    if (entries.length > 0) {
+        result.timeRange = { start: entries[0].time, end: entries[entries.length - 1].time };
+    }
+    for (const entry of entries) {
+        const msg = entry.message;
+        // Gateway events
+        if (msg.includes("listening on")) {
+            result.gateway.started = true;
+            result.gateway.listening = true;
+            const portMatch = msg.match(/:(\d+)/);
+            if (portMatch)
+                result.gateway.port = parseInt(portMatch[1]);
+            result.events.push({ time: entry.time, type: "gateway.start", message: "Gateway started", severity: "info" });
+        }
+        if (msg.includes("agent model:")) {
+            const modelMatch = msg.match(/agent model:\s*(\S+)/);
+            if (modelMatch)
+                result.gateway.model = modelMatch[1];
+        }
+        // Discord events
+        if (msg.includes("logged in to discord") || msg.includes("discord client ready")) {
+            result.discord.connected = true;
+            result.discord.lastEvent = "connected";
+            result.events.push({ time: entry.time, type: "discord.connected", message: "Discord bot connected", severity: "info" });
+        }
+        if (msg.includes("awaiting gateway readiness")) {
+            result.discord.lastEvent = "awaiting";
+            const botMatch = msg.match(/\((\S+)\)/);
+            if (botMatch)
+                result.discord.botName = botMatch[1];
+        }
+        if (msg.includes("starting provider")) {
+            const botMatch = msg.match(/@(\S+)\)/);
+            if (botMatch)
+                result.discord.botName = botMatch[1];
+        }
+        if (msg.includes("rate limit") || msg.includes("status=429")) {
+            result.discord.rateLimited = true;
+            result.discord.lastEvent = "rate_limited";
+            result.events.push({ time: entry.time, type: "discord.rate_limited", message: "Discord rate limited", severity: "warn" });
+        }
+        if (msg.includes("4014")) {
+            result.discord.error4014 = true;
+            result.events.push({ time: entry.time, type: "discord.error_4014", message: "Discord privileged intents error", severity: "error" });
+        }
+        // Auth events
+        if (msg.includes("Token refresh failed") || msg.includes("refresh_token_reused")) {
+            result.auth.refreshFailed = true;
+            result.auth.errors.push(msg.substring(0, 100));
+            result.events.push({ time: entry.time, type: "auth.refresh_failed", message: "Token refresh failed", severity: "error" });
+        }
+        if (msg.includes("unauthorized") || msg.includes("token missing") || msg.includes("token expired")) {
+            result.auth.tokenExpired = true;
+            result.auth.errors.push(msg.substring(0, 100));
+        }
+        // Model events
+        if (msg.includes("warmup failed")) {
+            result.events.push({ time: entry.time, type: "model.warmup_failed", message: msg.substring(0, 100), severity: "error" });
+        }
+        if (msg.includes("model fallback")) {
+            result.events.push({ time: entry.time, type: "model.fallback", message: msg.substring(0, 100), severity: "warn" });
+        }
+        // Agent events
+        if (msg.includes("lane task error")) {
+            result.events.push({ time: entry.time, type: "agent.error", message: msg.substring(0, 100), severity: "error" });
+        }
+        if (msg.includes("⇄ res ✓")) {
+            // Successful request
+            const durMatch = msg.match(/(\d+ms)/);
+            result.events.push({ time: entry.time, type: "request.success", message: `Request OK${durMatch ? ` (${durMatch[1]})` : ""}`, severity: "info" });
+        }
+        if (msg.includes("⇄ res ✗")) {
+            result.events.push({ time: entry.time, type: "request.error", message: msg.substring(0, 100), severity: "error" });
+        }
+        // Collect errors and warnings
+        if (entry.level === "error")
+            result.errors.push(msg.substring(0, 120));
+        if (entry.level === "warn")
+            result.warnings.push(msg.substring(0, 120));
+    }
+    return result;
+}
+/**
+ * Format log analysis for display.
+ */
+export function formatLogAnalysis(analysis) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m" };
+    const lines = [];
+    lines.push(`\n${c.bold}${c.cyan}── OpenClaw Log Analysis ──${c.reset}\n`);
+    lines.push(`  ${c.dim}${analysis.totalEntries} log entries${analysis.timeRange ? ` (${analysis.timeRange.start} → ${analysis.timeRange.end})` : ""}${c.reset}`);
+    // Gateway
+    lines.push(`\n  ${c.bold}Gateway:${c.reset} ${analysis.gateway.listening ? `${c.green}✓ running${c.reset}` : `${c.red}✗ not running${c.reset}`}${analysis.gateway.model ? ` | model: ${analysis.gateway.model}` : ""}`);
+    // Discord
+    if (analysis.discord.botName) {
+        const discordStatus = analysis.discord.connected ? `${c.green}✓ connected` :
+            analysis.discord.rateLimited ? `${c.yellow}⏳ rate limited` :
+                analysis.discord.error4014 ? `${c.red}✗ intents error (4014)` :
+                    `${c.yellow}⏳ ${analysis.discord.lastEvent ?? "connecting"}`;
+        lines.push(`  ${c.bold}Discord:${c.reset} ${discordStatus}${c.reset} (@${analysis.discord.botName})`);
+    }
+    // Auth
+    if (analysis.auth.errors.length > 0) {
+        lines.push(`\n  ${c.bold}Auth Issues:${c.reset}`);
+        for (const err of analysis.auth.errors.slice(0, 3)) {
+            lines.push(`    ${c.red}✗${c.reset} ${err}`);
+        }
+    }
+    // Key events
+    const keyEvents = analysis.events.filter(e => e.severity !== "info").slice(-10);
+    if (keyEvents.length > 0) {
+        lines.push(`\n  ${c.bold}Recent Issues:${c.reset}`);
+        for (const event of keyEvents) {
+            const icon = event.severity === "error" ? `${c.red}✗` : `${c.yellow}⚠`;
+            const time = event.time.split("T")[1]?.split(".")[0] ?? "";
+            lines.push(`    ${icon}${c.reset} ${c.dim}${time}${c.reset} ${event.message}`);
+        }
+    }
+    // Summary
+    if (analysis.errors.length === 0 && analysis.warnings.length === 0) {
+        lines.push(`\n  ${c.green}✓ No errors or warnings in recent logs.${c.reset}`);
+    }
+    else {
+        lines.push(`\n  ${c.dim}${analysis.errors.length} error(s), ${analysis.warnings.length} warning(s)${c.reset}`);
+    }
+    return lines.join("\n");
+}

package/dist/utils/output.js

@@ -3,6 +3,10 @@ export function formatParsedCommand(cmd) {
     const { intent } = cmd;
     lines.push(`Intent:      ${intent.intent}`);
     lines.push(`Confidence:  ${(intent.confidence * 100).toFixed(0)}%`);
+    // Show Computer: Local/Remote so user knows where the command runs
+    const env = intent.fields.environment ?? "local";
+    const isLocal = env === "local" || env === "localhost" || env === "dev";
+    lines.push(`Computer:    ${isLocal ? "\x1b[32mLocal\x1b[0m" : `\x1b[36mRemote (${env})\x1b[0m`}`);
     const entries = Object.entries(intent.fields).filter(([, v]) => v !== undefined);
     if (entries.length > 0) {
         lines.push("Fields:");

package/dist/utils/platform.js

@@ -245,7 +245,8 @@ function tryExec(cmd) {
     }
 }
 function commandExists(cmd) {
-    return tryExec(`command -v ${cmd}`) !== null;
+    const checkCmd = process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`;
+    return tryExec(checkCmd) !== null;
 }
 function extractField(content, key) {
     const match = content.match(new RegExp(`^${key}="?([^"\\n]*)"?`, "m"));

package/dist/utils/progressReporter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Progress Reporter — emit live progress events from executors.
+ *
+ * Allows handlers to report step-by-step progress that gets
+ * displayed in real-time to the user, even during background execution.
+ *
+ * Usage in a handler:
+ *   reportProgress("Step 1/3: Checking ports...");
+ *   reportProgress("Step 2/3: Scanning connections...");
+ *   reportProgress("Step 3/3: Generating report...", 100);
+ */
+import { EventEmitter } from "node:events";
+export interface ProgressEvent {
+    taskId: number;
+    intent: string;
+    message: string;
+    percent?: number;
+    step?: number;
+    totalSteps?: number;
+    timestamp: number;
+}
+declare class ProgressReporterClass extends EventEmitter {
+    private currentTaskId;
+    private currentIntent;
+    /** Set the current task context for progress reports. */
+    setContext(taskId: number, intent: string): void;
+    /** Report progress from inside a handler. */
+    report(message: string, opts?: {
+        percent?: number;
+        step?: number;
+        totalSteps?: number;
+    }): void;
+    /** Convenience: report a numbered step. */
+    step(current: number, total: number, message: string): void;
+    /** Report completion. */
+    done(message?: string): void;
+}
+/** Singleton progress reporter. */
+export declare const progressReporter: ProgressReporterClass;
+/**
+ * Convenience function for handlers to report progress.
+ * Import this in executor.ts handlers.
+ */
+export declare function reportProgress(message: string, opts?: {
+    percent?: number;
+    step?: number;
+    totalSteps?: number;
+}): void;
+export declare function reportStep(current: number, total: number, message: string): void;
+export {};

package/dist/utils/progressReporter.js

@@ -0,0 +1,58 @@
+/**
+ * Progress Reporter — emit live progress events from executors.
+ *
+ * Allows handlers to report step-by-step progress that gets
+ * displayed in real-time to the user, even during background execution.
+ *
+ * Usage in a handler:
+ *   reportProgress("Step 1/3: Checking ports...");
+ *   reportProgress("Step 2/3: Scanning connections...");
+ *   reportProgress("Step 3/3: Generating report...", 100);
+ */
+import { EventEmitter } from "node:events";
+class ProgressReporterClass extends EventEmitter {
+    currentTaskId = 0;
+    currentIntent = "";
+    /** Set the current task context for progress reports. */
+    setContext(taskId, intent) {
+        this.currentTaskId = taskId;
+        this.currentIntent = intent;
+    }
+    /** Report progress from inside a handler. */
+    report(message, opts) {
+        const event = {
+            taskId: this.currentTaskId,
+            intent: this.currentIntent,
+            message,
+            percent: opts?.percent,
+            step: opts?.step,
+            totalSteps: opts?.totalSteps,
+            timestamp: Date.now(),
+        };
+        this.emit("progress", event);
+    }
+    /** Convenience: report a numbered step. */
+    step(current, total, message) {
+        this.report(`Step ${current}/${total}: ${message}`, {
+            step: current,
+            totalSteps: total,
+            percent: Math.round((current / total) * 100),
+        });
+    }
+    /** Report completion. */
+    done(message) {
+        this.report(message ?? "Done", { percent: 100 });
+    }
+}
+/** Singleton progress reporter. */
+export const progressReporter = new ProgressReporterClass();
+/**
+ * Convenience function for handlers to report progress.
+ * Import this in executor.ts handlers.
+ */
+export function reportProgress(message, opts) {
+    progressReporter.report(message, opts);
+}
+export function reportStep(current, total, message) {
+    progressReporter.step(current, total, message);
+}

package/dist/utils/projectDetect.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Smart project detection and package manager resolution.
+ *
+ * Detects the project type in a directory and returns the correct
+ * install/update/build commands for that project's ecosystem.
+ */
+export interface DetectedProject {
+    type: string;
+    packageManager: string;
+    installCmd: string;
+    updateCmd: string;
+    buildCmd?: string;
+    lockFile?: string;
+    configFile: string;
+}
+/**
+ * Detect all projects in a directory.
+ * Returns them in priority order (most specific first).
+ */
+export declare function detectProjects(dir?: string): DetectedProject[];
+/** Format project detection results for display. */
+export declare function formatProjectDetection(projects: DetectedProject[]): string;
+/** Get the install command for the primary project in cwd. */
+export declare function getProjectInstallCmd(dir?: string): string | null;
+/** Get the update command for the primary project in cwd. */
+export declare function getProjectUpdateCmd(dir?: string): string | null;
+export interface ProjectScripts {
+    packageManager: string;
+    scripts: Record<string, string>;
+    dependencies: string[];
+    devDependencies: string[];
+    name: string;
+    version: string;
+}
+/** Read package.json or composer.json and extract scripts, deps, and metadata. */
+export declare function readProjectConfig(dir?: string): ProjectScripts | null;
+/** Format package.json scripts for display. */
+export declare function formatPackageScripts(info: ProjectScripts): string;
+/** Get the run command for a named script. */
+export declare function getScriptRunCmd(scriptName: string, dir?: string): string | null;
+/**
+ * Get the system-level update command based on the detected platform.
+ */
+export declare function getSystemUpdateCmd(): string;