tana-mcp-codemode 0.2.3 → 0.3.0

package/package.json

@@ -1,33 +1,15 @@
 {
   "name": "tana-mcp-codemode",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Codemode MCP server for Tana — AI writes TypeScript that executes against Tana Local API",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "dist/entry-node.js",
   "bin": {
-    "tana-mcp-codemode": "src/index.ts"
-  },
-  "scripts": {
-    "generate": "bun run scripts/generate.ts",
-    "list-endpoints": "bun run scripts/list-endpoints.ts",
-    "start": "bun run --env-file=.env src/index.ts",
-    "dev": "bun run --env-file=.env --watch src/index.ts",
-    "debug": "bun run --env-file=.env src/debug-server.ts",
-    "test": "bun test",
-    "typecheck": "bunx tsc --noEmit",
-    "prepublishOnly": "bun run typecheck",
-    "release:patch": "npm version patch && npm publish",
-    "release:minor": "npm version minor && npm publish",
-    "release:major": "npm version major && npm publish"
+    "tana-mcp-codemode": "dist/entry-node.js"
   },
   "files": [
-    "src/index.ts",
-    "src/prompts.ts",
-    "src/types.ts",
-    "src/api",
-    "src/sandbox",
-    "src/storage",
-    "src/generated",
+    "dist/",
+    "src/",
     "README.md"
   ],
   "keywords": [
@@ -43,16 +25,36 @@
     "url": "git+https://github.com/fabiogaliano/tana-mcp-codemode.git"
   },
   "engines": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.0.0",
+    "node": ">=20"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
     "zod": "^3"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^11",
+    "esbuild": "^0.24"
+  },
   "devDependencies": {
     "@types/bun": "^1.3.8",
     "openapi-typescript": "^7.10.1",
+    "tsup": "^8",
     "typescript": "^5.9.3"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "generate": "bun run scripts/generate.ts",
+    "list-endpoints": "bun run scripts/list-endpoints.ts",
+    "start": "bun run --env-file=.env src/entry-bun.ts",
+    "dev": "bun run --env-file=.env --watch src/entry-bun.ts",
+    "debug": "bun run --env-file=.env src/debug-server.ts",
+    "build": "tsup",
+    "build:binary": "bun build --compile src/entry-bun.ts --outfile dist/tana-mcp-codemode",
+    "test": "bun test",
+    "typecheck": "bunx tsc --noEmit",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish"
+  }
+}

package/src/compat/bun.ts

@@ -0,0 +1,39 @@
+import { Database } from "bun:sqlite";
+import type { CompatDatabase, CompatOps, CompatStatement } from "./types";
+
+function wrapStatement(stmt: ReturnType<Database["prepare"]>): CompatStatement {
+  return {
+    run(...params: unknown[]) {
+      const result = stmt.run(...(params as Parameters<typeof stmt.run>));
+      return { changes: result.changes };
+    },
+    all(...params: unknown[]) {
+      return stmt.all(...(params as Parameters<typeof stmt.all>)) as unknown[];
+    },
+  };
+}
+
+function wrapDatabase(db: Database): CompatDatabase {
+  return {
+    exec(sql: string) {
+      db.run(sql);
+    },
+    prepare(sql: string) {
+      return wrapStatement(db.prepare(sql));
+    },
+    close() {
+      db.close();
+    },
+  };
+}
+
+export const bunCompat: CompatOps = {
+  createDatabase(path: string): CompatDatabase {
+    return wrapDatabase(new Database(path, { create: true }));
+  },
+
+  transpileTS(code: string): string {
+    const transpiler = new Bun.Transpiler({ loader: "ts" });
+    return transpiler.transformSync(code);
+  },
+};

package/src/compat/index.ts

@@ -0,0 +1,29 @@
+import type { CompatDatabase, CompatOps } from "./types";
+
+export type { CompatDatabase, CompatStatement, CompatOps } from "./types";
+
+let ops: CompatOps | null = null;
+
+export function initCompat(compatOps: CompatOps): void {
+  if (ops) {
+    console.warn("initCompat called multiple times — overwriting previous compat ops");
+  }
+  ops = compatOps;
+}
+
+function getOps(): CompatOps {
+  if (!ops) {
+    throw new Error(
+      "compat not initialized — call initCompat() before using createDatabase or transpileTS"
+    );
+  }
+  return ops;
+}
+
+export function createDatabase(path: string): CompatDatabase {
+  return getOps().createDatabase(path);
+}
+
+export function transpileTS(code: string): string {
+  return getOps().transpileTS(code);
+}

package/src/compat/node.ts

@@ -0,0 +1,62 @@
+import { createRequire } from "node:module";
+import type { CompatDatabase, CompatOps, CompatStatement } from "./types";
+
+const require = createRequire(import.meta.url);
+
+function getBetterSqlite3(): any {
+  try {
+    return require("better-sqlite3");
+  } catch {
+    throw new Error(
+      "better-sqlite3 is required for Node.js. Install it: npm install better-sqlite3"
+    );
+  }
+}
+
+function getEsbuild(): any {
+  try {
+    return require("esbuild");
+  } catch {
+    throw new Error(
+      "esbuild is required for Node.js. Install it: npm install esbuild"
+    );
+  }
+}
+
+function wrapStatement(stmt: any): CompatStatement {
+  return {
+    run(...params: unknown[]) {
+      const result = stmt.run(...params);
+      return { changes: result.changes };
+    },
+    all(...params: unknown[]) {
+      return stmt.all(...params) as unknown[];
+    },
+  };
+}
+
+function wrapDatabase(db: any): CompatDatabase {
+  return {
+    exec(sql: string) {
+      db.exec(sql);
+    },
+    prepare(sql: string) {
+      return wrapStatement(db.prepare(sql));
+    },
+    close() {
+      db.close();
+    },
+  };
+}
+
+export const nodeCompat: CompatOps = {
+  createDatabase(path: string): CompatDatabase {
+    const BetterSqlite3 = getBetterSqlite3();
+    return wrapDatabase(new BetterSqlite3(path));
+  },
+
+  transpileTS(code: string): string {
+    const esbuild = getEsbuild();
+    return esbuild.transformSync(code, { loader: "ts" }).code;
+  },
+};

package/src/compat/types.ts

@@ -0,0 +1,15 @@
+export interface CompatStatement {
+  run(...params: unknown[]): { changes: number };
+  all(...params: unknown[]): unknown[];
+}
+
+export interface CompatDatabase {
+  exec(sql: string): void;
+  prepare(sql: string): CompatStatement;
+  close(): void;
+}
+
+export interface CompatOps {
+  createDatabase(path: string): CompatDatabase;
+  transpileTS(code: string): string;
+}

package/src/debug-server.ts

@@ -0,0 +1,232 @@
+#!/usr/bin/env bun
+/**
+ * Debug Server - WebSocket UI for Testing
+ *
+ * Provides a web-based interface for testing Tana API scripts.
+ * Run with: bun run src/debug-server.ts
+ * Open: http://localhost:3333
+ *
+ * In dev mode, proxies to Vite for hot-reload and dynamic glob resolution.
+ */
+
+import { initCompat } from "./compat";
+import { bunCompat } from "./compat/bun";
+import { createClient } from "./api/client";
+import { createTanaAPI } from "./api/tana";
+import { executeSandbox } from "./sandbox/executor";
+import { getWorkflowEvents, getRecentWorkflows } from "./sandbox/workflow";
+import { initDb } from "./storage/history";
+import { spawn, type Subprocess } from "bun";
+
+const PORT = parseInt(process.env.DEBUG_PORT || "3333", 10);
+const VITE_PORT = 5188; // Use unique port to avoid conflicts
+let viteProcess: Subprocess | null = null;
+
+interface ExecuteRequest {
+  type: "execute";
+  code: string;
+  sessionId?: string;
+  input?: string;
+}
+
+interface GetWorkflowRequest {
+  type: "getWorkflow";
+  sessionId: string;
+}
+
+interface ListWorkflowsRequest {
+  type: "listWorkflows";
+  limit?: number;
+}
+
+type WebSocketMessage = ExecuteRequest | GetWorkflowRequest | ListWorkflowsRequest;
+
+async function startVite(): Promise<void> {
+  console.log("Starting Vite dev server...");
+
+  viteProcess = spawn({
+    cmd: ["bunx", "vite", "--port", String(VITE_PORT), "--strictPort"],
+    cwd: "./ui",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  // Wait for Vite to be ready
+  const maxAttempts = 30;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const res = await fetch(`http://localhost:${VITE_PORT}`, { method: "HEAD" });
+      if (res.ok) {
+        console.log("Vite dev server ready");
+        return;
+      }
+    } catch {
+      // Not ready yet
+    }
+    await Bun.sleep(200);
+  }
+  console.warn("Vite may not be fully ready, continuing anyway...");
+}
+
+async function proxyToVite(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const viteUrl = `http://localhost:${VITE_PORT}${url.pathname}${url.search}`;
+
+  try {
+    const proxyReq = new Request(viteUrl, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+    });
+    return await fetch(proxyReq);
+  } catch (e) {
+    return new Response(`Vite proxy error: ${e}`, { status: 502 });
+  }
+}
+
+async function main() {
+  initCompat(bunCompat);
+  initDb();
+
+  // Start Vite dev server for dynamic glob resolution
+  await startVite();
+
+  let tana: ReturnType<typeof createTanaAPI> | null = null;
+  let clientError: string | null = null;
+
+  try {
+    const client = createClient();
+    tana = createTanaAPI(client);
+  } catch (e) {
+    clientError = e instanceof Error ? e.message : String(e);
+    console.error("Warning: Could not create Tana client:", clientError);
+  }
+
+  const server = Bun.serve({
+    port: PORT,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+
+      if (url.pathname === "/ws") {
+        const upgraded = server.upgrade(req);
+        if (!upgraded) {
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        return undefined;
+      }
+
+      if (url.pathname === "/health") {
+        return Response.json({ status: "ok", tanaConnected: !!tana, clientError });
+      }
+
+      // Proxy everything else to Vite dev server
+      return proxyToVite(req);
+    },
+
+    websocket: {
+      async message(ws, message) {
+        try {
+          const data = JSON.parse(String(message)) as WebSocketMessage;
+
+          switch (data.type) {
+            case "execute": {
+              if (!tana) {
+                ws.send(JSON.stringify({
+                  type: "error",
+                  error: clientError || "Tana client not initialized",
+                }));
+                return;
+              }
+
+              const sessionId = data.sessionId || crypto.randomUUID();
+              ws.send(JSON.stringify({ type: "started", sessionId }));
+
+              const result = await executeSandbox(
+                data.code,
+                tana,
+                sessionId
+              );
+
+              const events = getWorkflowEvents(sessionId);
+
+              ws.send(JSON.stringify({
+                type: "result",
+                sessionId,
+                ...result,
+                workflowEvents: events,
+              }));
+              break;
+            }
+
+            case "getWorkflow": {
+              const events = getWorkflowEvents(data.sessionId);
+              ws.send(JSON.stringify({
+                type: "workflow",
+                sessionId: data.sessionId,
+                events,
+              }));
+              break;
+            }
+
+            case "listWorkflows": {
+              const workflows = getRecentWorkflows(data.limit ?? 20);
+              ws.send(JSON.stringify({
+                type: "workflows",
+                workflows,
+              }));
+              break;
+            }
+
+            default:
+              ws.send(JSON.stringify({
+                type: "error",
+                error: "Unknown message type",
+              }));
+          }
+        } catch (e) {
+          ws.send(JSON.stringify({
+            type: "error",
+            error: e instanceof Error ? e.message : String(e),
+          }));
+        }
+      },
+
+      open(ws) {
+        console.log("Client connected");
+        ws.send(JSON.stringify({
+          type: "connected",
+          tanaConnected: !!tana,
+          clientError,
+        }));
+      },
+
+      close() {
+        console.log("Client disconnected");
+      },
+    },
+  });
+
+  console.log(`Debug server running at http://localhost:${PORT}`);
+  console.log(`WebSocket endpoint: ws://localhost:${PORT}/ws`);
+  console.log(`Vite dev server: http://localhost:${VITE_PORT} (proxied)`);
+  if (clientError) {
+    console.log(`Warning: ${clientError}`);
+  }
+
+  // Cleanup on shutdown
+  const cleanup = () => {
+    if (viteProcess) {
+      console.log("Stopping Vite dev server...");
+      viteProcess.kill();
+    }
+    process.exit(0);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/entry-bun.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+import { initCompat } from "./compat";
+import { bunCompat } from "./compat/bun";
+import { main } from "./main";
+
+initCompat(bunCompat);
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/entry-node.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { initCompat } from "./compat/index.js";
+import { nodeCompat } from "./compat/node.js";
+import { main } from "./main.js";
+
+initCompat(nodeCompat);
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/index.ts

@@ -1,167 +1,10 @@
 #!/usr/bin/env bun
-/**
- * Tana MCP Server - Entry Point
- *
- * Codemode MCP server for Tana knowledge management.
- * AI writes TypeScript code that executes against the Tana Local API.
- */
+// Backward-compat shim — use src/entry-bun.ts directly
+import { initCompat } from "./compat";
+import { bunCompat } from "./compat/bun";
+import { main } from "./main";
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-import { createClient } from "./api/client";
-import { createTanaAPI } from "./api/tana";
-import type { TanaClient } from "./api/client";
-import type { Workspace } from "./api/types";
-import { executeSandbox } from "./sandbox/executor";
-import { cleanupOldRuns, initDb } from "./storage/history";
-import { TOOL_DESCRIPTION } from "./prompts";
-
-/**
- * Resolves the default workspace from MAIN_TANA_WORKSPACE env var.
- * Matches by ID first, then case-insensitive name.
- * Returns null if unset, unmatched, or API unreachable.
- */
-async function resolveWorkspace(client: TanaClient): Promise<Workspace | null> {
-  const envValue = process.env.MAIN_TANA_WORKSPACE?.trim();
-  if (!envValue) return null;
-
-  let workspaces: Workspace[];
-  try {
-    workspaces = await client.get<Workspace[]>("/workspaces");
-  } catch (err) {
-    console.error(
-      `[workspace] Failed to fetch workspaces: ${err instanceof Error ? err.message : err}`
-    );
-    return null;
-  }
-
-  const byId = workspaces.find((w) => w.id === envValue);
-  if (byId) {
-    console.error(`[workspace] Resolved "${envValue}" → ${byId.name} (${byId.id})`);
-    return byId;
-  }
-
-  const lowerEnv = envValue.toLowerCase();
-  const byName = workspaces.find((w) => w.name.toLowerCase() === lowerEnv);
-  if (byName) {
-    console.error(`[workspace] Resolved "${envValue}" → ${byName.name} (${byName.id})`);
-    return byName;
-  }
-
-  const available = workspaces.map((w) => `${w.name} (${w.id})`).join(", ");
-  console.error(
-    `[workspace] No match for "${envValue}". Available: ${available || "none"}`
-  );
-  return null;
-}
-
-/**
- * Resolves TANA_SEARCH_WORKSPACES env var to an array of workspace IDs.
- * Each value can be an ID or case-insensitive name.
- * Unresolved values are logged and skipped.
- */
-async function resolveSearchWorkspaces(client: TanaClient): Promise<string[]> {
-  const envValue = process.env.TANA_SEARCH_WORKSPACES?.trim();
-  if (!envValue) return [];
-
-  const values = envValue.split(",").map((v) => v.trim()).filter(Boolean);
-  if (values.length === 0) return [];
-
-  let workspaces: Workspace[];
-  try {
-    workspaces = await client.get<Workspace[]>("/workspaces");
-  } catch (err) {
-    console.error(
-      `[search-workspaces] Failed to fetch workspaces: ${err instanceof Error ? err.message : err}`
-    );
-    return [];
-  }
-
-  const resolvedIds: string[] = [];
-  for (const value of values) {
-    const byId = workspaces.find((w) => w.id === value);
-    if (byId) {
-      resolvedIds.push(byId.id);
-      console.error(`[search-workspaces] Resolved "${value}" → ${byId.name} (${byId.id})`);
-      continue;
-    }
-    const lowerValue = value.toLowerCase();
-    const byName = workspaces.find((w) => w.name.toLowerCase() === lowerValue);
-    if (byName) {
-      resolvedIds.push(byName.id);
-      console.error(`[search-workspaces] Resolved "${value}" → ${byName.name} (${byName.id})`);
-      continue;
-    }
-    const available = workspaces.map((w) => `${w.name} (${w.id})`).join(", ");
-    console.error(
-      `[search-workspaces] No match for "${value}". Available: ${available || "none"}`
-    );
-  }
-
-  return resolvedIds;
-}
-
-async function main() {
-  initDb();
-  const cleaned = cleanupOldRuns(30);
-  if (cleaned > 0) {
-    console.error(`Cleaned up ${cleaned} old script runs`);
-  }
-
-  const client = createClient();
-  const workspace = await resolveWorkspace(client);
-  const searchWorkspaceIds = await resolveSearchWorkspaces(client);
-  const tana = createTanaAPI(client, workspace, searchWorkspaceIds);
-
-  const server = new McpServer({
-    name: "tana-mcp-codemode",
-    version: "0.1.0",
-  });
-
-  server.registerTool(
-    "execute",
-    {
-      description: TOOL_DESCRIPTION,
-      inputSchema: {
-        code: z.string().describe("TypeScript code to execute"),
-        sessionId: z
-          .string()
-          .optional()
-          .describe("Optional session ID for grouping script runs"),
-      },
-    },
-    async ({ code, sessionId }) => {
-      const result = await executeSandbox(code, tana, sessionId);
-
-      let responseText = "";
-      if (result.output) {
-        responseText += result.output;
-      }
-      if (result.error) {
-        responseText += responseText ? "\n\n" : "";
-        responseText += `Error: ${result.error}`;
-      }
-      responseText += `\n\n[Executed in ${result.durationMs}ms]`;
-
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: responseText,
-          },
-        ],
-        isError: !result.success,
-      };
-    }
-  );
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-
-  console.error("Tana MCP server started");
-}
+initCompat(bunCompat);
 
 main().catch((error) => {
   console.error("Fatal error:", error);