@launchapp-dev/ao-memory-mcp 2.0.0 → 2.0.1

package/dist/tools/summarize.js

@@ -0,0 +1,92 @@
+import { now, jsonResult, errorResult } from "../db.js";
+export const summarizeTools = [
+    {
+        name: "memory.summarize",
+        description: "Create a summary of memory entries. Agent provides the summary text. Server creates the summary record and transitions entries to 'summarized'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                namespace: { type: "string", description: "Namespace to summarize" },
+                agent_role: { type: "string", description: "Agent role" },
+                summary_title: { type: "string", description: "Summary title" },
+                summary_body: { type: "string", description: "Summary content (markdown)" },
+                before: { type: "string", description: "Summarize entries before this ISO date" },
+                entry_ids: { type: "array", items: { type: "number" }, description: "Specific IDs to summarize" },
+            },
+            required: ["namespace", "summary_title", "summary_body"],
+        },
+    },
+    {
+        name: "memory.cleanup",
+        description: "Identify stale entries needing summarization or archive old summarized entries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                older_than_days: { type: "number", description: "Entries older than N days (default 7)" },
+                min_entries: { type: "number", description: "Min entries per scope to trigger (default 10)" },
+                dry_run: { type: "boolean", description: "Preview only (default true)" },
+            },
+        },
+    },
+];
+export function handleSummarize(db, name, args) {
+    if (name === "memory.summarize")
+        return memorySummarize(db, args);
+    if (name === "memory.cleanup")
+        return memoryCleanup(db, args);
+    return null;
+}
+function memorySummarize(db, args) {
+    const { namespace, agent_role, summary_title, summary_body } = args;
+    const result = db.transaction(() => {
+        let entryIds;
+        if (args.entry_ids?.length) {
+            entryIds = args.entry_ids;
+        }
+        else {
+            const cutoff = args.before || new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+            const conditions = ["namespace = ?", "status = 'active'", "occurred_at < ?"];
+            const vals = [namespace, cutoff];
+            if (agent_role) {
+                conditions.push("agent_role = ?");
+                vals.push(agent_role);
+            }
+            const rows = db.prepare(`SELECT id FROM memories WHERE ${conditions.join(" AND ")}`).all(...vals);
+            entryIds = rows.map(r => r.id);
+        }
+        if (entryIds.length === 0)
+            return { error: "No entries to summarize" };
+        const range = db.prepare(`SELECT MIN(occurred_at) as date_from, MAX(occurred_at) as date_to FROM memories WHERE id IN (${entryIds.map(() => "?").join(",")})`).get(...entryIds);
+        const ts = now();
+        const sumResult = db.prepare(`
+      INSERT INTO summaries (scope, namespace, agent_role, title, content, entry_count, date_from, date_to, entry_ids, created_at)
+      VALUES ('project', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(namespace, agent_role || null, summary_title, summary_body, entryIds.length, range.date_from, range.date_to, JSON.stringify(entryIds), ts);
+        db.prepare(`UPDATE memories SET status = 'summarized', updated_at = ? WHERE id IN (${entryIds.map(() => "?").join(",")})`).run(ts, ...entryIds);
+        return { summary_id: Number(sumResult.lastInsertRowid), entries_summarized: entryIds.length };
+    })();
+    if (result.error)
+        return errorResult(result.error);
+    return jsonResult(result);
+}
+function memoryCleanup(db, args) {
+    const olderThanDays = args.older_than_days ?? 7;
+    const minEntries = args.min_entries ?? 10;
+    const dryRun = args.dry_run ?? true;
+    const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000).toISOString();
+    const needsSummarization = db.prepare(`
+    SELECT namespace, agent_role, COUNT(*) as entry_count,
+           MIN(occurred_at) as date_from, MAX(occurred_at) as date_to
+    FROM memories WHERE status = 'active' AND occurred_at < ?
+    GROUP BY namespace, agent_role
+    HAVING COUNT(*) >= ?
+  `).all(cutoff, minEntries);
+    const archivalCutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+    const needsArchival = db.prepare("SELECT COUNT(*) as c FROM memories WHERE status = 'summarized' AND updated_at < ?").get(archivalCutoff).c;
+    let archived = 0;
+    if (!dryRun && needsArchival > 0) {
+        const ts = now();
+        archived = db.prepare("UPDATE memories SET status = 'archived', updated_at = ? WHERE status = 'summarized' AND updated_at < ?").run(ts, archivalCutoff).changes;
+    }
+    return jsonResult({ needs_summarization: needsSummarization, needs_archival: needsArchival, archived, dry_run: dryRun });
+}

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@launchapp-dev/ao-memory-mcp",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Cognitive memory MCP server for AI agents — semantic search, document RAG, knowledge graph, episodic memory, and hybrid retrieval",
   "type": "module",
   "bin": {
-    "ao-memory-mcp": "./src/server.ts"
+    "ao-memory-mcp": "./dist/server.js"
   },
+  "files": [
+    "dist",
+    "src/schema.sql"
+  ],
   "scripts": {
-    "start": "node --experimental-strip-types src/server.ts",
-    "migrate": "node --experimental-strip-types migrate.ts",
-    "build": "tsc --noEmit -p tsconfig.json"
+    "start": "node dist/server.js",
+    "build": "tsc && cp src/schema.sql dist/schema.sql",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",

package/migrate.ts

@@ -1,250 +0,0 @@
-#!/usr/bin/env node --experimental-strip-types
-/**
- * Migration utility: imports existing .ao/memory/*.md files into the memory database.
- *
- * Usage:
- *   node --experimental-strip-types migrate.ts [--repos-dir <path>] [--db <path>]
- *
- * Defaults:
- *   --repos-dir: scans current directory and subdirectories for .ao/memory/
- *   --db: ~/.ao/memory.db
- */
-import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import { resolveDbPath, initDb, contentHash, now } from "./src/db.ts";
-
-// Parse args
-const argv = process.argv.slice(2);
-let reposDir = ".";
-let dbPath: string | undefined;
-for (let i = 0; i < argv.length; i++) {
-  if (argv[i] === "--repos-dir" && argv[i + 1]) reposDir = argv[++i];
-  if (argv[i] === "--db" && argv[i + 1]) dbPath = argv[++i];
-}
-
-const db = initDb(resolveDbPath(dbPath));
-
-const roleToFile: Record<string, string> = {
-  "planner.md": "planner",
-  "product-owner.md": "product-owner",
-  "reconciler.md": "reconciler",
-  "reviewer.md": "reviewer",
-  "qa-tester.md": "qa-tester",
-};
-
-const sectionToEntryType: Record<string, string> = {
-  "tasks enqueued": "task_dispatch",
-  "recently enqueued": "task_dispatch",
-  "rework dispatched": "task_dispatch",
-  "rebase dispatched": "task_dispatch",
-  "tasks skipped": "observation",
-  "capacity notes": "observation",
-  "queue status": "observation",
-  "pipeline health": "observation",
-  "decisions": "decision",
-  "tasks created": "decision",
-  "features assessed": "observation",
-  "gaps identified": "observation",
-  "tasks unblocked": "action",
-  "tasks marked done": "action",
-  "queue cleaned": "action",
-  "actions log": "action",
-  "prs merged": "review",
-  "prs with changes requested": "review",
-  "prs closed": "review",
-  "known patterns": "pattern",
-  "log": "test_result",
-  "test results": "test_result",
-  "bugs filed": "test_result",
-  "regressions": "test_result",
-};
-
-function guessEntryType(sectionHeader: string, agentRole: string): string {
-  const lower = sectionHeader.toLowerCase();
-  for (const [key, type] of Object.entries(sectionToEntryType)) {
-    if (lower.includes(key)) return type;
-  }
-  // Fallback by role
-  if (agentRole === "planner") return "task_dispatch";
-  if (agentRole === "product-owner") return "decision";
-  if (agentRole === "reconciler") return "action";
-  if (agentRole === "reviewer") return "review";
-  if (agentRole === "qa-tester") return "test_result";
-  return "observation";
-}
-
-interface ParsedEntry {
-  date: string;
-  title: string;
-  body: string;
-  entryType: string;
-  taskId?: string;
-  prNumber?: number;
-  runId?: string;
-}
-
-function parseMemoryFile(content: string, agentRole: string): ParsedEntry[] {
-  const entries: ParsedEntry[] = [];
-  const lines = content.split("\n");
-  let currentSection = "";
-  let currentDate = "";
-  let currentBlock: string[] = [];
-
-  function flushBlock() {
-    if (currentBlock.length === 0 || !currentDate) return;
-    const body = currentBlock.join("\n").trim();
-    if (!body) return;
-
-    const entryType = guessEntryType(currentSection, agentRole);
-    const firstLine = currentBlock.find(l => l.trim())?.trim() || "";
-    const title = firstLine.length > 120 ? firstLine.slice(0, 117) + "..." : firstLine;
-
-    // Extract task IDs
-    const taskMatch = body.match(/TASK-\d+/);
-    const prMatch = body.match(/(?:PR\s*#|#)(\d+)/);
-    const runMatch = body.match(/run\s+(\d+)/i);
-
-    entries.push({
-      date: currentDate,
-      title: title || `${agentRole} ${entryType} ${currentDate}`,
-      body,
-      entryType,
-      taskId: taskMatch?.[0],
-      prNumber: prMatch ? parseInt(prMatch[1]) : undefined,
-      runId: runMatch ? `run ${runMatch[1]}` : undefined,
-    });
-  }
-
-  for (const line of lines) {
-    // Section headers
-    const sectionMatch = line.match(/^##\s+(.+)/);
-    if (sectionMatch) {
-      flushBlock();
-      currentBlock = [];
-      currentSection = sectionMatch[1];
-
-      // Check if section header contains a date
-      const dateInHeader = currentSection.match(/(\d{4}-\d{2}-\d{2})/);
-      if (dateInHeader) currentDate = dateInHeader[1];
-      continue;
-    }
-
-    // Date patterns
-    const dateMatch = line.match(/\[(\d{4}-\d{2}-\d{2})\]/);
-    if (dateMatch) {
-      flushBlock();
-      currentBlock = [];
-      currentDate = dateMatch[1];
-      currentBlock.push(line);
-      continue;
-    }
-
-    // Separator — flush
-    if (line.match(/^---\s*$/)) {
-      flushBlock();
-      currentBlock = [];
-      continue;
-    }
-
-    currentBlock.push(line);
-  }
-  flushBlock();
-
-  return entries;
-}
-
-function findMemoryDirs(rootDir: string): { project: string; memoryDir: string }[] {
-  const results: { project: string; memoryDir: string }[] = [];
-
-  // Check if rootDir itself has .ao/memory
-  const directMemory = join(rootDir, ".ao", "memory");
-  if (existsSync(directMemory) && statSync(directMemory).isDirectory()) {
-    results.push({ project: basename(rootDir), memoryDir: directMemory });
-  }
-
-  // Scan subdirectories
-  try {
-    for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const memDir = join(rootDir, entry.name, ".ao", "memory");
-      if (existsSync(memDir) && statSync(memDir).isDirectory()) {
-        results.push({ project: entry.name, memoryDir: memDir });
-      }
-    }
-  } catch {}
-
-  return results;
-}
-
-// Main
-const ts = now();
-const memoryDirs = findMemoryDirs(reposDir);
-const summary: Record<string, Record<string, number>> = {};
-let totalImported = 0;
-let totalSkipped = 0;
-
-const insert = db.prepare(`
-  INSERT INTO memory_entries (entry_type, agent_role, project, title, body, task_id, pr_number, run_id, status, tags, metadata, created_at, occurred_at, updated_at, content_hash)
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', '[]', '{}', ?, ?, ?, ?)
-`);
-
-const checkHash = db.prepare("SELECT id FROM memory_entries WHERE content_hash = ?");
-
-const importAll = db.transaction(() => {
-  for (const { project, memoryDir } of memoryDirs) {
-    summary[project] = {};
-    try {
-      for (const file of readdirSync(memoryDir)) {
-        const agentRole = roleToFile[file];
-        if (!agentRole) continue;
-
-        const content = readFileSync(join(memoryDir, file), "utf-8");
-        const entries = parseMemoryFile(content, agentRole);
-
-        let count = 0;
-        for (const entry of entries) {
-          const hash = contentHash(entry.entryType, agentRole, project, entry.title, entry.body);
-          if (checkHash.get(hash)) {
-            totalSkipped++;
-            continue;
-          }
-
-          insert.run(
-            entry.entryType, agentRole, project,
-            entry.title, entry.body,
-            entry.taskId || null, entry.prNumber || null, entry.runId || null,
-            ts, entry.date + "T00:00:00.000Z", ts, hash
-          );
-          count++;
-          totalImported++;
-        }
-        summary[project][agentRole] = count;
-      }
-    } catch (err) {
-      console.error(`Error processing ${project}: ${err}`);
-    }
-  }
-});
-
-importAll();
-
-// Print results
-console.log("\n=== Migration Complete ===\n");
-console.log(`Scanned: ${memoryDirs.length} projects with .ao/memory/`);
-console.log(`Imported: ${totalImported} entries`);
-console.log(`Skipped (duplicates): ${totalSkipped}\n`);
-
-const roles = [...new Set(Object.values(summary).flatMap(s => Object.keys(s)))].sort();
-const header = ["Project", ...roles, "Total"].map(h => h.padEnd(16)).join(" | ");
-console.log(header);
-console.log("-".repeat(header.length));
-
-for (const [project, counts] of Object.entries(summary).sort()) {
-  const total = Object.values(counts).reduce((a, b) => a + b, 0);
-  const row = [project, ...roles.map(r => String(counts[r] || 0)), String(total)]
-    .map(v => v.padEnd(16))
-    .join(" | ");
-  console.log(row);
-}
-
-console.log(`\nDatabase: ${resolveDbPath(dbPath)}`);

package/src/db.ts

@@ -1,106 +0,0 @@
-import Database from "better-sqlite3";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { mkdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-let vecLoaded = false;
-
-export function resolveDbPath(cliDbPath?: string): string {
-  if (cliDbPath) return cliDbPath;
-  if (process.env.AO_MEMORY_DB) return process.env.AO_MEMORY_DB;
-  const home = process.env.HOME || process.env.USERPROFILE || ".";
-  const aoDir = join(home, ".ao");
-  mkdirSync(aoDir, { recursive: true });
-  return join(aoDir, "memory.db");
-}
-
-export function initDb(dbPath: string): Database.Database {
-  const db = new Database(dbPath);
-  const schema = readFileSync(join(__dirname, "schema.sql"), "utf-8");
-  db.exec(schema);
-  return db;
-}
-
-export function initVec(db: Database.Database, dimensions: number) {
-  if (vecLoaded) return;
-  try {
-    const sqliteVec = require("sqlite-vec");
-    sqliteVec.load(db);
-    vecLoaded = true;
-  } catch {
-    try {
-      // Fallback: the package might export differently
-      const mod = require("sqlite-vec");
-      if (mod.default?.load) mod.default.load(db);
-      else if (mod.load) mod.load(db);
-      vecLoaded = true;
-    } catch (e) {
-      console.error("[ao-memory] sqlite-vec not available, vector search disabled");
-      return;
-    }
-  }
-
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
-      embedding float[${dimensions}] distance_metric=cosine
-    );
-    CREATE VIRTUAL TABLE IF NOT EXISTS vec_chunks USING vec0(
-      embedding float[${dimensions}] distance_metric=cosine
-    );
-  `);
-}
-
-export function isVecAvailable(): boolean {
-  return vecLoaded;
-}
-
-export function contentHash(...parts: string[]): string {
-  return createHash("sha256").update(parts.join("\0")).digest("hex");
-}
-
-export function now(): string {
-  return new Date().toISOString();
-}
-
-export function jsonResult(data: unknown) {
-  return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
-}
-
-export function errorResult(message: string) {
-  return { content: [{ type: "text" as const, text: JSON.stringify({ error: message }) }], isError: true };
-}
-
-export function touchAccess(db: Database.Database, id: number) {
-  db.prepare("UPDATE memories SET last_accessed_at = ?, access_count = access_count + 1 WHERE id = ?").run(now(), id);
-}
-
-export function chunkText(text: string, maxChars: number = 1000, overlap: number = 100): { content: string; offset: number }[] {
-  if (text.length <= maxChars) {
-    return [{ content: text, offset: 0 }];
-  }
-
-  const chunks: { content: string; offset: number }[] = [];
-  let offset = 0;
-  while (offset < text.length) {
-    let end = Math.min(offset + maxChars, text.length);
-
-    if (end < text.length) {
-      const paraBreak = text.lastIndexOf("\n\n", end);
-      if (paraBreak > offset + maxChars * 0.3) end = paraBreak + 2;
-      else {
-        const sentBreak = text.lastIndexOf(". ", end);
-        if (sentBreak > offset + maxChars * 0.3) end = sentBreak + 2;
-      }
-    }
-
-    chunks.push({ content: text.slice(offset, end).trim(), offset });
-    offset = end - overlap;
-    if (offset >= text.length) break;
-  }
-
-  return chunks.filter(c => c.content.length > 0);
-}

package/src/embeddings.ts

@@ -1,97 +0,0 @@
-import type Database from "better-sqlite3";
-import { isVecAvailable } from "./db.ts";
-
-let extractor: any = null;
-
-const DEFAULT_MODEL = "nomic-ai/nomic-embed-text-v1.5";
-const NOMIC_DIMS = 768;
-const MINILM_DIMS = 384;
-
-export function getModelId(): string {
-  return process.env.AO_MEMORY_MODEL || DEFAULT_MODEL;
-}
-
-function isNomicModel(): boolean {
-  return getModelId().includes("nomic");
-}
-
-export function getDimensions(): number {
-  return isNomicModel() ? NOMIC_DIMS : MINILM_DIMS;
-}
-
-async function getExtractor() {
-  if (extractor) return extractor;
-  const { pipeline } = await import("@huggingface/transformers");
-  const model = getModelId();
-  console.error(`[ao-memory] Loading embedding model: ${model}`);
-  extractor = await pipeline("feature-extraction", model, { dtype: "q8" });
-  console.error(`[ao-memory] Model ready (${getDimensions()}d)`);
-  return extractor;
-}
-
-export async function embed(text: string, isQuery: boolean = false): Promise<Float32Array> {
-  const ext = await getExtractor();
-  const input = isNomicModel()
-    ? (isQuery ? `search_query: ${text}` : `search_document: ${text}`)
-    : text;
-  const output = await ext(input, { pooling: "mean", normalize: true });
-  return new Float32Array(output.data);
-}
-
-export function storeVector(db: Database.Database, table: string, rowid: number, embedding: Float32Array) {
-  if (!isVecAvailable()) return;
-  db.prepare(`INSERT OR REPLACE INTO ${table}(rowid, embedding) VALUES (?, ?)`).run(
-    BigInt(rowid), Buffer.from(embedding.buffer)
-  );
-}
-
-export function deleteVector(db: Database.Database, table: string, rowid: number) {
-  if (!isVecAvailable()) return;
-  db.prepare(`DELETE FROM ${table} WHERE rowid = ?`).run(BigInt(rowid));
-}
-
-export function searchVectors(db: Database.Database, table: string, queryEmbedding: Float32Array, limit: number = 20): { rowid: number; distance: number }[] {
-  if (!isVecAvailable()) return [];
-  return db.prepare(
-    `SELECT rowid, distance FROM ${table} WHERE embedding MATCH ? ORDER BY distance LIMIT ?`
-  ).all(Buffer.from(queryEmbedding.buffer), limit) as any[];
-}
-
-export function hybridSearch(
-  db: Database.Database,
-  ftsTable: string,
-  vecTable: string,
-  queryText: string,
-  queryEmbedding: Float32Array,
-  limit: number = 10,
-  alpha: number = 0.5
-): { rowid: number; score: number }[] {
-  const RRF_K = 60;
-  const scores = new Map<number, number>();
-
-  // FTS5 keyword results
-  try {
-    const ftsResults = db.prepare(
-      `SELECT rowid FROM ${ftsTable} WHERE ${ftsTable} MATCH ? LIMIT 30`
-    ).all(queryText) as any[];
-
-    ftsResults.forEach((r, i) => {
-      const id = Number(r.rowid);
-      scores.set(id, (scores.get(id) || 0) + (1 - alpha) * (1 / (RRF_K + i + 1)));
-    });
-  } catch {}
-
-  // Vector similarity results
-  if (isVecAvailable()) {
-    const vecResults = searchVectors(db, vecTable, queryEmbedding, 30);
-    vecResults.forEach((r, i) => {
-      const id = Number(r.rowid);
-      scores.set(id, (scores.get(id) || 0) + alpha * (1 / (RRF_K + i + 1)));
-    });
-  }
-
-  return [...scores.entries()]
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, limit)
-    .map(([rowid, score]) => ({ rowid, score }));
-}

package/src/server.ts

@@ -1,70 +0,0 @@
-#!/usr/bin/env node --experimental-strip-types
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { resolveDbPath, initDb, initVec, errorResult } from "./db.ts";
-import { getDimensions } from "./embeddings.ts";
-import { storeTools, handleStore } from "./tools/store.ts";
-import { recallTools, handleRecall } from "./tools/recall.ts";
-import { statsTools, handleStats } from "./tools/stats.ts";
-import { contextTools, handleContext } from "./tools/context.ts";
-import { summarizeTools, handleSummarize } from "./tools/summarize.ts";
-import { documentTools, handleDocuments } from "./tools/documents.ts";
-import { knowledgeTools, handleKnowledge } from "./tools/knowledge.ts";
-import { episodeTools, handleEpisodes } from "./tools/episodes.ts";
-
-// Parse CLI args
-const args = process.argv.slice(2);
-let dbPath: string | undefined;
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === "--db" && args[i + 1]) dbPath = args[++i];
-}
-
-const db = initDb(resolveDbPath(dbPath));
-initVec(db, getDimensions());
-
-const allTools = [
-  ...storeTools,
-  ...recallTools,
-  ...documentTools,
-  ...knowledgeTools,
-  ...episodeTools,
-  ...contextTools,
-  ...summarizeTools,
-  ...statsTools,
-];
-
-const handlers: Array<(db: any, name: string, args: any) => any> = [
-  handleStore, handleRecall, handleDocuments, handleKnowledge,
-  handleEpisodes, handleContext, handleSummarize, handleStats,
-];
-
-const server = new Server(
-  { name: "ao-memory-mcp", version: "2.0.0" },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: allTools,
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const { name, arguments: input } = req.params;
-
-  for (const handler of handlers) {
-    const result = handler(db, name, input || {});
-    if (result !== null) {
-      // Handle async results (embed operations)
-      if (result instanceof Promise) return await result;
-      return result;
-    }
-  }
-
-  return errorResult(`Unknown tool: ${name}`);
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);