@mnemom/mnemom 0.7.0

package/dist/lib/config.js

@@ -0,0 +1,253 @@
+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");
+const API_URLS = {
+    production: "https://api.mnemom.ai",
+    staging: "https://api-staging.mnemom.ai",
+    local: "http://localhost:8787",
+};
+const GATEWAY_URLS = {
+    production: "https://gateway.mnemom.ai",
+    staging: "https://gateway-staging.mnemom.ai",
+    local: "http://localhost:8787",
+};
+const WEBSITE_URLS = {
+    production: "https://www.mnemom.ai",
+    staging: "https://staging.mnemom.ai",
+    local: "http://localhost:5173",
+};
+/**
+ * Resolve the active environment.
+ *
+ * Resolution order:
+ *  1. `SMOLTBOT_ENV` environment variable
+ *  2. Defaults to `production`
+ */
+export function getEnvironment() {
+    const env = process.env.SMOLTBOT_ENV;
+    if (env === "staging" || env === "local")
+        return env;
+    return "production";
+}
+export function getApiUrl() {
+    return API_URLS[getEnvironment()];
+}
+export function getGatewayUrl() {
+    return GATEWAY_URLS[getEnvironment()];
+}
+export function getWebsiteUrl() {
+    return WEBSITE_URLS[getEnvironment()];
+}
+// ---------------------------------------------------------------------------
+// Migration
+// ---------------------------------------------------------------------------
+/**
+ * Migrate a v1 config into v2 format.
+ * All agent-specific fields move into `agents.default`.
+ */
+export function migrateConfig(raw) {
+    return {
+        version: 2,
+        defaultAgent: "default",
+        gateway: raw.gateway ?? "https://gateway.mnemom.ai",
+        mnemomApiKey: raw.mnemomApiKey,
+        licenseJwt: raw.licenseJwt,
+        agents: {
+            default: {
+                agentId: raw.agentId,
+                openclawConfigured: raw.openclawConfigured,
+                providers: raw.providers,
+                configuredAt: raw.configuredAt,
+            },
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+export function configExists() {
+    return fs.existsSync(CONFIG_FILE);
+}
+/**
+ * Load the config file.
+ * If the file is v1 (no `version` field), it is automatically migrated to v2
+ * and written back to disk before returning.
+ */
+export function loadConfig() {
+    if (!configExists()) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        const raw = JSON.parse(content);
+        // Detect v1: no `version` field present
+        if (!raw.version) {
+            const migrated = migrateConfig(raw);
+            saveConfig(migrated);
+            return migrated;
+        }
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Validate write path stays within expected directory
+    const resolvedPath = path.resolve(CONFIG_FILE);
+    if (!resolvedPath.startsWith(path.resolve(CONFIG_DIR))) {
+        throw new Error("Config file path escapes expected directory");
+    }
+    // Re-serialize to sanitize any HTTP-sourced data before writing to disk
+    const sanitizedConfig = JSON.parse(JSON.stringify(config));
+    const tmpFile = `${resolvedPath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpFile, JSON.stringify(sanitizedConfig, null, 2));
+    fs.renameSync(tmpFile, resolvedPath);
+}
+// ---------------------------------------------------------------------------
+// Agent resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the active agent config.
+ *
+ * Resolution order:
+ *  1. Explicit `agentName` parameter (--agent flag)
+ *  2. `SMOLTBOT_AGENT` environment variable
+ *
+ * Returns `null` if no agent is specified or the agent is not found.
+ * Callers must require --agent or SMOLTBOT_AGENT for agent-scoped commands.
+ */
+export function getActiveAgent(agentName) {
+    const config = loadConfig();
+    if (!config) {
+        return null;
+    }
+    const name = agentName ??
+        process.env.SMOLTBOT_AGENT;
+    if (!name) {
+        return null;
+    }
+    return config.agents[name] ?? null;
+}
+/**
+ * Require an explicit agent selection. Exits with a helpful error if
+ * no agent was specified via --agent or SMOLTBOT_AGENT.
+ *
+ * Falls back to API lookup if the agent is not in local config:
+ *  - smolt-XXXXXXXX IDs: public endpoint, no auth required
+ *  - Names: authenticated account listing (requires `smoltbot login`)
+ */
+export async function requireAgent(agentName) {
+    if (!configExists()) {
+        console.error("\nsmoltbot is not initialized. Run `smoltbot init` first.\n");
+        process.exit(1);
+    }
+    // Fast path: local config hit — no network call needed
+    const localAgent = getActiveAgent(agentName);
+    if (localAgent)
+        return localAgent;
+    const name = agentName ?? process.env.SMOLTBOT_AGENT;
+    if (!name) {
+        console.error("\nAgent required. Use --agent <name> or set SMOLTBOT_AGENT.\n");
+        console.error("Available agents:");
+        const config = loadConfig();
+        if (config) {
+            for (const [n, a] of Object.entries(config.agents)) {
+                console.error(`  ${n} (${a.agentId})`);
+            }
+        }
+        console.error();
+        process.exit(1);
+    }
+    // API fallback: resolve from account
+    try {
+        const { getAgent, getAgentByName } = await import("./api.js");
+        let found = null;
+        if (/^smolt-[0-9a-f]{8}$/.test(name)) {
+            // Public endpoint — no auth needed
+            found = await getAgent(name);
+        }
+        else {
+            found = await getAgentByName(name);
+        }
+        if (found) {
+            return { agentId: found.id };
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("Not logged in")) {
+            console.error(`\n${msg}\n`);
+            process.exit(1);
+        }
+        // Other API errors: fall through to "not found" message
+    }
+    console.error(`\nAgent not found: ${name}`);
+    console.error(`Run \`smoltbot agents add ${name}\` to register it locally,`);
+    console.error(`or check \`smoltbot agents\` to see agents in your account.\n`);
+    process.exit(1);
+}
+// ---------------------------------------------------------------------------
+// ID generation
+// ---------------------------------------------------------------------------
+export function generateAgentId() {
+    // New format per ADR-019 (scale/step-25b): mnm-{uuid_v4} for all new agents.
+    // crypto.randomUUID() is a Node.js built-in (>=14.17), no new dependencies.
+    return `mnm-${crypto.randomUUID()}`;
+}
+/**
+ * Compute the 16-char agent_hash for a given API key and optional agent name.
+ * Matches the gateway's hashApiKey() and the POST /v1/agents/:id/rekey expected format.
+ *
+ * Unnamed agent:  SHA256(apiKey).slice(0, 16)
+ * Named agent:    SHA256(apiKey + '|' + name).slice(0, 16)
+ */
+export function computeAgentHash(apiKey, name) {
+    const input = name ? `${apiKey}|${name}` : apiKey;
+    // eslint-disable-next-line -- deterministic ID derivation must match gateway SHA-256
+    return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16); // lgtm[js/insufficient-password-hash]
+}
+/**
+ * Derive agent ID deterministically from an API key.
+ * Uses SHA-256 to match the gateway's hashApiKey (Web Crypto SHA-256, first 16 hex chars).
+ * The agent ID is "smolt-" + first 8 hex chars of the SHA-256 digest.
+ */
+export function deriveAgentId(apiKey) {
+    return `smolt-${computeAgentHash(apiKey).slice(0, 8)}`;
+}
+/**
+ * Derive agent ID deterministically from an API key *and* a name.
+ * Allows multiple named agents to share one API key with distinct IDs.
+ * Uses SHA-256 to match the gateway's hashApiKey(apiKey + '|' + name).
+ */
+export function deriveAgentIdWithName(apiKey, name) {
+    return `smolt-${computeAgentHash(apiKey, name).slice(0, 8)}`;
+}
+// ---------------------------------------------------------------------------
+// Auth token helpers
+// ---------------------------------------------------------------------------
+export function saveAuthTokens(tokens) {
+    const config = loadConfig();
+    if (!config) {
+        throw new Error("Config not initialized. Run `smoltbot init` first.");
+    }
+    config.auth = tokens;
+    saveConfig(config);
+}
+export function clearAuthTokens() {
+    const config = loadConfig();
+    if (!config)
+        return;
+    delete config.auth;
+    saveConfig(config);
+}
+export function getAuthInfo() {
+    const config = loadConfig();
+    return config?.auth ?? null;
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,35 @@
+export type BadgeColor = "green" | "red" | "yellow" | "blue" | "cyan" | "magenta" | "white";
+export declare const fmt: {
+    /**
+     * Bold header with "═" double-line border
+     */
+    header(title: string): string;
+    /**
+     * Dim section divider with "─" line
+     */
+    section(title: string): string;
+    /**
+     * Green check mark with message
+     */
+    success(msg: string): string;
+    /**
+     * Red cross with message
+     */
+    error(msg: string): string;
+    /**
+     * Yellow warning with message
+     */
+    warn(msg: string): string;
+    /**
+     * Dim label with value
+     */
+    label(key: string, val: string): string;
+    /**
+     * Syntax-highlighted JSON output
+     */
+    json(obj: unknown): string;
+    /**
+     * Colored inline badge
+     */
+    badge(text: string, color?: BadgeColor): string;
+};

package/dist/lib/format.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+export const fmt = {
+    /**
+     * Bold header with "═" double-line border
+     */
+    header(title) {
+        const line = "═".repeat(60);
+        return `\n${chalk.bold(line)}\n  ${chalk.bold(title)}\n${chalk.bold(line)}`;
+    },
+    /**
+     * Dim section divider with "─" line
+     */
+    section(title) {
+        const line = "─".repeat(50);
+        return `\n${chalk.dim(line)}\n${title}\n${chalk.dim(line)}`;
+    },
+    /**
+     * Green check mark with message
+     */
+    success(msg) {
+        return `${chalk.green("✓")} ${msg}`;
+    },
+    /**
+     * Red cross with message
+     */
+    error(msg) {
+        return `${chalk.red("✗")} ${msg}`;
+    },
+    /**
+     * Yellow warning with message
+     */
+    warn(msg) {
+        return `${chalk.yellow("⚠")} ${msg}`;
+    },
+    /**
+     * Dim label with value
+     */
+    label(key, val) {
+        return `${chalk.dim(key)} ${val}`;
+    },
+    /**
+     * Syntax-highlighted JSON output
+     */
+    json(obj) {
+        const raw = JSON.stringify(obj, null, 2);
+        return raw
+            .replace(/"([^"]+)":/g, (_match, key) => `${chalk.cyan(`"${key}"`)}:`)
+            .replace(/: "([^"]*)"/g, (_match, val) => `: ${chalk.green(`"${val}"`)}`)
+            .replace(/: (\d+)/g, (_match, num) => `: ${chalk.yellow(num)}`)
+            .replace(/: (true|false)/g, (_match, bool) => `: ${chalk.magenta(bool)}`)
+            .replace(/: (null)/g, (_match, n) => `: ${chalk.dim(n)}`);
+    },
+    /**
+     * Colored inline badge
+     */
+    badge(text, color = "blue") {
+        const colorFn = chalk[color] || chalk.blue;
+        return colorFn(`[${text}]`);
+    },
+};

package/dist/lib/model-cache.d.ts

@@ -0,0 +1,16 @@
+import type { ModelDefinition, Provider } from "./openclaw.js";
+/**
+ * Refresh the model cache in the background.
+ * Fetches from the gateway and saves to disk.
+ * Fails silently — never blocks the caller.
+ */
+export declare function refreshModelCache(): Promise<void>;
+/**
+ * Get a model definition, checking: static registry -> cache -> inference fallback.
+ * This is the primary entry point for looking up model definitions.
+ */
+export declare function getCachedModelDefinition(modelId: string): ModelDefinition;
+/**
+ * Get all known models from both static registry and cache.
+ */
+export declare function getAllCachedModels(): Record<Provider, Record<string, ModelDefinition>>;

package/dist/lib/model-cache.js

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { MODEL_REGISTRY, getModelDefinition as getStaticModelDefinition } from "./models.js";
+const SMOLTBOT_DIR = path.join(os.homedir(), ".smoltbot");
+const CACHE_FILE = path.join(SMOLTBOT_DIR, "models-cache.json");
+const MODELS_URL = "https://gateway.mnemom.ai/models.json";
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+/**
+ * Load the cached model registry from disk.
+ * Returns null if cache doesn't exist or is expired.
+ */
+function loadCache() {
+    if (!fs.existsSync(CACHE_FILE)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(CACHE_FILE, "utf-8");
+        const cache = JSON.parse(content);
+        // Check TTL
+        const fetchedAt = new Date(cache.fetchedAt).getTime();
+        if (Date.now() - fetchedAt > CACHE_TTL_MS) {
+            return null; // Expired
+        }
+        return cache;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save model registry to disk cache.
+ */
+function saveCache(models) {
+    if (!models || typeof models !== "object") {
+        return;
+    }
+    // Ensure directory exists
+    if (!fs.existsSync(SMOLTBOT_DIR)) {
+        fs.mkdirSync(SMOLTBOT_DIR, { recursive: true });
+    }
+    // Validate write path stays within expected directory
+    const resolvedCachePath = path.resolve(CACHE_FILE);
+    if (!resolvedCachePath.startsWith(path.resolve(SMOLTBOT_DIR))) {
+        throw new Error("Cache file path escapes expected directory");
+    }
+    // Re-serialize HTTP-sourced data to sanitize before writing to disk
+    const sanitizedModels = JSON.parse(JSON.stringify(models));
+    const cache = {
+        fetchedAt: new Date().toISOString(),
+        models: sanitizedModels,
+    };
+    // Atomic write: temp file + rename to prevent corruption
+    const tmpFile = `${resolvedCachePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpFile, JSON.stringify(cache, null, 2));
+    fs.renameSync(tmpFile, resolvedCachePath);
+}
+/**
+ * Fetch fresh model registry from the gateway.
+ * Fails silently on network errors — returns null.
+ */
+async function fetchRemoteModels() {
+    try {
+        const response = await fetch(MODELS_URL, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = (await response.json());
+        // Basic validation
+        if (!data.anthropic && !data.openai && !data.gemini) {
+            return null;
+        }
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Refresh the model cache in the background.
+ * Fetches from the gateway and saves to disk.
+ * Fails silently — never blocks the caller.
+ */
+export async function refreshModelCache() {
+    const remote = await fetchRemoteModels();
+    if (remote) {
+        saveCache(remote);
+    }
+}
+/**
+ * Get a model definition, checking: static registry -> cache -> inference fallback.
+ * This is the primary entry point for looking up model definitions.
+ */
+export function getCachedModelDefinition(modelId) {
+    // 1. Check static registry first (always up to date with code)
+    for (const provider of Object.values(MODEL_REGISTRY)) {
+        const known = provider[modelId];
+        if (known)
+            return known;
+    }
+    // 2. Check disk cache
+    const cache = loadCache();
+    if (cache) {
+        for (const provider of Object.values(cache.models)) {
+            const cached = provider[modelId];
+            if (cached)
+                return cached;
+        }
+    }
+    // 3. Fall back to inference (same as static getModelDefinition)
+    return getStaticModelDefinition(modelId);
+}
+/**
+ * Get all known models from both static registry and cache.
+ */
+export function getAllCachedModels() {
+    const result = {
+        anthropic: { ...MODEL_REGISTRY.anthropic },
+        openai: { ...MODEL_REGISTRY.openai },
+        gemini: { ...MODEL_REGISTRY.gemini },
+    };
+    // Merge cache (cache entries don't override static entries)
+    const cache = loadCache();
+    if (cache) {
+        for (const [provider, models] of Object.entries(cache.models)) {
+            if (!result[provider])
+                continue;
+            for (const [id, model] of Object.entries(models)) {
+                if (!(id in result[provider])) {
+                    result[provider][id] = model;
+                }
+            }
+        }
+    }
+    return result;
+}

package/dist/lib/models.d.ts

@@ -0,0 +1,41 @@
+import type { ModelDefinition, Provider } from "./openclaw.js";
+/**
+ * Multi-provider model registry.
+ * Focuses on top-tier reasoning models that OpenClaws use as substrates.
+ */
+export declare const MODEL_REGISTRY: Record<Provider, Record<string, ModelDefinition>>;
+/**
+ * Backward-compatible re-export of Anthropic models.
+ */
+export declare const ANTHROPIC_MODELS: Record<string, ModelDefinition>;
+/**
+ * Detect provider from a model ID string.
+ */
+export declare function detectProvider(modelId: string): Provider | null;
+/**
+ * Get model definition by ID — searches all providers.
+ * 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 model (any provider).
+ */
+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.
+ * Handles Anthropic, OpenAI, and Gemini model ID formats.
+ */
+export declare function formatModelName(modelId: string): string;
+/**
+ * Get all known model IDs across all providers.
+ */
+export declare function getAllKnownModelIds(): string[];
+/**
+ * Get the latest models per provider.
+ * Returns { anthropic: [...], openai: [...], gemini: [...] }
+ */
+export declare function getLatestModels(): Record<Provider, ModelDefinition[]>;