@astramindapp/mcp-server 0.5.4 → 0.7.0

package/dist/server.js

@@ -5,7 +5,7 @@
  * Exposes the MIND knowledge graph as MCP tools that any LLM agent can use.
  * This is the universal AI memory layer.
  *
- * Tools (15):
+ * Tools (16):
  *   mind_query     — Semantic search across the knowledge graph
  *   mind_remember  — Store/manage content in the graph (auto-categorized)
  *   mind_context   — Get structured always-loaded context (soul/user/rules)
@@ -21,6 +21,8 @@
  *   mind_insights  — ALE insights and analytics
  *   mind_automate  — Automations and triggers
  *   mind_notify    — Notifications management
+ *   mind_agents    — Admin-only Agent Command Center (registry, heartbeat,
+ *                    probe, status — for Anthony's agent fleet)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMindMcpServer = createMindMcpServer;
@@ -1808,6 +1810,455 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── MIND Front Layer (typed-document taxonomy / "MIND Sense") ─────────────
+    // Three tools that expose the 16 typed-document templates and the typed-save flow.
+    // The same templates power the developer API endpoints under /v1/templates.
+    server.tool("mind_list_templates", "List the 16 MIND Front Layer template types (SOUL, IDENTITY, BELIEFS, USER, AGENTS, TOOLS, SENSES, SKILLS, BEHAVIOR, LESSON, DECISION, POLICY, WORKFLOW, PREFERENCE, GOAL, RELATIONSHIP). Use this first to see what typed documents an agent can fill in. Each entry includes a short description and the source_tag used when storing filled documents.", {}, async () => {
+        try {
+            const result = await client.listFrontLayerTemplates();
+            const lines = [
+                `📋 MIND Front Layer — ${result.count} typed-document templates`,
+                "",
+            ];
+            for (const t of result.templates) {
+                lines.push(`• ${t.type.padEnd(13)} — ${t.description}`);
+            }
+            lines.push("");
+            lines.push("Fetch one with mind_get_template(type=\"<TYPE>\")");
+            lines.push("Save a filled doc with mind_save_typed(type=\"<TYPE>\", title=..., content=...)");
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error listing templates: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("mind_get_template", "Fetch the full augmented markdown for one MIND Front Layer template. Returns a self-contained spec — when to create a document of this type, what slots to fill, and how to store the filled copy. Always read the template before writing a typed document.", {
+        type: zod_1.z
+            .string()
+            .describe("One of the 16 canonical types, upper-case (e.g. SOUL, BEHAVIOR, LESSON, POLICY, GOAL). Use mind_list_templates to see all valid values."),
+    }, async ({ type }) => {
+        try {
+            const result = await client.getFrontLayerTemplate(type);
+            const lines = [
+                `📄 ${result.type} template`,
+                `Description: ${result.description}`,
+                `Source tag (use this when storing): ${result.source_tag}`,
+                `Default tags: ${result.default_tags.join(", ")}`,
+                "",
+                result.body,
+                "",
+                `--- Store via: ${result.store_via} ---`,
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error fetching template: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("mind_save_typed", "Save a filled-out Front Layer document with the proper type tag so retrieval can filter by it later. Wraps mind document creation and pre-bakes the source tag (`front-layer-<type>`). Use this — not raw mind_remember — for any SOUL/IDENTITY/BELIEFS/USER/BEHAVIOR/LESSON/POLICY/etc. document. Pass the markdown body (frontmatter + content) as the `content` field.", {
+        type: zod_1.z
+            .string()
+            .describe("The Front Layer type for this document (e.g. BEHAVIOR, LESSON, POLICY). Must match one of the 16 canonical types."),
+        title: zod_1.z
+            .string()
+            .describe("Short, human-readable title for the document — used in retrieval and the documents UI."),
+        content: zod_1.z
+            .string()
+            .describe("Full markdown body of the typed document including the frontmatter block (---type, id, slots, ---) followed by the human-readable sections."),
+    }, async ({ type, title, content }) => {
+        try {
+            const result = await client.saveTypedDocument(type, title, content);
+            const lines = [
+                `✅ Saved as ${type} document`,
+                `id:    ${result.id}`,
+                `title: ${result.title ?? title}`,
+                `source: front-layer-${type.toLowerCase()}`,
+                `status: ${result.status ?? "PROCESSED"}`,
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error saving typed document: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("mind_bootstrap_templates", "Seed all 16 MIND Front Layer templates into this MIND tenant as system documents. After running, the templates become queryable through mind_query so agents can ask 'what should I fill out for SOUL?' and retrieve the spec from their own knowledge graph. Idempotent — re-runs create fresh copies. Run once per new tenant.", {}, async () => {
+        try {
+            const result = await client.bootstrapFrontLayerTemplates();
+            const lines = [
+                `🌱 Bootstrapped ${result.bootstrapped} of ${result.total} Front Layer templates into your MIND.`,
+                "",
+            ];
+            for (const r of result.results) {
+                if (r.status === "PROCESSED") {
+                    lines.push(`  ✅ ${r.type.padEnd(13)} — ${r.title ?? ""}`);
+                }
+                else {
+                    lines.push(`  ❌ ${r.type.padEnd(13)} — ${r.status}${r.error ? `: ${r.error}` : ""}`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error bootstrapping templates: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_agents ────────────────────────────────────────
+    // Admin-only registry of every agent across MINDapp + the VPS fleet.
+    // Surface UI: https://m-i-n-d.ai/agents · Backend: /admin/agents/*
+    // Use this BEFORE creating a new agent so you don't collide with an
+    // existing slug, and AFTER any non-trivial work to update status,
+    // current_job, or responsibilities.
+    server.tool("mind_agents", "Admin-only Agent Command Center — canonical registry of every Astra AI agent (running on VPS, planned, archived). Query before scaffolding a new agent. Update status / current_job / responsibilities after non-trivial work. Backed by /admin/agents on the MIND backend; admin API key required.", {
+        action: zod_1.z
+            .enum([
+            "list",
+            "get",
+            "create",
+            "update",
+            "delete",
+            "heartbeat",
+            "probe",
+            "log_activity",
+            "list_activities",
+            "import_from_mind",
+            "seed_known",
+            "set_status",
+            "set_current_job",
+        ])
+            .describe("Action: list (filter+stats), get (detail+recent activities), create, update (partial), delete (soft archive; pass hard=true to remove), heartbeat (push from agent runtime), probe (HTTP/OpenClaw liveness probe), log_activity (manual note), list_activities, import_from_mind (enrich from agent-identity docs), seed_known (idempotent upsert of canonical seed), set_status (shortcut update), set_current_job (shortcut update)"),
+        slug: zod_1.z.string().optional().describe("Agent slug (lowercase, dashes). Required for get/update/delete/heartbeat/probe/activities/set_*."),
+        // create / update fields
+        name: zod_1.z.string().optional().describe("Display name."),
+        description: zod_1.z.string().optional().describe("One-paragraph description of the agent."),
+        status: zod_1.z
+            .enum(["running", "paused", "planned", "archived", "error"])
+            .optional()
+            .describe("Lifecycle status."),
+        cadence: zod_1.z
+            .enum(["continuous", "scheduled", "on-demand"])
+            .optional()
+            .describe("How the agent runs."),
+        host: zod_1.z.string().optional().describe("Host: DO1 / DO2-LEO / local / render / vercel / atlas-droplet / other."),
+        host_address: zod_1.z.string().optional().describe("IP or hostname (e.g. 45.55.233.204)."),
+        port: zod_1.z.number().optional().describe("TCP port if applicable."),
+        health_url: zod_1.z.string().optional().describe("Optional HTTP health endpoint for the probe action."),
+        source_path: zod_1.z.string().optional().describe("Local path to the agent directory (e.g. /Users/anthonyjconti/Documents/Agents/Foo)."),
+        source_repo: zod_1.z.string().optional().describe("Git repo URL when applicable."),
+        mind_identity_doc_id: zod_1.z.string().optional().describe("MIND document id for the agent-identity record."),
+        responsibilities: zod_1.z.array(zod_1.z.string()).optional().describe("Bullet list of what the agent does."),
+        triggers: zod_1.z.array(zod_1.z.string()).optional().describe("Canonical phrases that should invoke this agent."),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Domain tags for filtering."),
+        owner_email: zod_1.z.string().optional().describe("Owner contact (defaults to anthony@theastraway.com)."),
+        expected_interval_seconds: zod_1.z
+            .number()
+            .optional()
+            .describe("Expected heartbeat cadence in seconds; live_status thresholds compute against 2× / 4× this value."),
+        authority_can_autonomous: zod_1.z.array(zod_1.z.string()).optional().describe("Things this agent can do without asking."),
+        authority_requires_approval: zod_1.z.array(zod_1.z.string()).optional().describe("Things that need Anthony's sign-off."),
+        // delete options
+        hard: zod_1.z.boolean().optional().describe("If true with action=delete, permanently remove. Default soft-archives."),
+        // heartbeat fields
+        current_job: zod_1.z.string().optional().describe("What the agent is doing right now (set on heartbeat or set_current_job)."),
+        metrics: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Arbitrary metrics blob attached to a heartbeat."),
+        note: zod_1.z.string().optional().describe("Free-form note attached to a heartbeat."),
+        source: zod_1.z.string().optional().describe("Source attribution for heartbeats / activities."),
+        // log_activity fields
+        activity_type: zod_1.z.string().optional().describe("Activity type for log_activity (e.g. job_done, job_start, error, note)."),
+        activity_payload: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Activity payload for log_activity."),
+        // list / list_activities filters
+        list_status: zod_1.z
+            .enum(["running", "paused", "planned", "archived", "error"])
+            .optional()
+            .describe("Filter by status when listing."),
+        list_host: zod_1.z.string().optional().describe("Filter by host when listing."),
+        list_tag: zod_1.z.string().optional().describe("Filter by tag when listing."),
+        include_archived: zod_1.z.boolean().optional().describe("Include archived records when listing (default false)."),
+        limit: zod_1.z.number().optional().describe("Max activities to return for list_activities (default 50)."),
+        // seed_known
+        overwrite: zod_1.z.boolean().optional().describe("If true with action=seed_known, reset existing records to seed defaults."),
+    }, async (args) => {
+        const { action, slug, name, description, status, cadence, host, host_address, port, health_url, source_path, source_repo, mind_identity_doc_id, responsibilities, triggers, tags, owner_email, expected_interval_seconds, authority_can_autonomous, authority_requires_approval, hard, current_job, metrics, note, source, activity_type, activity_payload, list_status, list_host, list_tag, include_archived, limit, overwrite, } = args;
+        const requireSlug = (label) => {
+            if (!slug) {
+                return `Error: 'slug' is required for action=${label}.`;
+            }
+            return null;
+        };
+        const buildPayload = () => {
+            const payload = {};
+            if (name !== undefined)
+                payload.name = name;
+            if (description !== undefined)
+                payload.description = description;
+            if (status !== undefined)
+                payload.status = status;
+            if (cadence !== undefined)
+                payload.cadence = cadence;
+            if (host !== undefined)
+                payload.host = host;
+            if (host_address !== undefined)
+                payload.host_address = host_address;
+            if (port !== undefined)
+                payload.port = port;
+            if (health_url !== undefined)
+                payload.health_url = health_url;
+            if (source_path !== undefined)
+                payload.source_path = source_path;
+            if (source_repo !== undefined)
+                payload.source_repo = source_repo;
+            if (mind_identity_doc_id !== undefined)
+                payload.mind_identity_doc_id = mind_identity_doc_id;
+            if (responsibilities !== undefined)
+                payload.responsibilities = responsibilities;
+            if (triggers !== undefined)
+                payload.triggers = triggers;
+            if (tags !== undefined)
+                payload.tags = tags;
+            if (owner_email !== undefined)
+                payload.owner_email = owner_email;
+            if (expected_interval_seconds !== undefined)
+                payload.expected_interval_seconds = expected_interval_seconds;
+            if (current_job !== undefined)
+                payload.current_job = current_job;
+            if (authority_can_autonomous !== undefined || authority_requires_approval !== undefined) {
+                payload.authority = {
+                    can_autonomous: authority_can_autonomous ?? [],
+                    requires_approval: authority_requires_approval ?? [],
+                };
+            }
+            return payload;
+        };
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.listAgents({
+                        status: list_status,
+                        host: list_host,
+                        tag: list_tag,
+                        include_archived,
+                    });
+                    const lines = [];
+                    const s = result.stats;
+                    lines.push(`Agent fleet: ${s.total} total · ${s.running} running · ${s.planned} planned · ${s.paused} paused · ${s.error} errored`, `Live: ${s.online} online · ${s.stale} stale · ${s.offline} offline`, "");
+                    for (const a of result.agents) {
+                        const host = a.host ?? "—";
+                        lines.push(`• [${a.status.padEnd(8)}] ${a.slug.padEnd(28)} ${a.live_status.padEnd(7)} host=${host} — ${a.name}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "get": {
+                    const err = requireSlug("get");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const detail = await client.getAgent(slug);
+                    const lines = [
+                        `${detail.name} (${detail.slug})`,
+                        `  status=${detail.status} · cadence=${detail.cadence} · live=${detail.live_status}`,
+                        `  host=${detail.host ?? "—"}${detail.host_address ? ` (${detail.host_address})` : ""}`,
+                        `  last_heartbeat=${detail.last_heartbeat ?? "never"} · current_job=${detail.current_job ?? "—"}`,
+                        detail.description ? `  ${detail.description}` : "",
+                        detail.responsibilities.length
+                            ? `  Responsibilities:\n    - ${detail.responsibilities.join("\n    - ")}`
+                            : "",
+                        detail.tags.length ? `  Tags: ${detail.tags.join(", ")}` : "",
+                        detail.recent_activities?.length
+                            ? `  Recent activity: ${detail.recent_activities
+                                .slice(0, 5)
+                                .map((e) => `${e.type}@${e.ts.slice(0, 19)}`)
+                                .join(" · ")}`
+                            : "",
+                    ].filter(Boolean);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "create": {
+                    if (!slug || !name) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'slug' and 'name' are required for create." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const payload = { slug, name, ...buildPayload() };
+                    const created = await client.createAgent(payload);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ Created agent: ${created.slug} (status=${created.status})` },
+                        ],
+                    };
+                }
+                case "update": {
+                    const err = requireSlug("update");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const payload = buildPayload();
+                    if (Object.keys(payload).length === 0) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: provide at least one field to update." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, payload);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ Updated ${updated.slug} (status=${updated.status}, live=${updated.live_status})` },
+                        ],
+                    };
+                }
+                case "delete": {
+                    const err = requireSlug("delete");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.deleteAgent(slug, !!hard);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${result.hard ? "Deleted" : "Archived"} ${result.deleted}` },
+                        ],
+                    };
+                }
+                case "heartbeat": {
+                    const err = requireSlug("heartbeat");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const updated = await client.agentHeartbeat(slug, {
+                        current_job,
+                        metrics,
+                        note,
+                        source: source ?? "mcp-agent",
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `💓 heartbeat ${updated.slug} → live=${updated.live_status}${updated.current_job ? ` · job="${updated.current_job}"` : ""}`,
+                            },
+                        ],
+                    };
+                }
+                case "probe": {
+                    const err = requireSlug("probe");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.agentProbe(slug);
+                    const p = result.probe;
+                    const summary = p.ok
+                        ? `✅ ${p.probe_kind ?? "probe"} OK · ${p.status_code ?? ""} · ${p.latency_ms ?? "?"}ms${p.endpoint ? ` · ${p.endpoint}` : ""}`
+                        : `❌ ${p.probe_kind ?? "probe"} failed: ${p.error ?? "no signal"}`;
+                    return { content: [{ type: "text", text: summary }] };
+                }
+                case "log_activity": {
+                    const err = requireSlug("log_activity");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const activity = await client.logAgentActivity(slug, {
+                        type: activity_type ?? "note",
+                        payload: activity_payload,
+                        source: source ?? "mcp-agent",
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `📝 ${activity.type} logged for ${slug} (${activity.activity_id})` },
+                        ],
+                    };
+                }
+                case "list_activities": {
+                    const err = requireSlug("list_activities");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.listAgentActivities(slug, limit ?? 50);
+                    if (!result.activities.length) {
+                        return { content: [{ type: "text", text: `No activity for ${slug}.` }] };
+                    }
+                    const lines = result.activities.map((e) => `  ${e.ts} · ${e.type.padEnd(15)} · src=${e.source}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "import_from_mind": {
+                    const result = await client.importAgentsFromMind();
+                    if (result.error) {
+                        return {
+                            content: [{ type: "text", text: `⚠️ import-from-mind: ${result.error}` }],
+                            isError: true,
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Enriched ${result.enriched} agent(s) from MIND identity docs (${result.skipped} skipped). Slugs: ${result.matched_slugs.join(", ") || "—"}`,
+                            },
+                        ],
+                    };
+                }
+                case "seed_known": {
+                    const result = await client.seedKnownAgents(!!overwrite);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Seed: +${result.inserted} new · ${result.updated} updated · ${result.skipped} unchanged · ${result.total_known} canonical`,
+                            },
+                        ],
+                    };
+                }
+                case "set_status": {
+                    const err = requireSlug("set_status");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!status) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'status' is required for set_status." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, { status });
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${updated.slug} → status=${updated.status}` },
+                        ],
+                    };
+                }
+                case "set_current_job": {
+                    const err = requireSlug("set_current_job");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (current_job === undefined) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'current_job' is required for set_current_job." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, { current_job });
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${updated.slug} → current_job="${updated.current_job ?? ""}"` },
+                        ],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_agents error: ${err}` }],
+                isError: true,
+            };
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map