@mnemom/mnemom 0.7.0

package/dist/index.js

@@ -0,0 +1,381 @@
+#!/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";
+import { licenseActivateCommand, licenseStatusCommand, licenseDeactivateCommand } from "./commands/license.js";
+import { cardShowCommand, cardPublishCommand, cardValidateCommand } from "./commands/card.js";
+import { policyInitCommand, policyValidateCommand, policyPublishCommand, policyListCommand, policyTestCommand, policyEvaluateCommand, } from "./commands/policy.js";
+import { registerCommand } from "./commands/register.js";
+import { agentsListCommand, agentsRemoveCommand, agentsAddCommand, agentsDefaultCommand, agentsRekeyCommand, agentsCheckBindingCommand } from "./commands/agents.js";
+import { loginCommand, logoutCommand, whoamiCommand } from "./commands/auth.js";
+import { makeMigrateConfigCommand } from "./commands/migrate-config.js";
+program
+    .name("mnemom")
+    .description("Transparent AI agent tracing - AAP compliant")
+    .version("0.6.0")
+    .option("--agent <name>", "Select agent by name");
+program
+    .command("init")
+    .description("Initialize smoltbot for traced mode (interactive, --openclaw, or --standalone)")
+    .option("-y, --yes", "Skip confirmation prompts (accept defaults)")
+    .option("-f, --force", "Force reconfiguration even if already configured")
+    .option("--openclaw", "Configure using OpenClaw (requires OpenClaw installed)")
+    .option("--standalone", "Configure standalone (prompt for API keys directly)")
+    .action(async (options) => {
+    try {
+        await initCommand({
+            yes: options.yes,
+            force: options.force,
+            openclaw: options.openclaw,
+            standalone: options.standalone,
+        });
+    }
+    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 {
+        const opts = program.opts();
+        await statusCommand(opts.agent);
+    }
+    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 {
+        const opts = program.opts();
+        await integrityCommand(opts.agent);
+    }
+    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 globalOpts = program.opts();
+        const limit = parseInt(options.limit, 10);
+        await logsCommand({ limit: isNaN(limit) ? 10 : limit, agentName: globalOpts.agent });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+const license = program
+    .command("license")
+    .description("Enterprise license management");
+license
+    .command("activate <jwt>")
+    .description("Activate an enterprise license")
+    .action(async (jwt) => {
+    try {
+        await licenseActivateCommand(jwt);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+license
+    .command("status")
+    .description("Show license status and details")
+    .action(async () => {
+    try {
+        await licenseStatusCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+license
+    .command("deactivate")
+    .description("Deactivate and remove the enterprise license")
+    .action(async () => {
+    try {
+        await licenseDeactivateCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+const cardCmd = program
+    .command("card")
+    .description("Manage alignment card");
+cardCmd
+    .command("show")
+    .description("Display active alignment card")
+    .action(async () => {
+    try {
+        const opts = program.opts();
+        await cardShowCommand(opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+cardCmd
+    .command("publish")
+    .argument("<file>", "Path to card JSON file")
+    .description("Publish alignment card from JSON file")
+    .action(async (file) => {
+    try {
+        const opts = program.opts();
+        await cardPublishCommand(file, opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+cardCmd
+    .command("validate")
+    .argument("<file>", "Path to card JSON file")
+    .description("Validate card JSON locally")
+    .action(async (file) => {
+    try {
+        await cardValidateCommand(file);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+const policyCmd = program
+    .command("policy")
+    .description("Manage policy engine");
+policyCmd
+    .command("init")
+    .description("Scaffold a policy.json template")
+    .action(async () => {
+    try {
+        await policyInitCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+policyCmd
+    .command("validate")
+    .argument("<file>", "Path to policy JSON file")
+    .description("Validate policy locally")
+    .action(async (file) => {
+    try {
+        await policyValidateCommand(file);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+policyCmd
+    .command("publish")
+    .argument("<file>", "Path to policy JSON file")
+    .description("Validate and publish policy to API")
+    .action(async (file) => {
+    try {
+        const opts = program.opts();
+        await policyPublishCommand(file, opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+policyCmd
+    .command("list")
+    .description("List active policy for current agent")
+    .action(async () => {
+    try {
+        const opts = program.opts();
+        await policyListCommand(opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+policyCmd
+    .command("test")
+    .argument("<file>", "Path to policy JSON file")
+    .option("--against-traces", "Test against historical traces")
+    .description("Dry-run policy against historical traces")
+    .action(async (file) => {
+    try {
+        const opts = program.opts();
+        await policyTestCommand(file, opts.agent);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+policyCmd
+    .command("evaluate")
+    .argument("<file>", "Path to policy JSON file")
+    .option("--card <file>", "Path to alignment card JSON file")
+    .option("--tools <tools>", "Comma-separated list of tool names")
+    .option("--tool-manifest <file>", "Path to tool manifest JSON file")
+    .option("--strict", "Exit with code 1 on warnings (not just failures)")
+    .description("Evaluate policy against tools locally (for CI/CD)")
+    .action(async (file, options) => {
+    try {
+        await policyEvaluateCommand(file, options);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("register <name>")
+    .description("Register a new named agent")
+    .option("--openclaw", "Configure using OpenClaw")
+    .option("--standalone", "Configure standalone mode")
+    .option("--set-default", "Set as default agent")
+    .action(async (name, options) => {
+    try {
+        await registerCommand(name, {
+            openclaw: options.openclaw,
+            standalone: options.standalone,
+            setDefault: options.setDefault,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+const agentsCmd = program
+    .command("agents")
+    .description("List and manage registered agents");
+agentsCmd
+    .action(async () => {
+    try {
+        await agentsListCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentsCmd
+    .command("remove <name>")
+    .description("Remove a registered agent")
+    .action(async (name) => {
+    try {
+        await agentsRemoveCommand(name);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentsCmd
+    .command("add <name-or-id>")
+    .description("Register an existing API agent in local config")
+    .option("--alias <alias>", "Local alias name (default: agent's API name)")
+    .action(async (nameOrId, options) => {
+    try {
+        await agentsAddCommand(nameOrId, options.alias);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentsCmd
+    .command("default <name>")
+    .description("Set the default agent")
+    .action(async (name) => {
+    try {
+        await agentsDefaultCommand(name);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentsCmd
+    .command("rekey [name]")
+    .description("Re-bind an agent to a new provider API key (key hashed locally, never transmitted)")
+    .action(async (name) => {
+    try {
+        await agentsRekeyCommand(name);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentsCmd
+    .command("check-binding [name]")
+    .description("Verify that a provider API key is bound to an agent (key hashed locally, never transmitted)")
+    .action(async (name) => {
+    try {
+        await agentsCheckBindingCommand(name);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("login")
+    .description("Authenticate with your Mnemom account")
+    .option("--no-browser", "Use email/password prompt instead of browser")
+    .action(async (options) => {
+    try {
+        await loginCommand({ noBrowser: options.browser === false });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("logout")
+    .description("Clear stored authentication credentials")
+    .action(async () => {
+    try {
+        await logoutCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command("whoami")
+    .description("Show current authentication status")
+    .action(async () => {
+    try {
+        await whoamiCommand();
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program.addCommand(makeMigrateConfigCommand());
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,133 @@
+export declare const API_BASE: string;
+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 postApi<T>(endpoint: string, body: unknown): Promise<T>;
+export declare function verifyBinding(agentId: string, keyHash: string): Promise<{
+    bound: boolean;
+    key_prefix: string | null;
+}>;
+export declare function getAgent(id: string): Promise<Agent>;
+export interface AgentListItem {
+    id: string;
+    name: string | null;
+    email: string | null;
+    created_at: string;
+    last_seen: string | null;
+    containment_status: string | null;
+    key_prefix?: string | null;
+}
+export declare function listAgents(): Promise<AgentListItem[]>;
+/**
+ * Look up an agent in the authenticated user's account by name.
+ * Tries exact match first, then single partial match.
+ * Throws if multiple agents partially match (ambiguous).
+ * Returns null if no match found.
+ * Note: capped at 100 agents by listAgents().
+ */
+export declare function getAgentByName(name: string): Promise<AgentListItem | null>;
+export declare function getIntegrity(id: string): Promise<IntegrityScore>;
+export declare function getTraces(id: string, limit?: number): Promise<Trace[]>;
+export interface AlignmentCard {
+    card_id?: string;
+    version?: string;
+    issued_at?: string;
+    expires_at?: string;
+    principal?: {
+        name?: string;
+        type?: string;
+        organization?: string;
+    };
+    values?: {
+        declared?: string[];
+        definitions?: Record<string, string>;
+    };
+    autonomy_envelope?: {
+        bounded_actions?: string[];
+        forbidden_actions?: string[];
+        escalation_triggers?: Array<{
+            condition: string;
+            action?: string;
+        }>;
+    };
+    audit_commitment?: {
+        log_level?: string;
+        retention_days?: number;
+        access_policy?: string;
+    };
+    extensions?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface CardResponse {
+    card_id: string;
+    agent_id: string;
+    card_json: AlignmentCard;
+    created_at: string;
+    updated_at: string;
+}
+export declare function getCard(agentId: string): Promise<CardResponse | null>;
+export declare function updateCard(agentId: string, cardJson: AlignmentCard): Promise<{
+    updated: boolean;
+    card_id: string;
+}>;
+export declare function reverifyAgent(agentId: string): Promise<{
+    reverified: number;
+}>;
+export interface PolicyResponse {
+    id: string;
+    name: string;
+    description: string | null;
+    policy_json: Record<string, unknown>;
+    version: number;
+    created_by: string;
+    created_at: string;
+}
+export interface PolicyListResponse {
+    agent_id: string;
+    policy: PolicyResponse | null;
+}
+export declare function getPolicy(agentId: string): Promise<PolicyListResponse | null>;
+export declare function publishPolicy(agentId: string, policyJson: Record<string, unknown>): Promise<{
+    id: string;
+    version: number;
+    created: boolean;
+}>;
+export declare function testPolicyHistorical(agentId: string, policyJson: Record<string, unknown>, limit?: number): Promise<{
+    agent_id: string;
+    policy_name: string;
+    total_traces: number;
+    results: any[];
+    summary: {
+        pass: number;
+        warn: number;
+        fail: number;
+        skipped: number;
+    };
+}>;