@mnemom/mnemom 0.7.0

package/dist/commands/integrity.d.ts

@@ -0,0 +1 @@
+export declare function integrityCommand(agentName?: string): Promise<void>;

package/dist/commands/integrity.js

@@ -0,0 +1,49 @@
+import { requireAgent } from "../lib/config.js";
+import { getIntegrity } from "../lib/api.js";
+import { fmt } from "../lib/format.js";
+export async function integrityCommand(agentName) {
+    const agent = await requireAgent(agentName);
+    console.log("\nFetching integrity score...\n");
+    try {
+        const integrity = await getIntegrity(agent.agentId);
+        const scorePercent = (integrity.score * 100).toFixed(1);
+        const scoreBar = generateScoreBar(integrity.score);
+        console.log(fmt.header("Integrity Score"));
+        console.log(`  ${fmt.label("Score:     ", `${scorePercent}% ${scoreBar}`)}`);
+        console.log(`  ${fmt.label("Total:     ", `${integrity.total_traces} traces`)}`);
+        console.log(`  ${fmt.label("Verified:  ", `${integrity.verified}`)} ${fmt.success("")}`);
+        console.log(`  ${fmt.label("Violations:", ` ${integrity.violations}`)} ${fmt.error("")}`);
+        console.log(`  ${fmt.label("Updated:   ", integrity.last_updated)}`);
+        if (integrity.violations > 0) {
+            console.log("\n" + fmt.warn("You have integrity violations. Run `smoltbot logs` to investigate.") + "\n");
+        }
+        else if (integrity.total_traces === 0) {
+            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.\n");
+        }
+        else {
+            console.log("\n" + fmt.success("Your agent has a clean integrity record!") + "\n");
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("404") || message.includes("not found")) {
+            console.log(fmt.header("Integrity Score"));
+            console.log(`  ${fmt.label("Score:     ", "N/A")}`);
+            console.log(`  ${fmt.label("Total:     ", "0 traces")}`);
+            console.log(`  ${fmt.label("Verified:  ", "0")}`);
+            console.log(`  ${fmt.label("Violations:", " 0")}`);
+            console.log("\nNo traces recorded yet. Start using Claude to build your integrity score.\n");
+        }
+        else {
+            console.log("\n" + fmt.error(`Failed to fetch integrity score: ${message}`) + "\n");
+            process.exit(1);
+        }
+    }
+}
+function generateScoreBar(score) {
+    const filled = Math.round(score * 10);
+    const empty = 10 - filled;
+    const filledChar = "█";
+    const emptyChar = "░";
+    return `[${filledChar.repeat(filled)}${emptyChar.repeat(empty)}]`;
+}

package/dist/commands/license.d.ts

@@ -0,0 +1,3 @@
+export declare function licenseActivateCommand(jwt: string): Promise<void>;
+export declare function licenseStatusCommand(): Promise<void>;
+export declare function licenseDeactivateCommand(): Promise<void>;

package/dist/commands/license.js

@@ -0,0 +1,163 @@
+import { loadConfig, saveConfig, configExists } from "../lib/config.js";
+import { API_BASE } from "../lib/api.js";
+import { fmt } from "../lib/format.js";
+/** Sanitize file-sourced data before use in outbound HTTP requests. */
+function sanitizeForHttp(data) {
+    return String(data).trim();
+}
+/**
+ * Decode a JWT payload without verifying the signature.
+ */
+function decodeJwtPayload(jwt) {
+    const parts = jwt.split(".");
+    if (parts.length !== 3)
+        return null;
+    try {
+        const padded = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padding = padded.length % 4 === 0 ? "" : "=".repeat(4 - (padded.length % 4));
+        return JSON.parse(Buffer.from(padded + padding, "base64").toString("utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function licenseActivateCommand(jwt) {
+    if (!jwt || jwt.trim() === "") {
+        console.error("Error: License JWT is required");
+        console.error("Usage: smoltbot license activate <jwt>");
+        process.exit(1);
+    }
+    // Decode claims
+    const claims = decodeJwtPayload(jwt);
+    if (!claims) {
+        console.error("Error: Invalid JWT format");
+        process.exit(1);
+    }
+    console.log("\nActivating enterprise license...\n");
+    // Validate against API (if reachable)
+    const hostname = (await import("node:os")).hostname();
+    try {
+        const licenseUrl = new URL(`${API_BASE}/v1/license/validate`).href;
+        const response = await fetch(licenseUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                license: jwt,
+                instance_id: hostname,
+                instance_metadata: {
+                    hostname,
+                    platform: process.platform,
+                    cli_version: "2.1.0",
+                },
+            }),
+        });
+        if (response.ok) {
+            const result = (await response.json());
+            console.log("  License validated successfully!\n");
+            if (result.warning) {
+                console.log(`  Warning: ${result.warning}\n`);
+            }
+        }
+        else {
+            const err = (await response.json());
+            console.log(`  Warning: Validation returned ${response.status}: ${err.error || "unknown"}`);
+            console.log("  License stored locally (will retry validation).\n");
+        }
+    }
+    catch {
+        console.log("  Warning: Could not reach API for validation.");
+        console.log("  License stored locally (offline mode).\n");
+    }
+    // Store in config
+    const config = loadConfig();
+    if (!config) {
+        console.log("No configuration found. Run 'smoltbot init' first.");
+        process.exit(1);
+    }
+    config.licenseJwt = jwt;
+    saveConfig(config);
+    // Display info
+    const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
+    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : "unknown";
+    console.log("  License ID:      " + (claims.license_id || "unknown"));
+    console.log("  Plan:            " + (claims.plan_id || "unknown"));
+    console.log("  Features:        " + Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none");
+    console.log("  Expires:         " + (expiresAt ? expiresAt.toISOString() : "unknown"));
+    console.log("  Days remaining:  " + daysRemaining);
+    console.log("  Max activations: " + (claims.max_activations || "unknown"));
+    console.log("  Offline mode:    " + (claims.is_offline ? "yes" : "no"));
+    console.log();
+}
+export async function licenseStatusCommand() {
+    if (!configExists()) {
+        console.error("Error: No smoltbot configuration found. Run 'smoltbot init' first.");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config?.licenseJwt) {
+        console.log("\nNo enterprise license configured.");
+        console.log("Use 'smoltbot license activate <jwt>' to activate a license.\n");
+        return;
+    }
+    const claims = decodeJwtPayload(config.licenseJwt);
+    if (!claims) {
+        console.error("Error: Stored license JWT is invalid");
+        process.exit(1);
+    }
+    const expiresAt = claims.exp ? new Date(claims.exp * 1000) : null;
+    const daysRemaining = expiresAt ? Math.floor((expiresAt.getTime() - Date.now()) / 86400000) : null;
+    const isExpired = daysRemaining !== null && daysRemaining <= 0;
+    console.log(fmt.header("Enterprise License Status"));
+    console.log();
+    console.log(`  ${fmt.label("License ID:     ", String(claims.license_id || "unknown"))}`);
+    console.log(`  ${fmt.label("Account:        ", String(claims.account_id || "unknown"))}`);
+    console.log(`  ${fmt.label("Plan:           ", String(claims.plan_id || "unknown"))}`);
+    console.log(`  ${fmt.label("Features:       ", Object.keys(claims.feature_flags || {}).filter((k) => claims.feature_flags[k]).join(", ") || "none")}`);
+    console.log(`  ${fmt.label("Expires:        ", expiresAt ? expiresAt.toISOString() : "unknown")}`);
+    console.log(`  ${fmt.label("Days remaining: ", String(daysRemaining ?? "unknown"))}`);
+    console.log(`  ${fmt.label("Status:         ", isExpired ? "EXPIRED" : "Active")}`);
+    console.log(`  ${fmt.label("Max activations:", ` ${claims.max_activations || "unknown"}`)}`);
+    console.log(`  ${fmt.label("Offline mode:   ", claims.is_offline ? "yes" : "no")}`);
+    console.log();
+    if (isExpired) {
+        console.log("  WARNING: License has expired. Contact enterprise@mnemom.ai for renewal.\n");
+    }
+    else if (daysRemaining !== null && daysRemaining <= 30) {
+        console.log(`  WARNING: License expires in ${daysRemaining} days.\n`);
+    }
+}
+export async function licenseDeactivateCommand() {
+    if (!configExists()) {
+        console.error("Error: No smoltbot configuration found.");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config?.licenseJwt) {
+        console.log("\nNo enterprise license to deactivate.\n");
+        return;
+    }
+    // Try to deactivate via API
+    const claims = decodeJwtPayload(config.licenseJwt);
+    if (claims) {
+        try {
+            const hostname = (await import("node:os")).hostname();
+            const deactivateUrl = new URL(`${API_BASE}/v1/license/validate`).href;
+            await fetch(deactivateUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: sanitizeForHttp(JSON.stringify({
+                    license: String(config.licenseJwt),
+                    instance_id: hostname,
+                    instance_metadata: { deactivating: true },
+                })),
+            });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    // Remove from config
+    delete config.licenseJwt;
+    saveConfig(config);
+    console.log("\nLicense deactivated and removed from local configuration.\n");
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,5 @@
+export interface LogsOptions {
+    limit?: number;
+    agentName?: string;
+}
+export declare function logsCommand(options?: LogsOptions): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,73 @@
+import { requireAgent, loadConfig } from "../lib/config.js";
+import { getTraces } from "../lib/api.js";
+import { fmt } from "../lib/format.js";
+export async function logsCommand(options = {}) {
+    const agent = await requireAgent(options.agentName);
+    const config = loadConfig();
+    const limit = options.limit || 10;
+    console.log("\nFetching traces...\n");
+    try {
+        const traces = await getTraces(agent.agentId, limit);
+        if (traces.length === 0) {
+            console.log(fmt.header("No traces found"));
+            console.log("\nStart 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/${agent.agentId}"\n`);
+            return;
+        }
+        console.log(fmt.header(`Recent Traces (${traces.length})`));
+        for (const trace of traces) {
+            displayTrace(trace);
+        }
+        console.log(`\nView more: smoltbot logs --limit ${limit + 10}`);
+        console.log(`Dashboard: https://mnemon.ai/dashboard/${agent.agentId}\n`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("404") || message.includes("not found")) {
+            console.log(fmt.header("No traces found"));
+            console.log("\nStart using Claude to generate traces.\n");
+        }
+        else {
+            console.log("\n" + fmt.error(`Failed to fetch traces: ${message}`) + "\n");
+            process.exit(1);
+        }
+    }
+}
+function displayTrace(trace) {
+    const timestamp = formatTimestamp(trace.timestamp);
+    const statusMsg = trace.verified
+        ? fmt.success(timestamp)
+        : fmt.error(`${timestamp} [VIOLATION]`);
+    console.log(`\n  ${statusMsg}`);
+    console.log(`  ${fmt.label("Action:", ` ${trace.action}`)}`);
+    if (trace.tool_name) {
+        console.log(`  ${fmt.label("Tool:  ", ` ${trace.tool_name}`)}`);
+    }
+    if (trace.reasoning) {
+        const preview = truncate(trace.reasoning, 60);
+        console.log(`  ${fmt.label("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/migrate-config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function makeMigrateConfigCommand(): Command;

package/dist/commands/migrate-config.js

@@ -0,0 +1,72 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Command } from "commander";
+const OPENCLAW_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
+export function makeMigrateConfigCommand() {
+    const cmd = new Command("migrate-config");
+    cmd
+        .description("Migrate ~/.openclaw/openclaw.json provider keys from smoltbot* to mnemom*")
+        .action(async () => {
+        // 1. Check if OpenClaw config exists
+        if (!fs.existsSync(OPENCLAW_CONFIG_PATH)) {
+            console.log("OpenClaw not detected at ~/.openclaw/openclaw.json. Nothing to migrate.");
+            return;
+        }
+        // 2. Read and parse the config
+        let config = null;
+        try {
+            const raw = fs.readFileSync(OPENCLAW_CONFIG_PATH, "utf-8");
+            config = JSON.parse(raw);
+        }
+        catch {
+            console.error("Error: ~/.openclaw/openclaw.json is malformed JSON.");
+            process.exit(1);
+            return;
+        }
+        if (!config)
+            return;
+        // 3. Get models.providers — must be an object
+        const models = config.models;
+        const providers = models?.providers;
+        if (!providers || typeof providers !== "object" || Object.keys(providers).length === 0) {
+            console.log("No providers found.");
+            return;
+        }
+        // 4. Find all keys matching /^smoltbot/
+        const keysToMigrate = Object.keys(providers).filter((k) => /^smoltbot/.test(k));
+        if (keysToMigrate.length === 0) {
+            console.log("No smoltbot* provider keys found. Nothing to migrate.");
+            return;
+        }
+        // 5. Migrate each key
+        const migrations = [];
+        for (const oldKey of keysToMigrate) {
+            const newKey = oldKey.replace(/^smoltbot/, "mnemom");
+            const entry = providers[oldKey];
+            // Deep-copy the provider entry
+            const newEntry = { ...entry };
+            // Rename x-smoltbot-agent header if present
+            const defaultHeaders = newEntry.defaultHeaders;
+            if (defaultHeaders && "x-smoltbot-agent" in defaultHeaders) {
+                const headersCopy = { ...defaultHeaders };
+                headersCopy["x-mnemom-agent"] = headersCopy["x-smoltbot-agent"];
+                delete headersCopy["x-smoltbot-agent"];
+                newEntry.defaultHeaders = headersCopy;
+            }
+            // Remove old key, add new key
+            delete providers[oldKey];
+            providers[newKey] = newEntry;
+            migrations.push({ from: oldKey, to: newKey });
+        }
+        // 6. Write back
+        fs.writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2));
+        // 7. Print summary
+        console.log(`✓ Migrated ${migrations.length} provider${migrations.length !== 1 ? "s" : ""}:`);
+        for (const { from, to } of migrations) {
+            console.log(`  ${from} → ${to}`);
+        }
+        console.log("\nYour agent config at ~/.smoltbot/ is unchanged.\n");
+    });
+    return cmd;
+}

package/dist/commands/policy.d.ts

@@ -0,0 +1,31 @@
+/**
+ * smoltbot policy init — scaffold a policy.json with commented examples
+ */
+export declare function policyInitCommand(): Promise<void>;
+/**
+ * smoltbot policy validate <file> — local-only validation
+ */
+export declare function policyValidateCommand(file: string): Promise<void>;
+/**
+ * smoltbot policy publish <file> — validate + upload to API
+ */
+export declare function policyPublishCommand(file: string, agentName?: string): Promise<void>;
+/**
+ * smoltbot policy list — list active policies for current agent
+ */
+export declare function policyListCommand(agentName?: string): Promise<void>;
+/**
+ * smoltbot policy test <file> --against-traces — dry-run against historical traces
+ */
+export declare function policyTestCommand(file: string, agentName?: string): Promise<void>;
+/**
+ * smoltbot policy evaluate <policy-file> --card <card-file> --tools <tools> — local CI/CD evaluation
+ *
+ * Runs entirely locally using the embedded policy engine. No API key needed.
+ */
+export declare function policyEvaluateCommand(file: string, options: {
+    card?: string;
+    tools?: string;
+    toolManifest?: string;
+    strict?: boolean;
+}): Promise<void>;