@mnemom/mnemom 0.7.1 → 0.8.0

package/dist/commands/protection.js

@@ -0,0 +1,308 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { spawnSync } from "node:child_process";
+import yaml from "js-yaml";
+import { getProtectionCard, putProtectionCard, resolveAgentId, } from "../lib/api.js";
+import { requireAuth } from "../lib/auth.js";
+import { fmt } from "../lib/format.js";
+import { askYesNo, isInteractive } from "../lib/prompt.js";
+const VALID_MODES = new Set(["observe", "warn", "block"]);
+/**
+ * Validate a protection card object.
+ * Schema: mode, thresholds, screen_surfaces, trusted_sources
+ */
+export function validateProtectionCard(card) {
+    const checks = [];
+    // mode: required, must be observe | warn | block
+    const mode = card.mode;
+    if (typeof mode === "string" && VALID_MODES.has(mode)) {
+        checks.push({ name: "mode", passed: true, message: mode });
+    }
+    else if (mode === undefined) {
+        checks.push({ name: "mode", passed: false, message: "Required (observe | warn | block)" });
+    }
+    else {
+        checks.push({ name: "mode", passed: false, message: `Invalid: "${mode}". Must be observe | warn | block` });
+    }
+    // thresholds: optional, if present must have warn/quarantine/block in ascending order (0-1)
+    const thresholds = card.thresholds;
+    if (thresholds !== undefined) {
+        if (typeof thresholds !== "object" || thresholds === null) {
+            checks.push({ name: "thresholds", passed: false, message: "Must be an object" });
+        }
+        else {
+            const w = thresholds.warn;
+            const q = thresholds.quarantine;
+            const b = thresholds.block;
+            if (w === undefined || q === undefined || b === undefined) {
+                checks.push({ name: "thresholds", passed: false, message: "Must have warn, quarantine, and block fields" });
+            }
+            else if (typeof w !== "number" || typeof q !== "number" || typeof b !== "number") {
+                checks.push({ name: "thresholds", passed: false, message: "Values must be numbers" });
+            }
+            else if (w < 0 || w > 1 || q < 0 || q > 1 || b < 0 || b > 1) {
+                checks.push({ name: "thresholds", passed: false, message: "Values must be between 0 and 1" });
+            }
+            else if (!(w <= q && q <= b)) {
+                checks.push({ name: "thresholds", passed: false, message: `Must be in ascending order (warn=${w} <= quarantine=${q} <= block=${b})` });
+            }
+            else {
+                checks.push({ name: "thresholds", passed: true, message: `warn=${w}, quarantine=${q}, block=${b}` });
+            }
+        }
+    }
+    // screen_surfaces: optional, array of strings
+    const surfaces = card.screen_surfaces;
+    if (surfaces !== undefined) {
+        if (!Array.isArray(surfaces)) {
+            checks.push({ name: "screen_surfaces", passed: false, message: "Must be an array" });
+        }
+        else if (surfaces.some((s) => typeof s !== "string")) {
+            checks.push({ name: "screen_surfaces", passed: false, message: "All entries must be strings" });
+        }
+        else {
+            checks.push({ name: "screen_surfaces", passed: true, message: `${surfaces.length} surface(s)` });
+        }
+    }
+    // trusted_sources: optional, array of objects
+    const trusted = card.trusted_sources;
+    if (trusted !== undefined) {
+        if (!Array.isArray(trusted)) {
+            checks.push({ name: "trusted_sources", passed: false, message: "Must be an array" });
+        }
+        else {
+            checks.push({ name: "trusted_sources", passed: true, message: `${trusted.length} source(s)` });
+        }
+    }
+    return checks;
+}
+// ============================================================================
+// File parsing
+// ============================================================================
+function parseProtectionFile(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const ext = path.extname(filePath).toLowerCase();
+    const format = (ext === ".yaml" || ext === ".yml") ? "yaml" : "json";
+    if (format === "yaml") {
+        const parsed = yaml.load(raw);
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error("YAML did not produce a valid object");
+        }
+        return { parsed, raw, format };
+    }
+    return { parsed: JSON.parse(raw), raw, format };
+}
+// ============================================================================
+// Subcommands
+// ============================================================================
+export async function protectionShowCommand(agentName) {
+    const agentId = await resolveAgentId(agentName);
+    console.log("\nFetching protection card...\n");
+    try {
+        const { body, contentType } = await getProtectionCard(agentId);
+        if (!body) {
+            console.log(fmt.warn("No protection card found"));
+            console.log("\nPublish one with:\n");
+            console.log("  mnemom protection publish <file.yaml>\n");
+            return;
+        }
+        if (contentType.includes("yaml") || contentType.includes("text/yaml")) {
+            console.log(fmt.header("Protection Card"));
+            console.log();
+            console.log(body);
+        }
+        else {
+            const parsed = JSON.parse(body);
+            console.log(fmt.header("Protection Card"));
+            console.log();
+            console.log(yaml.dump(parsed, { lineWidth: 120, noRefs: true }));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log("\n" + fmt.error(`Failed to fetch protection card: ${message}`) + "\n");
+        process.exit(1);
+    }
+}
+export async function protectionPublishCommand(file, agentName) {
+    const agentId = await resolveAgentId(agentName);
+    const filePath = path.resolve(file);
+    if (!fs.existsSync(filePath)) {
+        console.log("\n" + fmt.error(`File not found: ${filePath}`) + "\n");
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = parseProtectionFile(filePath);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log("\n" + fmt.error(`Could not parse file: ${msg}`) + "\n");
+        process.exit(1);
+    }
+    // Validate locally
+    const checks = validateProtectionCard(parsed.parsed);
+    const allPassed = checks.every((c) => c.passed);
+    console.log(fmt.header("Protection Card Validation"));
+    console.log(fmt.label("  Format:", ` ${parsed.format.toUpperCase()}`));
+    console.log();
+    for (const check of checks) {
+        if (check.passed) {
+            console.log(fmt.success(`${check.name}: ${check.message}`));
+        }
+        else {
+            console.log(fmt.error(`${check.name}: ${check.message}`));
+        }
+    }
+    console.log();
+    if (!allPassed) {
+        console.log(fmt.error("Validation failed. Fix the errors above before publishing.") + "\n");
+        process.exit(1);
+    }
+    await requireAuth();
+    if (isInteractive()) {
+        const confirm = await askYesNo(`Publish this protection card for agent ${agentId}?`, false);
+        if (!confirm) {
+            console.log("\nPublish cancelled.\n");
+            return;
+        }
+    }
+    try {
+        console.log("\nPublishing protection card...");
+        const contentType = parsed.format === "yaml" ? "text/yaml" : "application/json";
+        const body = parsed.format === "yaml" ? parsed.raw : JSON.stringify(parsed.parsed);
+        const result = await putProtectionCard(agentId, body, contentType);
+        console.log(fmt.success("Protection card published!"));
+        console.log(fmt.label("  Card ID:", ` ${result.card_id}`));
+        if (result.composed) {
+            console.log(fmt.success("Canonical protection card recomposed"));
+        }
+        console.log();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log("\n" + fmt.error(`Failed to publish protection card: ${message}`) + "\n");
+        process.exit(1);
+    }
+}
+export async function protectionValidateCommand(file) {
+    const filePath = path.resolve(file);
+    if (!fs.existsSync(filePath)) {
+        console.log("\n" + fmt.error(`File not found: ${filePath}`) + "\n");
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = parseProtectionFile(filePath);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log("\n" + fmt.error(`Could not parse file: ${msg}`) + "\n");
+        process.exit(1);
+    }
+    const checks = validateProtectionCard(parsed.parsed);
+    const allPassed = checks.every((c) => c.passed);
+    const passCount = checks.filter((c) => c.passed).length;
+    const failCount = checks.filter((c) => !c.passed).length;
+    console.log(fmt.header("Protection Card Validation Report"));
+    console.log();
+    console.log(fmt.label("  File:", ` ${filePath}`));
+    console.log(fmt.label("  Format:", ` ${parsed.format.toUpperCase()}`));
+    console.log();
+    for (const check of checks) {
+        if (check.passed) {
+            console.log(fmt.success(`${check.name}: ${check.message}`));
+        }
+        else {
+            console.log(fmt.error(`${check.name}: ${check.message}`));
+        }
+    }
+    console.log();
+    if (allPassed) {
+        console.log(fmt.success(`All ${passCount} checks passed`) + "\n");
+    }
+    else {
+        console.log(fmt.error(`${failCount} check(s) failed, ${passCount} passed`) + "\n");
+        process.exit(1);
+    }
+}
+export async function protectionEditCommand(agentName) {
+    const agentId = await resolveAgentId(agentName);
+    await requireAuth();
+    console.log("\nFetching current protection card...\n");
+    const { body: original } = await getProtectionCard(agentId);
+    if (!original) {
+        console.log(fmt.warn("No protection card found. Creating a template..."));
+    }
+    const cardYaml = original || yaml.dump({
+        mode: "observe",
+        thresholds: { warn: 0.3, quarantine: 0.6, block: 0.9 },
+        screen_surfaces: ["system_prompt", "tool_input", "tool_output"],
+        trusted_sources: [],
+    }, { lineWidth: 120, noRefs: true });
+    const tmpDir = os.tmpdir();
+    const tmpFile = path.join(tmpDir, `mnemom-protection-${agentId}.yaml`);
+    fs.writeFileSync(tmpFile, cardYaml);
+    const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+    console.log(`Opening ${editor}...`);
+    const result = spawnSync(editor, [tmpFile], { stdio: "inherit" });
+    if (result.status !== 0) {
+        console.log("\n" + fmt.error("Editor exited with an error") + "\n");
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+        process.exit(1);
+    }
+    const edited = fs.readFileSync(tmpFile, "utf-8");
+    try {
+        fs.unlinkSync(tmpFile);
+    }
+    catch { /* ignore */ }
+    if (edited === cardYaml) {
+        console.log("\nNo changes made.\n");
+        return;
+    }
+    let parsed;
+    try {
+        parsed = yaml.load(edited);
+        if (!parsed || typeof parsed !== "object")
+            throw new Error("Invalid YAML");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log("\n" + fmt.error(`Invalid YAML: ${msg}`) + "\n");
+        process.exit(1);
+    }
+    const checks = validateProtectionCard(parsed);
+    const allPassed = checks.every((c) => c.passed);
+    if (!allPassed) {
+        console.log(fmt.header("Validation Errors"));
+        console.log();
+        for (const check of checks.filter((c) => !c.passed)) {
+            console.log(fmt.error(`${check.name}: ${check.message}`));
+        }
+        console.log();
+        console.log(fmt.error("Validation failed. Card not published.") + "\n");
+        process.exit(1);
+    }
+    if (isInteractive()) {
+        const confirm = await askYesNo("Publish updated protection card?", true);
+        if (!confirm) {
+            console.log("\nPublish cancelled.\n");
+            return;
+        }
+    }
+    try {
+        console.log("\nPublishing protection card...");
+        const putResult = await putProtectionCard(agentId, edited, "text/yaml");
+        console.log(fmt.success("Protection card published!"));
+        console.log(fmt.label("  Card ID:", ` ${putResult.card_id}`) + "\n");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log("\n" + fmt.error(`Failed to publish protection card: ${message}`) + "\n");
+        process.exit(1);
+    }
+}

package/dist/commands/status.js

@@ -1,10 +1,10 @@
-import { configExists, loadConfig, requireAgent } from "../lib/config.js";
-import { getAgent, getIntegrity, getTraces } from "../lib/api.js";
+import { getGatewayUrl } from "../lib/config.js";
+import { resolveAgentId, getAgent, getIntegrity, getTraces } from "../lib/api.js";
+import { isLoggedIn, getAuthInfo } from "../lib/auth.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",
@@ -17,19 +17,20 @@ const AIP_SUPPORT = {
     gemini: "Full (thought parts)",
 };
 export async function statusCommand(agentName) {
-    console.log(fmt.header("smoltbot status"));
+    console.log(fmt.header("mnemom status"));
     console.log();
     const checks = [];
-    // 1. Check smoltbot config
-    const configCheck = checkSmoltbotConfig();
-    checks.push(configCheck);
-    if (configCheck.status === "error") {
+    // 1. Check auth status
+    const authCheck = await checkAuthStatus();
+    checks.push(authCheck);
+    if (authCheck.status === "error") {
         printChecks(checks);
-        console.log("\nRun `smoltbot init` to get started.\n");
+        console.log("\nRun `mnemom login` to authenticate.\n");
         process.exit(1);
     }
-    const config = loadConfig();
-    const agent = await requireAgent(agentName);
+    // Resolve agent ID from server
+    const agentId = await resolveAgentId(agentName);
+    const gatewayUrl = getGatewayUrl();
     // 2. Check OpenClaw configuration
     const openclawCheck = checkOpenClawConfig();
     checks.push(openclawCheck);
@@ -40,28 +41,19 @@ export async function statusCommand(agentName) {
     const modelCheck = checkCurrentModel();
     checks.push(modelCheck);
     // 5. Test gateway connectivity
-    const gatewayCheck = await checkGatewayConnectivity();
+    const gatewayCheck = await checkGatewayConnectivity(gatewayUrl);
     checks.push(gatewayCheck);
     // 6. Test API connectivity
-    const apiCheck = await checkApiConnectivity(agent.agentId);
+    const apiCheck = await checkApiConnectivity(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"}`);
-    }
+    console.log(fmt.label("Agent ID: ", agentId));
+    console.log(fmt.label("Gateway:  ", gatewayUrl));
+    console.log(fmt.label("Dashboard:", ` ${DASHBOARD_URL}/agents/${agentId}`));
     // Show current model info
     const { fullPath, provider, modelId } = getCurrentModel();
     if (fullPath) {
@@ -76,7 +68,7 @@ export async function statusCommand(agentName) {
             console.log("  Status: Traced mode NOT ACTIVE");
             if (modelId) {
                 const detectedProvider = detectProvider(modelId);
-                const configKey = detectedProvider ? PROVIDER_CONFIG_KEYS[detectedProvider] : "smoltbot";
+                const configKey = detectedProvider ? PROVIDER_CONFIG_KEYS[detectedProvider] : "mnemom";
                 console.log(`\n  To enable: openclaw models set ${configKey}/${modelId}`);
             }
         }
@@ -85,7 +77,7 @@ export async function statusCommand(agentName) {
     showProviderSummary();
     // Show trace summary if available
     if (apiCheck.status === "ok") {
-        await showTraceSummary(agent.agentId);
+        await showTraceSummary(agentId);
     }
     // Show overall status
     const hasErrors = checks.some((c) => c.status === "error");
@@ -105,29 +97,29 @@ export async function statusCommand(agentName) {
     // Refresh model cache in background (non-blocking)
     refreshModelCache().catch(() => { });
 }
-function checkSmoltbotConfig() {
-    if (!configExists()) {
+async function checkAuthStatus() {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
         return {
-            name: "Smoltbot Config",
+            name: "Authentication",
             status: "error",
-            message: "Not initialized",
-            details: "Run `smoltbot init` to configure",
+            message: "Not authenticated",
+            details: "Run `mnemom login` or set MNEMOM_API_KEY",
         };
     }
-    const config = loadConfig();
-    if (!config) {
+    const auth = getAuthInfo();
+    if (auth) {
         return {
-            name: "Smoltbot Config",
-            status: "error",
-            message: "Config file corrupted",
-            details: "Delete ~/.smoltbot/config.json and run `smoltbot init`",
+            name: "Authentication",
+            status: "ok",
+            message: `Logged in as ${auth.email}`,
         };
     }
-    const defaultAgent = config.agents[config.defaultAgent];
+    // API key auth (no email available)
     return {
-        name: "Smoltbot Config",
+        name: "Authentication",
         status: "ok",
-        message: `Agent ID: ${defaultAgent?.agentId ?? "unknown"}`,
+        message: "Authenticated via API key",
     };
 }
 function checkOpenClawConfig() {
@@ -146,7 +138,7 @@ function checkOpenClawConfig() {
                 name: "OpenClaw",
                 status: "error",
                 message: "OAuth auth (not supported)",
-                details: "smoltbot requires API key authentication",
+                details: "mnemom requires API key authentication",
             };
         }
         // Check if any provider has a key (not just Anthropic)
@@ -170,14 +162,14 @@ function checkOpenClawConfig() {
         return {
             name: "OpenClaw",
             status: "warning",
-            message: "smoltbot provider not configured",
-            details: "Run `smoltbot init` to configure",
+            message: "mnemom provider not configured",
+            details: "Run `mnemom register <name>` to configure",
         };
     }
     return {
         name: "OpenClaw",
         status: "ok",
-        message: "smoltbot provider configured",
+        message: "mnemom provider configured",
     };
 }
 function checkConfiguredProviders() {
@@ -201,7 +193,7 @@ function checkConfiguredProviders() {
                 name: `${PROVIDER_LABELS[provider]}`,
                 status: "warning",
                 message: "API key found but not configured",
-                details: "Run `smoltbot init` to configure",
+                details: "Run `mnemom register <name>` to configure",
             });
         }
         // Don't show providers without keys (too noisy)
@@ -215,7 +207,7 @@ function checkCurrentModel() {
             name: "Current Model",
             status: "warning",
             message: "No default model set",
-            details: "Run `openclaw models set smoltbot/<model>`",
+            details: "Run `openclaw models set mnemom/<model>`",
         };
     }
     if (provider && (provider === "smoltbot" || provider.startsWith("smoltbot"))) {
@@ -229,7 +221,7 @@ function checkCurrentModel() {
         name: "Current Model",
         status: "warning",
         message: `${fullPath} (not traced)`,
-        details: `Switch with: openclaw models set smoltbot/${modelId}`,
+        details: `Switch with: openclaw models set mnemom/${modelId}`,
     };
 }
 function showProviderSummary() {
@@ -248,9 +240,9 @@ function showProviderSummary() {
         console.log(`  ${label}: ${configKey}/* (AIP: ${aip})`);
     }
 }
-async function checkGatewayConnectivity() {
+async function checkGatewayConnectivity(gatewayUrl) {
     try {
-        const response = await fetch(`${GATEWAY_URL}/health`, {
+        const response = await fetch(`${gatewayUrl}/health`, {
             signal: AbortSignal.timeout(5000),
         });
         if (response.ok) {