@mnemom/smoltbot 2.0.1

package/dist/commands/logs.js

@@ -0,0 +1,86 @@
+import { configExists, loadConfig } from "../lib/config.js";
+import { getTraces } from "../lib/api.js";
+export async function logsCommand(options = {}) {
+    if (!configExists()) {
+        console.log("\n✗ smoltbot is not initialized\n");
+        console.log("Run `smoltbot init` to get started.\n");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config) {
+        console.log("\n✗ Failed to load configuration\n");
+        process.exit(1);
+    }
+    const limit = options.limit || 10;
+    console.log("\n🔍 Fetching traces...\n");
+    try {
+        const traces = await getTraces(config.agentId, limit);
+        if (traces.length === 0) {
+            console.log("━".repeat(60));
+            console.log("No traces found");
+            console.log("━".repeat(60));
+            console.log("\n💡 Start using Claude to generate traces.\n");
+            console.log("Make sure ANTHROPIC_BASE_URL is set correctly:\n");
+            console.log(`  export ANTHROPIC_BASE_URL="${config.gateway || "https://gateway.mnemon.ai"}/v1/proxy/${config.agentId}"\n`);
+            return;
+        }
+        console.log("━".repeat(60));
+        console.log(`Recent Traces (${traces.length})`);
+        console.log("━".repeat(60));
+        for (const trace of traces) {
+            displayTrace(trace);
+        }
+        console.log("━".repeat(60));
+        console.log(`\n💡 View more: smoltbot logs --limit ${limit + 10}\n`);
+        console.log(`📊 Dashboard: https://mnemon.ai/dashboard/${config.agentId}\n`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("404") || message.includes("not found")) {
+            console.log("━".repeat(60));
+            console.log("No traces found");
+            console.log("━".repeat(60));
+            console.log("\n💡 Start using Claude to generate traces.\n");
+        }
+        else {
+            console.log(`\n✗ Failed to fetch traces: ${message}\n`);
+            process.exit(1);
+        }
+    }
+}
+function displayTrace(trace) {
+    const timestamp = formatTimestamp(trace.timestamp);
+    const status = trace.verified ? "✓" : "✗";
+    const statusColor = trace.verified ? "" : " [VIOLATION]";
+    console.log(`\n  ${timestamp} ${status}${statusColor}`);
+    console.log(`  Action: ${trace.action}`);
+    if (trace.tool_name) {
+        console.log(`  Tool:   ${trace.tool_name}`);
+    }
+    if (trace.reasoning) {
+        const preview = truncate(trace.reasoning, 60);
+        console.log(`  Reason: ${preview}`);
+    }
+}
+function formatTimestamp(iso) {
+    try {
+        const date = new Date(iso);
+        return date.toLocaleString("en-US", {
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    }
+    catch {
+        return iso;
+    }
+}
+function truncate(text, maxLength) {
+    const cleaned = text.replace(/\n/g, " ").trim();
+    if (cleaned.length <= maxLength) {
+        return cleaned;
+    }
+    return cleaned.slice(0, maxLength - 3) + "...";
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,299 @@
+import { configExists, loadConfig } from "../lib/config.js";
+import { getAgent, getIntegrity, getTraces } from "../lib/api.js";
+import { detectOpenClaw, getCurrentModel, } from "../lib/openclaw.js";
+import { formatModelName } from "../lib/models.js";
+const GATEWAY_URL = "https://gateway.mnemom.ai";
+const DASHBOARD_URL = "https://mnemom.ai";
+export async function statusCommand() {
+    console.log("\n" + "=".repeat(60));
+    console.log("  smoltbot status");
+    console.log("=".repeat(60) + "\n");
+    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();
+    // 2. Check OpenClaw configuration
+    const openclawCheck = checkOpenClawConfig();
+    checks.push(openclawCheck);
+    // 3. Check current model
+    const modelCheck = checkCurrentModel();
+    checks.push(modelCheck);
+    // 4. Test gateway connectivity
+    const gatewayCheck = await checkGatewayConnectivity();
+    checks.push(gatewayCheck);
+    // 5. Test API connectivity
+    const apiCheck = await checkApiConnectivity(config.agentId);
+    checks.push(apiCheck);
+    // Print all checks
+    printChecks(checks);
+    // Show configuration details
+    console.log("\n" + "─".repeat(50));
+    console.log("Configuration");
+    console.log("─".repeat(50) + "\n");
+    console.log(`Agent ID:  ${config.agentId}`);
+    console.log(`Gateway:   ${config.gateway || GATEWAY_URL}`);
+    console.log(`Dashboard: ${DASHBOARD_URL}/agents/${config.agentId}`);
+    if (config.openclawConfigured) {
+        console.log(`Configured: ${config.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 === "smoltbot") {
+            console.log("  Status: Traced mode ACTIVE");
+        }
+        else {
+            console.log("  Status: Traced mode NOT ACTIVE");
+            console.log(`\n  To enable: openclaw models set smoltbot/${modelId}`);
+        }
+    }
+    // Show trace summary if available
+    if (apiCheck.status === "ok") {
+        await showTraceSummary(config.agentId);
+    }
+    // Show overall status
+    const hasErrors = checks.some((c) => c.status === "error");
+    const hasWarnings = checks.some((c) => c.status === "warning");
+    console.log("\n" + "=".repeat(60));
+    if (hasErrors) {
+        console.log("  Status: ISSUES DETECTED");
+        console.log("\n  Fix the errors above to ensure tracing works correctly.");
+    }
+    else if (hasWarnings) {
+        console.log("  Status: OK (with warnings)");
+    }
+    else {
+        console.log("  Status: ALL SYSTEMS GO");
+    }
+    console.log("=".repeat(60) + "\n");
+}
+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`",
+        };
+    }
+    return {
+        name: "Smoltbot Config",
+        status: "ok",
+        message: `Agent ID: ${config.agentId}`,
+    };
+}
+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",
+            };
+        }
+        return {
+            name: "OpenClaw",
+            status: "error",
+            message: "No API key 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 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 === "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}`,
+    };
+}
+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("\n" + "─".repeat(50));
+        console.log("Trace Summary");
+        console.log("─".repeat(50) + "\n");
+        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("System Checks");
+    console.log("─".repeat(50) + "\n");
+    for (const check of checks) {
+        const icon = check.status === "ok" ? "✓" : check.status === "warning" ? "⚠" : "✗";
+        const color = check.status === "ok"
+            ? ""
+            : check.status === "warning"
+                ? ""
+                : "";
+        console.log(`${icon} ${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 {};

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { initCommand } from "./commands/init.js";
+import { statusCommand } from "./commands/status.js";
+import { integrityCommand } from "./commands/integrity.js";
+import { logsCommand } from "./commands/logs.js";
+program
+    .name("smoltbot")
+    .description("Transparent AI agent tracing - AAP compliant")
+    .version("2.0.0");
+program
+    .command("init")
+    .description("Initialize smoltbot and configure OpenClaw for traced mode")
+    .option("-y, --yes", "Skip confirmation prompts (accept defaults)")
+    .option("-f, --force", "Force reconfiguration even if already configured")
+    .action(async (options) => {
+    try {
+        await initCommand({ yes: options.yes, force: options.force });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("status")
+    .description("Show agent status and connection info")
+    .action(async () => {
+    try {
+        await statusCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("integrity")
+    .description("Display integrity score and verification stats")
+    .action(async () => {
+    try {
+        await integrityCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("logs")
+    .description("Show recent traces and actions")
+    .option("-l, --limit <number>", "Number of traces to show", "10")
+    .action(async (options) => {
+    try {
+        const limit = parseInt(options.limit, 10);
+        await logsCommand({ limit: isNaN(limit) ? 10 : limit });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,34 @@
+export declare const API_BASE = "https://api.mnemom.ai";
+export interface Agent {
+    id: string;
+    gateway: string;
+    last_seen: string | null;
+    claimed: boolean;
+    email?: string;
+    created_at: string;
+}
+export interface IntegrityScore {
+    agent_id: string;
+    score: number;
+    total_traces: number;
+    verified: number;
+    violations: number;
+    last_updated: string;
+}
+export interface Trace {
+    id: string;
+    agent_id: string;
+    timestamp: string;
+    action: string;
+    verified: boolean;
+    reasoning?: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+}
+export interface ApiError {
+    error: string;
+    message: string;
+}
+export declare function getAgent(id: string): Promise<Agent>;
+export declare function getIntegrity(id: string): Promise<IntegrityScore>;
+export declare function getTraces(id: string, limit?: number): Promise<Trace[]>;

package/dist/lib/api.js

@@ -0,0 +1,22 @@
+export const API_BASE = "https://api.mnemom.ai";
+async function fetchApi(endpoint) {
+    const url = `${API_BASE}${endpoint}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const error = (await response.json().catch(() => ({
+            error: "unknown",
+            message: response.statusText,
+        })));
+        throw new Error(error.message || `API request failed: ${response.status}`);
+    }
+    return response.json();
+}
+export async function getAgent(id) {
+    return fetchApi(`/v1/agents/${id}`);
+}
+export async function getIntegrity(id) {
+    return fetchApi(`/v1/integrity/${id}`);
+}
+export async function getTraces(id, limit = 10) {
+    return fetchApi(`/v1/traces?agent_id=${id}&limit=${limit}`);
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,18 @@
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export interface Config {
+    agentId: string;
+    email?: string;
+    gateway?: string;
+    openclawConfigured?: boolean;
+    configuredAt?: string;
+}
+export declare function configExists(): boolean;
+export declare function loadConfig(): Config | null;
+export declare function saveConfig(config: Config): void;
+export declare function generateAgentId(): string;
+/**
+ * Derive agent ID deterministically from an API key.
+ * Uses the same SHA-256 hashing as the gateway so IDs match.
+ */
+export declare function deriveAgentId(apiKey: string): string;

package/dist/lib/config.js

@@ -0,0 +1,40 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+export const CONFIG_DIR = path.join(os.homedir(), ".smoltbot");
+export const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function configExists() {
+    return fs.existsSync(CONFIG_FILE);
+}
+export function loadConfig() {
+    if (!configExists()) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function generateAgentId() {
+    const randomHex = crypto.randomBytes(4).toString("hex");
+    return `smolt-${randomHex}`;
+}
+/**
+ * Derive agent ID deterministically from an API key.
+ * Uses the same SHA-256 hashing as the gateway so IDs match.
+ */
+export function deriveAgentId(apiKey) {
+    const hash = crypto.createHash("sha256").update(apiKey).digest("hex");
+    const agentHash = hash.substring(0, 16);
+    return `smolt-${agentHash.slice(0, 8)}`;
+}

package/dist/lib/models.d.ts

@@ -0,0 +1,32 @@
+import type { ModelDefinition } from "./openclaw.js";
+/**
+ * Known Anthropic model definitions with their specifications.
+ * These are used when configuring the smoltbot provider.
+ */
+export declare const ANTHROPIC_MODELS: Record<string, ModelDefinition>;
+/**
+ * Get model definition by ID
+ * Returns the definition if known, or creates a basic one if unknown
+ */
+export declare function getModelDefinition(modelId: string): ModelDefinition;
+/**
+ * Check if a model ID is a known Anthropic model
+ */
+export declare function isKnownModel(modelId: string): boolean;
+/**
+ * Check if a model ID looks like an Anthropic model
+ */
+export declare function isAnthropicModel(modelId: string): boolean;
+/**
+ * Format a model ID into a human-readable name
+ * e.g., "claude-opus-4-5-20251101" -> "Claude Opus 4.5"
+ */
+export declare function formatModelName(modelId: string): string;
+/**
+ * Get all known model IDs
+ */
+export declare function getAllKnownModelIds(): string[];
+/**
+ * Get the latest model for each tier
+ */
+export declare function getLatestModels(): ModelDefinition[];