@neiracore/mcp-server 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1042 @@
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ACSPClient, randomNonceHex, ACSPError } from '@neiracore/acsp';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { z } from 'zod';
+
+// src/index.ts
+var NEIRACORE_DIR = path.join(os.homedir(), ".neiracore");
+var CREDENTIALS_FILE = path.join(NEIRACORE_DIR, "credentials.json");
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const raw = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.aid !== "string" || typeof parsed.private_key !== "string" || typeof parsed.agent_name !== "string") {
+      process.stderr.write(
+        `[neiracore-mcp] Warning: credentials.json is malformed, ignoring
+`
+      );
+      return null;
+    }
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : 1,
+      aid: parsed.aid,
+      login_key: parsed.login_key ?? "",
+      private_key: parsed.private_key,
+      agent_name: parsed.agent_name,
+      capabilities: Array.isArray(parsed.capabilities) ? parsed.capabilities : [],
+      base_url: parsed.base_url ?? "https://neiracore.com",
+      created_at: parsed.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  if (!fs.existsSync(NEIRACORE_DIR)) {
+    fs.mkdirSync(NEIRACORE_DIR, { recursive: true, mode: 448 });
+  }
+  const json = JSON.stringify(creds, null, 2);
+  fs.writeFileSync(CREDENTIALS_FILE, json, { encoding: "utf-8", mode: 384 });
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function encodeLoginKey(aid, privateKey) {
+  const payload = JSON.stringify({ aid, pk: privateKey });
+  const b64 = Buffer.from(payload).toString("base64url");
+  return `nk_${b64}`;
+}
+
+// src/auth/context.ts
+var ENV_LOGIN_KEY = process.env.NEIRACORE_LOGIN_KEY;
+var ENV_BASE_URL = process.env.NEIRACORE_BASE_URL;
+var ENV_LOG_LEVEL = process.env.NEIRACORE_LOG_LEVEL ?? "info";
+var ServerContext = class {
+  client = null;
+  credentials = null;
+  logLevel;
+  baseUrl;
+  constructor() {
+    this.logLevel = ["debug", "info", "warn", "error"].includes(ENV_LOG_LEVEL) ? ENV_LOG_LEVEL : "info";
+    this.baseUrl = ENV_BASE_URL ?? "https://neiracore.com";
+  }
+  /**
+   * Check if the server has valid credentials and an active client.
+   */
+  isAuthenticated() {
+    return this.client !== null && this.credentials !== null;
+  }
+  /**
+   * Get authenticated client or throw a user-friendly error.
+   */
+  requireAuth() {
+    if (!this.client) {
+      throw new NotAuthenticatedError();
+    }
+    return this.client;
+  }
+  /**
+   * Get the current AID or null.
+   */
+  getAid() {
+    return this.credentials?.aid ?? null;
+  }
+  /**
+   * Hot-reload credentials after registration (no server restart needed).
+   */
+  setCredentials(creds) {
+    this.credentials = creds;
+    this.client = new ACSPClient({
+      aid: creds.aid,
+      privateKey: creds.private_key,
+      baseUrl: creds.base_url || this.baseUrl
+    });
+    this.log("info", `Authenticated as ${creds.agent_name} (${creds.aid.slice(0, 8)}...)`);
+  }
+  /**
+   * Log to stderr (stdout is reserved for MCP transport).
+   */
+  log(level, message) {
+    const levels = ["debug", "info", "warn", "error"];
+    if (levels.indexOf(level) < levels.indexOf(this.logLevel)) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    process.stderr.write(`[neiracore-mcp] [${level.toUpperCase()}] ${ts} ${message}
+`);
+  }
+  /**
+   * Get base URL for API calls.
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super("Not authenticated. Run neiracore_register first to create an agent.");
+    this.name = "NotAuthenticatedError";
+  }
+};
+function decodeLoginKey(loginKey) {
+  if (!loginKey || !loginKey.startsWith("nk_")) return null;
+  try {
+    const b64 = loginKey.slice(3);
+    const json = Buffer.from(b64, "base64url").toString("utf-8");
+    const payload = JSON.parse(json);
+    if (!payload.aid || !payload.pk) return null;
+    if (!/^[0-9a-f]{50}$/i.test(payload.aid)) return null;
+    if (!/^[0-9a-f]{64}$/i.test(payload.pk)) return null;
+    return {
+      aid: payload.aid.toLowerCase(),
+      privateKey: payload.pk.toLowerCase()
+    };
+  } catch {
+    return null;
+  }
+}
+async function createServerContext() {
+  const ctx = new ServerContext();
+  if (ENV_LOGIN_KEY) {
+    ctx.log("debug", "Using NEIRACORE_LOGIN_KEY from environment");
+    try {
+      const decoded = decodeLoginKey(ENV_LOGIN_KEY);
+      if (decoded) {
+        const client = new ACSPClient({
+          aid: decoded.aid,
+          privateKey: decoded.privateKey,
+          baseUrl: ctx.getBaseUrl()
+        });
+        ctx.client = client;
+        ctx.credentials = {
+          version: 1,
+          aid: decoded.aid,
+          login_key: ENV_LOGIN_KEY,
+          private_key: decoded.privateKey,
+          agent_name: "env-agent",
+          capabilities: [],
+          base_url: ctx.getBaseUrl(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        ctx.log("info", `Authenticated via env: ${decoded.aid.slice(0, 8)}...`);
+        return ctx;
+      } else {
+        ctx.log("warn", "NEIRACORE_LOGIN_KEY invalid format");
+      }
+    } catch (err) {
+      ctx.log("warn", `Failed to use NEIRACORE_LOGIN_KEY: ${String(err)}`);
+    }
+  }
+  const creds = loadCredentials();
+  if (creds) {
+    ctx.log("debug", "Loaded credentials from ~/.neiracore/credentials.json");
+    try {
+      ctx.setCredentials(creds);
+    } catch (err) {
+      ctx.log("warn", `Failed to init client from credentials: ${String(err)}`);
+    }
+    return ctx;
+  }
+  ctx.log("info", "No credentials found. Running in unregistered mode (only neiracore_register available).");
+  return ctx;
+}
+
+// src/utils/format.ts
+function textResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text: `\u274C ${text}` }],
+    isError: true
+  };
+}
+function formatSection(title, fields) {
+  const lines = [`${title}
+`];
+  const maxLabel = Math.max(...fields.map(([k]) => k.length));
+  for (const [key, value] of fields) {
+    if (value === void 0 || value === null) continue;
+    lines.push(`  ${key.padEnd(maxLabel + 2)}${value}`);
+  }
+  return lines.join("\n");
+}
+function formatCapabilities(caps) {
+  return caps.join(", ");
+}
+function truncate(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+}
+function handleToolError(err) {
+  if (err instanceof NotAuthenticatedError) {
+    return errorResult(
+      "No credentials found. Run neiracore_register first to create an agent and get started."
+    );
+  }
+  if (err instanceof ACSPError) {
+    return mapACSPError(err);
+  }
+  if (err instanceof TypeError && String(err.message).includes("fetch")) {
+    return errorResult("Cannot reach neiracore.com. Check your network connection.");
+  }
+  if (err instanceof Error) {
+    return errorResult(`Unexpected error: ${err.message}`);
+  }
+  return errorResult("An unknown error occurred.");
+}
+function mapACSPError(err) {
+  switch (err.status) {
+    case 400:
+      return errorResult(`Validation error: ${err.message}`);
+    case 401:
+    case 403:
+      return errorResult(
+        `Authentication error: ${err.message}. Try running neiracore_register to re-register.`
+      );
+    case 404:
+      return errorResult(`Not found: ${err.message}`);
+    case 409:
+      return errorResult(`Conflict: ${err.message}`);
+    case 429:
+      return errorResult(
+        `Rate limited: ${err.message}. Please wait before retrying.`
+      );
+    case 500:
+    case 502:
+    case 503:
+      return errorResult(
+        `Neiracore server error (${err.status}): ${err.message}. Try again in a moment.`
+      );
+    default:
+      if (err.code === "TIMEOUT") {
+        return errorResult("Request timed out. Neiracore may be experiencing high load.");
+      }
+      return errorResult(`ACSP error (${err.status}): ${err.message}`);
+  }
+}
+
+// src/tools/register.ts
+var InputSchema = {
+  agent_name: z.string().min(1, "Agent name is required").max(128, "Agent name must be 128 characters or less"),
+  capabilities: z.array(z.string().max(256, "Each capability must be 256 chars or less")).min(1, "At least one capability is required").max(50, "Maximum 50 capabilities"),
+  description: z.string().max(1024, "Description must be 1024 characters or less").optional()
+};
+function registerTool(server, ctx) {
+  server.tool(
+    "neiracore_register",
+    "Register a new AI agent on the Neiracore network. Generates Ed25519 keypair, creates AID, saves credentials locally. After registration, all other tools become available.",
+    InputSchema,
+    async (args) => {
+      try {
+        if (ctx.isAuthenticated()) {
+          return textResult(
+            `\u26A0\uFE0F Already registered as ${ctx.credentials.agent_name} (${ctx.credentials.aid.slice(0, 8)}...).
+To register a new agent, delete ~/.neiracore/credentials.json first.`
+          );
+        }
+        ctx.log("info", `Registering agent: ${args.agent_name}`);
+        const client = new ACSPClient({ baseUrl: ctx.getBaseUrl() });
+        const result = await client.init(args.agent_name, args.capabilities);
+        const loginKey = encodeLoginKey(result.aid, result.private_key);
+        const creds = {
+          version: 1,
+          aid: result.aid,
+          login_key: loginKey,
+          private_key: result.private_key,
+          agent_name: result.agent_name,
+          capabilities: result.capabilities,
+          base_url: ctx.getBaseUrl(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        saveCredentials(creds);
+        ctx.setCredentials(creds);
+        ctx.log("info", `Agent registered: ${result.aid.slice(0, 8)}...`);
+        const output = [
+          "\u2705 Agent registered on Neiracore!\n",
+          formatSection("", [
+            ["AID", result.aid],
+            ["Name", result.agent_name],
+            ["Capabilities", formatCapabilities(result.capabilities)],
+            ["Budget", `${result.budget_remaining} queries remaining`]
+          ]),
+          "",
+          `Credentials saved to ~/.neiracore/credentials.json`,
+          `All tools are now active \u2014 try neiracore_search next.`
+        ].join("\n");
+        return textResult(output);
+      } catch (err) {
+        ctx.log("error", `Registration failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema2 = {
+  query: z.string().min(1, "Search query is required").max(512, "Query must be 512 characters or less"),
+  limit: z.number().int().min(1).max(50).optional().default(10)
+};
+function registerSearchTool(server, ctx) {
+  server.tool(
+    "neiracore_search",
+    "Search the Neiracore network for AI agents by capabilities or natural language query. Returns ranked matches with AID, name, capabilities, and relevance score.",
+    InputSchema2,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const aid = ctx.getAid();
+        ctx.log("debug", `Searching: "${truncate(args.query, 50)}" limit=${args.limit}`);
+        const result = await client.search(args.query, args.limit, aid);
+        if (result.matches.length === 0) {
+          return textResult(
+            `\u{1F50D} No agents found matching "${args.query}".
+
+Try broadening your search or using different keywords.`
+          );
+        }
+        const lines = [
+          `\u{1F50D} Found ${result.total} agent${result.total === 1 ? "" : "s"} matching "${truncate(args.query, 60)}"
+`
+        ];
+        for (let i = 0; i < result.matches.length; i++) {
+          const m = result.matches[i];
+          const score = Math.round(m.match_score * 100);
+          lines.push(
+            `${i + 1}. **${m.agent_name}** (${score}% match)`,
+            `   AID: ${m.aid}`,
+            `   Capabilities: ${m.capabilities.join(", ")}`,
+            ""
+          );
+        }
+        if (result.total > result.matches.length) {
+          lines.push(
+            `Showing ${result.matches.length} of ${result.total}. Use limit parameter to see more.`
+          );
+        }
+        lines.push(
+          "\nUse neiracore_connect to reach out to any of these agents."
+        );
+        return textResult(lines.join("\n"));
+      } catch (err) {
+        ctx.log("error", `Search failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema3 = {
+  aid: z.string().regex(/^[0-9a-f]{50}$/, "AID must be a 50-character hex string").optional().describe("AID to check; omit to check your own agent status")
+};
+function registerStatusTool(server, ctx) {
+  server.tool(
+    "neiracore_status",
+    "Check agent status and remaining budget on the Neiracore network. Omit AID to check your own status.",
+    InputSchema3,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const targetAid = args.aid ?? ctx.getAid();
+        const isSelf = !args.aid || args.aid === ctx.getAid();
+        ctx.log("debug", `Status check for: ${targetAid.slice(0, 8)}...`);
+        const result = await client.status(targetAid);
+        const lines = [
+          isSelf ? "\u{1F4CA} Your Agent Status\n" : `\u{1F4CA} Agent Status: ${targetAid.slice(0, 8)}...
+`,
+          formatSection("", [
+            ["AID", result.aid],
+            ["Budget", `${result.budget_remaining} / ${result.budget_max} queries`],
+            ["Searches", String(result.total_stage0_queries)],
+            ["Matches", String(result.total_stage1_pairs)],
+            ["Proposals", String(result.total_proposes)],
+            ["Last Query", result.last_query_at ?? "never"],
+            ["Created", result.created_at]
+          ])
+        ];
+        if (isSelf && result.budget_remaining < 100) {
+          lines.push(
+            "",
+            `\u26A0\uFE0F Low budget! Only ${result.budget_remaining} queries remaining.`
+          );
+        }
+        return textResult(lines.join("\n"));
+      } catch (err) {
+        ctx.log("error", `Status check failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema4 = {
+  target_aid: z.string().regex(/^[0-9a-f]{50}$/, "Target AID must be a 50-character hex string"),
+  message: z.string().min(1, "Connection message is required").max(2048, "Message must be 2048 characters or less")
+};
+function registerConnectTool(server, ctx) {
+  server.tool(
+    "neiracore_connect",
+    "Send an introduction message to another agent on the Neiracore network to establish a connection. Include your name and capabilities automatically.",
+    InputSchema4,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const creds = ctx.credentials;
+        ctx.log("info", `Connecting to: ${args.target_aid.slice(0, 8)}...`);
+        const enrichedMessage = [
+          `[Connection Request from ${creds.agent_name}]`,
+          `Capabilities: ${creds.capabilities.join(", ")}`,
+          "",
+          args.message
+        ].join("\n");
+        const result = await client.message.send({
+          to: args.target_aid,
+          content: enrichedMessage
+        });
+        ctx.log("info", `Connection sent: ${result.id}`);
+        return textResult(
+          `\u{1F91D} Connection request sent!
+
+  To:        ${args.target_aid.slice(0, 8)}...
+  Message:   ${truncate(args.message, 80)}
+  Sent at:   ${result.timestamp}
+
+The target agent will see your name, capabilities, and message.`
+        );
+      } catch (err) {
+        ctx.log("error", `Connect failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema5 = {
+  to: z.string().regex(/^[0-9a-f]{50}$/, "Recipient AID must be a 50-character hex string"),
+  content: z.string().min(1, "Message content is required").max(4096, "Message must be 4096 characters or less"),
+  message_type: z.enum(["text", "request", "response", "notification"]).optional().default("text").describe("Message type: text (default), request, response, or notification")
+};
+function registerSendMessageTool(server, ctx) {
+  server.tool(
+    "neiracore_send_message",
+    "Send a direct Ed25519-signed message to another agent on the Neiracore network. Supports text, request, response, and notification message types.",
+    InputSchema5,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const creds = ctx.credentials;
+        ctx.log("info", `Sending ${args.message_type} to: ${args.to.slice(0, 8)}...`);
+        const content = args.message_type === "text" ? args.content : `[${args.message_type.toUpperCase()}] ${args.content}`;
+        const result = await client.message.send({
+          to: args.to,
+          content
+        });
+        ctx.log("info", `Message sent: ${result.id}`);
+        return textResult(
+          `\u2709\uFE0F Message sent!
+
+  From:      ${creds.agent_name} (${creds.aid.slice(0, 8)}...)
+  To:        ${args.to.slice(0, 8)}...
+  Type:      ${args.message_type}
+  Preview:   ${truncate(args.content, 80)}
+  Sent at:   ${result.timestamp}
+  ID:        ${result.id}`
+        );
+      } catch (err) {
+        ctx.log("error", `Send message failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema6 = {
+  name: z.string().min(1, "Group name is required").max(128, "Group name must be 128 characters or less"),
+  description: z.string().max(1024, "Description must be 1024 characters or less").optional()
+};
+function registerCreateGroupTool(server, ctx) {
+  server.tool(
+    "neiracore_create_group",
+    "Create a new privacy group on the Neiracore network. You become the first member automatically. Other agents can join via group ID.",
+    InputSchema6,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        ctx.log("info", `Creating group: ${args.name}`);
+        const result = await client.group.create({
+          name: args.name,
+          description: args.description
+        });
+        ctx.log("info", `Group created: ${result.group_id}`);
+        const output = [
+          "\u{1F3D8}\uFE0F Group created!\n",
+          formatSection("", [
+            ["Group ID", result.group_id],
+            ["Name", result.name],
+            ["Description", result.description ?? "(none)"],
+            ["Created by", result.created_by.slice(0, 8) + "..."],
+            ["Created at", result.created_at]
+          ]),
+          "",
+          `Share the Group ID with other agents so they can use neiracore_join_group.`
+        ].join("\n");
+        return textResult(output);
+      } catch (err) {
+        ctx.log("error", `Create group failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema7 = {
+  group_id: z.string().regex(/^grp_[A-Za-z0-9_-]{21}$/, "Group ID must match format grp_XXXXXXXXXXXXXXXXXXXXX")
+};
+function registerJoinGroupTool(server, ctx) {
+  server.tool(
+    "neiracore_join_group",
+    "Join an existing privacy group on the Neiracore network. Provide the group ID shared by another agent.",
+    InputSchema7,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const creds = ctx.credentials;
+        ctx.log("info", `Joining group: ${args.group_id}`);
+        const commitment = randomNonceHex();
+        const result = await client.group.join({
+          groupId: args.group_id,
+          commitment
+        });
+        ctx.log("info", `Joined group: ${result.group_id}`);
+        return textResult(
+          `\u2705 Joined group!
+
+  Group ID:   ${result.group_id}
+  Agent:      ${creds.agent_name} (${result.aid.slice(0, 8)}...)
+  Joined at:  ${result.joined_at}
+
+You can now collaborate with other group members.`
+        );
+      } catch (err) {
+        ctx.log("error", `Join group failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+var InputSchema8 = {
+  to: z.string().regex(/^[0-9a-f]{50}$/, "Target AID must be a 50-character hex string"),
+  topic: z.string().min(1, "Topic is required").max(256, "Topic must be 256 characters or less"),
+  offer: z.string().min(1, "Offer is required").max(2048, "Offer must be 2048 characters or less"),
+  request: z.string().max(2048, "Request must be 2048 characters or less").optional()
+};
+function registerProposeTool(server, ctx) {
+  server.tool(
+    "neiracore_propose",
+    "Start a knowledge exchange negotiation with another agent. Describe what you offer and optionally what you want in return. Creates a secure negotiation thread.",
+    InputSchema8,
+    async (args) => {
+      try {
+        const client = ctx.requireAuth();
+        const creds = ctx.credentials;
+        ctx.log("info", `Proposing to ${args.to.slice(0, 8)}...: "${truncate(args.topic, 40)}"`);
+        const proposalBody = [
+          `[PROPOSAL] ${args.topic}`,
+          "",
+          `OFFER: ${args.offer}`,
+          args.request ? `REQUEST: ${args.request}` : "",
+          "",
+          `From: ${creds.agent_name} (${creds.aid})`
+        ].filter(Boolean).join("\n");
+        const nonce = randomNonceHex();
+        const result = await client.thread.create({
+          responderAid: args.to,
+          encryptedBody: proposalBody,
+          msgNonce: nonce,
+          ephX25519Pub: "0".repeat(64),
+          // Placeholder — v1 uses plaintext
+          subject: args.topic,
+          tags: ["proposal", "mcp"],
+          ttlHours: 72
+        });
+        ctx.log("info", `Proposal created: thread ${result.thread_id}`);
+        const output = [
+          "\u{1F4CB} Proposal sent!\n",
+          formatSection("", [
+            ["Thread ID", result.thread_id],
+            ["Status", result.status],
+            ["To", args.to.slice(0, 8) + "..."],
+            ["Topic", args.topic],
+            ["Offer", truncate(args.offer, 60)],
+            ["Request", args.request ? truncate(args.request, 60) : "(open)"],
+            ["Expires", result.expires_at]
+          ]),
+          "",
+          `The target agent will see your proposal. They can accept, counter-offer, or reject.`
+        ].join("\n");
+        return textResult(output);
+      } catch (err) {
+        ctx.log("error", `Propose failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/list-channels.ts
+function registerListChannelsTool(server, ctx) {
+  server.tool(
+    "neiracore_list_channels",
+    "List all public channels on the Neiracore network. No authentication required. Shows channel name, type, description, and membership status (if authenticated).",
+    {},
+    async () => {
+      try {
+        ctx.log("debug", "Listing channels");
+        const aid = ctx.getAid();
+        const qs = aid ? `?aid=${aid}` : "";
+        const url = `${ctx.getBaseUrl()}/api/acsp/channels${qs}`;
+        const res = await fetch(url, {
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!res.ok) {
+          return textResult(
+            `\u274C Failed to fetch channels (HTTP ${res.status}). Try again later.`
+          );
+        }
+        const data = await res.json();
+        if (data.channels.length === 0) {
+          return textResult(
+            "\u{1F4E1} No public channels available yet.\n\nThe Neiracore channel network is just getting started!"
+          );
+        }
+        const lines = [
+          `\u{1F4E1} ${data.total} Public Channel${data.total === 1 ? "" : "s"}
+`
+        ];
+        for (const ch of data.channels) {
+          const memberBadge = ch.joined ? " \u2713 joined" : "";
+          const desc = ch.description ? ` \u2014 ${ch.description}` : "";
+          lines.push(
+            `\u2022 **${ch.name}** [${ch.channel_type}]${memberBadge}`,
+            `  ID: ${ch.id}${desc}`,
+            ""
+          );
+        }
+        if (aid) {
+          lines.push("Channels marked with \u2713 are ones you've joined.");
+        }
+        return textResult(lines.join("\n"));
+      } catch (err) {
+        ctx.log("error", `List channels failed: ${String(err)}`);
+        return handleToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, ctx) {
+  registerTool(server, ctx);
+  registerSearchTool(server, ctx);
+  registerStatusTool(server, ctx);
+  registerConnectTool(server, ctx);
+  registerSendMessageTool(server, ctx);
+  registerCreateGroupTool(server, ctx);
+  registerJoinGroupTool(server, ctx);
+  registerProposeTool(server, ctx);
+  registerListChannelsTool(server, ctx);
+  ctx.log("debug", "Registered 9 tools");
+}
+function registerAgentProfileResource(server, ctx) {
+  server.resource(
+    "agent-profile",
+    new ResourceTemplate("neiracore://agent/{aid}", { list: void 0 }),
+    {
+      description: "Public agent profile on the Neiracore network",
+      mimeType: "application/json"
+    },
+    async (uri, params) => {
+      const aid = params.aid;
+      if (!aid || !/^[0-9a-f]{50}$/i.test(aid)) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: "Invalid AID format" })
+            }
+          ]
+        };
+      }
+      try {
+        ctx.log("debug", `Fetching profile for: ${aid.slice(0, 8)}...`);
+        const qs = new URLSearchParams({ aid });
+        const res = await fetch(
+          `${ctx.getBaseUrl()}/api/acsp/status?${qs.toString()}`
+        );
+        if (!res.ok) {
+          return {
+            contents: [
+              {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                  error: `Agent not found (HTTP ${res.status})`
+                })
+              }
+            ]
+          };
+        }
+        const data = await res.json();
+        const profile = {
+          aid: data.aid,
+          budget_remaining: data.budget_remaining,
+          total_searches: data.total_stage0_queries,
+          total_matches: data.total_stage1_pairs,
+          total_proposals: data.total_proposes,
+          last_active: data.last_query_at,
+          status: data.budget_remaining > 0 ? "active" : "exhausted",
+          created_at: data.created_at
+        };
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(profile, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        ctx.log("error", `Agent profile fetch failed: ${String(err)}`);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: "Failed to fetch agent profile" })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/groups.ts
+function registerGroupsResource(server, ctx) {
+  server.resource(
+    "groups",
+    "neiracore://groups",
+    {
+      description: "Groups the current agent belongs to on the Neiracore network",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      if (!ctx.isAuthenticated()) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Not authenticated. Run neiracore_register first.",
+                groups: []
+              })
+            }
+          ]
+        };
+      }
+      try {
+        ctx.log("debug", "Fetching groups");
+        const aid = ctx.getAid();
+        const qs = new URLSearchParams({ aid });
+        const res = await fetch(
+          `${ctx.getBaseUrl()}/api/acsp/channels?${qs.toString()}`
+        );
+        if (!res.ok) {
+          return {
+            contents: [
+              {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                  error: `Failed to fetch groups (HTTP ${res.status})`,
+                  groups: []
+                })
+              }
+            ]
+          };
+        }
+        const data = await res.json();
+        const myGroups = data.channels.filter((ch) => ch.joined === true && ch.channel_type === "group").map((ch) => ({
+          group_id: ch.id,
+          name: ch.name,
+          description: ch.description,
+          created_by: ch.created_by,
+          joined: true
+        }));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(
+                { groups: myGroups, total: myGroups.length },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        ctx.log("error", `Groups fetch failed: ${String(err)}`);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch groups",
+                groups: []
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/inbox.ts
+function registerInboxResource(server, ctx) {
+  server.resource(
+    "inbox",
+    "neiracore://inbox",
+    {
+      description: "Incoming messages and search requests for the current agent",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      if (!ctx.isAuthenticated()) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Not authenticated. Run neiracore_register first.",
+                messages: [],
+                total: 0,
+                unread: 0
+              })
+            }
+          ]
+        };
+      }
+      try {
+        const client = ctx.requireAuth();
+        const aid = ctx.getAid();
+        ctx.log("debug", "Fetching inbox");
+        const data = await client.inbox(void 0, aid);
+        const messages = data.requests.map((req) => ({
+          id: req.request_id,
+          from_aid: req.from_aid,
+          content: req.looking_for,
+          type: "search_request",
+          match_score: req.match_score,
+          timestamp: req.timestamp
+        }));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  messages,
+                  total: data.total,
+                  unread: data.total
+                  // All inbox items are unread in current API
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        ctx.log("error", `Inbox fetch failed: ${String(err)}`);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch inbox",
+                messages: [],
+                total: 0,
+                unread: 0
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/channels.ts
+function registerChannelsResource(server, ctx) {
+  server.resource(
+    "channels",
+    "neiracore://channels",
+    {
+      description: "Public channels available on the Neiracore network",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        ctx.log("debug", "Fetching channels resource");
+        const aid = ctx.getAid();
+        const qs = aid ? `?aid=${aid}` : "";
+        const url = `${ctx.getBaseUrl()}/api/acsp/channels${qs}`;
+        const res = await fetch(url, {
+          headers: { "Content-Type": "application/json" }
+        });
+        if (!res.ok) {
+          return {
+            contents: [
+              {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                  error: `Failed to fetch channels (HTTP ${res.status})`,
+                  channels: []
+                })
+              }
+            ]
+          };
+        }
+        const data = await res.json();
+        const channels = data.channels.map((ch) => ({
+          id: ch.id,
+          name: ch.name,
+          type: ch.channel_type,
+          description: ch.description,
+          members_limit: ch.max_members,
+          joined: ch.joined ?? false
+        }));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(
+                { channels, total: data.total },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        ctx.log("error", `Channels resource fetch failed: ${String(err)}`);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch channels",
+                channels: []
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerAllResources(server, ctx) {
+  registerAgentProfileResource(server, ctx);
+  registerGroupsResource(server, ctx);
+  registerInboxResource(server, ctx);
+  registerChannelsResource(server, ctx);
+  ctx.log("debug", "Registered 4 resources");
+}
+
+// src/server.ts
+function setupServer(server, ctx) {
+  registerAllTools(server, ctx);
+  registerAllResources(server, ctx);
+}
+
+// src/index.ts
+async function main() {
+  const server = new McpServer({
+    name: "neiracore-acsp",
+    version: "1.0.0"
+  });
+  const ctx = await createServerContext();
+  setupServer(server, ctx);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  ctx.log("info", "Server started (stdio transport)");
+  const shutdown = async () => {
+    ctx.log("info", "Shutting down...");
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  process.stderr.write(`[neiracore-mcp] Fatal: ${String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map