@mnemom/mnemom 0.7.0

package/dist/commands/status.js

@@ -0,0 +1,383 @@
+import { configExists, loadConfig, requireAgent } from "../lib/config.js";
+import { getAgent, getIntegrity, getTraces } from "../lib/api.js";
+import { detectOpenClaw, detectProviders, getCurrentModel, getSmoltbotConfiguredProviders, PROVIDER_CONFIG_KEYS, } from "../lib/openclaw.js";
+import { formatModelName, detectProvider } from "../lib/models.js";
+import { refreshModelCache } from "../lib/model-cache.js";
+import { fmt } from "../lib/format.js";
+const GATEWAY_URL = "https://gateway.mnemom.ai";
+const DASHBOARD_URL = "https://mnemom.ai";
+const PROVIDER_LABELS = {
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    gemini: "Gemini",
+};
+const AIP_SUPPORT = {
+    anthropic: "Full (thinking blocks)",
+    openai: "Via reasoning summaries",
+    gemini: "Full (thought parts)",
+};
+export async function statusCommand(agentName) {
+    console.log(fmt.header("smoltbot status"));
+    console.log();
+    const checks = [];
+    // 1. Check smoltbot config
+    const configCheck = checkSmoltbotConfig();
+    checks.push(configCheck);
+    if (configCheck.status === "error") {
+        printChecks(checks);
+        console.log("\nRun `smoltbot init` to get started.\n");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const agent = await requireAgent(agentName);
+    // 2. Check OpenClaw configuration
+    const openclawCheck = checkOpenClawConfig();
+    checks.push(openclawCheck);
+    // 3. Check configured providers
+    const providerChecks = checkConfiguredProviders();
+    checks.push(...providerChecks);
+    // 4. Check current model
+    const modelCheck = checkCurrentModel();
+    checks.push(modelCheck);
+    // 5. Test gateway connectivity
+    const gatewayCheck = await checkGatewayConnectivity();
+    checks.push(gatewayCheck);
+    // 6. Test API connectivity
+    const apiCheck = await checkApiConnectivity(agent.agentId);
+    checks.push(apiCheck);
+    // Print all checks
+    printChecks(checks);
+    // Show configuration details
+    console.log(fmt.section("Configuration"));
+    console.log();
+    console.log(fmt.label("Agent ID: ", agent.agentId));
+    console.log(fmt.label("Gateway:  ", config.gateway || GATEWAY_URL));
+    console.log(fmt.label("Dashboard:", ` ${DASHBOARD_URL}/agents/${agent.agentId}`));
+    if (config.mnemomApiKey) {
+        console.log(`Mnemom Key: [CONFIGURED] (billing enabled)`);
+    }
+    else {
+        console.log(`Mnemom Key: Not configured (free tier)`);
+    }
+    if (agent.openclawConfigured) {
+        console.log(`Configured: ${agent.configuredAt || "yes"}`);
+    }
+    // Show current model info
+    const { fullPath, provider, modelId } = getCurrentModel();
+    if (fullPath) {
+        console.log(`\nCurrent Model: ${fullPath}`);
+        if (modelId) {
+            console.log(`  (${formatModelName(modelId)})`);
+        }
+        if (provider && (provider === "smoltbot" || provider.startsWith("smoltbot"))) {
+            console.log("  Status: Traced mode ACTIVE");
+        }
+        else {
+            console.log("  Status: Traced mode NOT ACTIVE");
+            if (modelId) {
+                const detectedProvider = detectProvider(modelId);
+                const configKey = detectedProvider ? PROVIDER_CONFIG_KEYS[detectedProvider] : "smoltbot";
+                console.log(`\n  To enable: openclaw models set ${configKey}/${modelId}`);
+            }
+        }
+    }
+    // Show provider summary
+    showProviderSummary();
+    // Show trace summary if available
+    if (apiCheck.status === "ok") {
+        await showTraceSummary(agent.agentId);
+    }
+    // Show overall status
+    const hasErrors = checks.some((c) => c.status === "error");
+    const hasWarnings = checks.some((c) => c.status === "warning");
+    if (hasErrors) {
+        console.log("\n" + fmt.header("Status: ISSUES DETECTED"));
+        console.log("\n  Fix the errors above to ensure tracing works correctly.\n");
+    }
+    else if (hasWarnings) {
+        console.log("\n" + fmt.header("Status: OK (with warnings)"));
+        console.log();
+    }
+    else {
+        console.log("\n" + fmt.header("Status: ALL SYSTEMS GO"));
+        console.log();
+    }
+    // Refresh model cache in background (non-blocking)
+    refreshModelCache().catch(() => { });
+}
+function checkSmoltbotConfig() {
+    if (!configExists()) {
+        return {
+            name: "Smoltbot Config",
+            status: "error",
+            message: "Not initialized",
+            details: "Run `smoltbot init` to configure",
+        };
+    }
+    const config = loadConfig();
+    if (!config) {
+        return {
+            name: "Smoltbot Config",
+            status: "error",
+            message: "Config file corrupted",
+            details: "Delete ~/.smoltbot/config.json and run `smoltbot init`",
+        };
+    }
+    const defaultAgent = config.agents[config.defaultAgent];
+    return {
+        name: "Smoltbot Config",
+        status: "ok",
+        message: `Agent ID: ${defaultAgent?.agentId ?? "unknown"}`,
+    };
+}
+function checkOpenClawConfig() {
+    const detection = detectOpenClaw();
+    if (!detection.installed) {
+        return {
+            name: "OpenClaw",
+            status: "error",
+            message: "Not installed",
+            details: "Install from https://openclaw.ai",
+        };
+    }
+    if (!detection.hasApiKey) {
+        if (detection.isOAuth) {
+            return {
+                name: "OpenClaw",
+                status: "error",
+                message: "OAuth auth (not supported)",
+                details: "smoltbot requires API key authentication",
+            };
+        }
+        // Check if any provider has a key (not just Anthropic)
+        const providerDetection = detectProviders();
+        const anyKey = Object.values(providerDetection.providers).some((p) => p.hasApiKey);
+        if (anyKey) {
+            return {
+                name: "OpenClaw",
+                status: "ok",
+                message: "API key(s) found",
+            };
+        }
+        return {
+            name: "OpenClaw",
+            status: "error",
+            message: "No API keys configured",
+            details: "Run `openclaw auth` to add your API key",
+        };
+    }
+    if (!detection.smoltbotAlreadyConfigured) {
+        return {
+            name: "OpenClaw",
+            status: "warning",
+            message: "smoltbot provider not configured",
+            details: "Run `smoltbot init` to configure",
+        };
+    }
+    return {
+        name: "OpenClaw",
+        status: "ok",
+        message: "smoltbot provider configured",
+    };
+}
+function checkConfiguredProviders() {
+    const results = [];
+    const providerDetection = detectProviders();
+    if (!providerDetection.installed)
+        return results;
+    const configuredProviders = getSmoltbotConfiguredProviders();
+    for (const provider of ["anthropic", "openai", "gemini"]) {
+        const info = providerDetection.providers[provider];
+        const isConfigured = configuredProviders.includes(provider);
+        if (info.hasApiKey && isConfigured) {
+            results.push({
+                name: `${PROVIDER_LABELS[provider]}`,
+                status: "ok",
+                message: `Configured (AIP: ${AIP_SUPPORT[provider]})`,
+            });
+        }
+        else if (info.hasApiKey && !isConfigured) {
+            results.push({
+                name: `${PROVIDER_LABELS[provider]}`,
+                status: "warning",
+                message: "API key found but not configured",
+                details: "Run `smoltbot init` to configure",
+            });
+        }
+        // Don't show providers without keys (too noisy)
+    }
+    return results;
+}
+function checkCurrentModel() {
+    const { fullPath, provider, modelId } = getCurrentModel();
+    if (!fullPath) {
+        return {
+            name: "Current Model",
+            status: "warning",
+            message: "No default model set",
+            details: "Run `openclaw models set smoltbot/<model>`",
+        };
+    }
+    if (provider && (provider === "smoltbot" || provider.startsWith("smoltbot"))) {
+        return {
+            name: "Current Model",
+            status: "ok",
+            message: `${modelId} (traced)`,
+        };
+    }
+    return {
+        name: "Current Model",
+        status: "warning",
+        message: `${fullPath} (not traced)`,
+        details: `Switch with: openclaw models set smoltbot/${modelId}`,
+    };
+}
+function showProviderSummary() {
+    const providerDetection = detectProviders();
+    if (!providerDetection.installed)
+        return;
+    const configuredProviders = getSmoltbotConfiguredProviders();
+    if (configuredProviders.length === 0)
+        return;
+    console.log(fmt.section("Configured Providers"));
+    console.log();
+    for (const provider of configuredProviders) {
+        const label = PROVIDER_LABELS[provider];
+        const aip = AIP_SUPPORT[provider];
+        const configKey = PROVIDER_CONFIG_KEYS[provider];
+        console.log(`  ${label}: ${configKey}/* (AIP: ${aip})`);
+    }
+}
+async function checkGatewayConnectivity() {
+    try {
+        const response = await fetch(`${GATEWAY_URL}/health`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            return {
+                name: "Gateway",
+                status: "ok",
+                message: `Connected (v${data.version || "unknown"})`,
+            };
+        }
+        return {
+            name: "Gateway",
+            status: "error",
+            message: `HTTP ${response.status}`,
+            details: "Gateway returned an error",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("timeout") || message.includes("TIMEOUT")) {
+            return {
+                name: "Gateway",
+                status: "error",
+                message: "Connection timeout",
+                details: "Check your network connection",
+            };
+        }
+        return {
+            name: "Gateway",
+            status: "error",
+            message: "Connection failed",
+            details: message,
+        };
+    }
+}
+async function checkApiConnectivity(agentId) {
+    try {
+        const agent = await getAgent(agentId);
+        if (agent) {
+            return {
+                name: "API",
+                status: "ok",
+                message: "Agent registered",
+            };
+        }
+        return {
+            name: "API",
+            status: "warning",
+            message: "Agent not yet registered",
+            details: "Will register on first traced API call",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("404") || message.includes("not found")) {
+            return {
+                name: "API",
+                status: "warning",
+                message: "Agent not yet registered",
+                details: "Will register on first traced API call",
+            };
+        }
+        if (message.includes("timeout") || message.includes("TIMEOUT")) {
+            return {
+                name: "API",
+                status: "error",
+                message: "Connection timeout",
+                details: "Check your network connection",
+            };
+        }
+        return {
+            name: "API",
+            status: "error",
+            message: "Connection failed",
+            details: message,
+        };
+    }
+}
+async function showTraceSummary(agentId) {
+    try {
+        const [integrityResult, tracesResult] = await Promise.allSettled([
+            getIntegrity(agentId),
+            getTraces(agentId, 1),
+        ]);
+        console.log(fmt.section("Trace Summary"));
+        console.log();
+        if (integrityResult.status === "fulfilled") {
+            const integrity = integrityResult.value;
+            const score = (integrity.score * 100).toFixed(1);
+            console.log(`Integrity Score: ${score}%`);
+            console.log(`Total Traces:    ${integrity.total_traces}`);
+            console.log(`Verified:        ${integrity.verified}`);
+            if (integrity.violations > 0) {
+                console.log(`Violations:      ${integrity.violations}`);
+            }
+        }
+        else {
+            console.log("Integrity: No data yet");
+        }
+        if (tracesResult.status === "fulfilled" && tracesResult.value.length > 0) {
+            const lastTrace = tracesResult.value[0];
+            const lastTime = new Date(lastTrace.timestamp).toLocaleString();
+            console.log(`\nLast Activity:   ${lastTime}`);
+        }
+        else {
+            console.log("\nLast Activity:   None");
+        }
+    }
+    catch {
+        // Silently skip if we can't get trace info
+    }
+}
+function printChecks(checks) {
+    console.log(fmt.section("System Checks"));
+    console.log();
+    for (const check of checks) {
+        if (check.status === "ok") {
+            console.log(fmt.success(`${check.name}: ${check.message}`));
+        }
+        else if (check.status === "warning") {
+            console.log(fmt.warn(`${check.name}: ${check.message}`));
+        }
+        else {
+            console.log(fmt.error(`${check.name}: ${check.message}`));
+        }
+        if (check.details) {
+            console.log(`    ${check.details}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};