tana-mcp-codemode 0.2.2 → 0.3.0

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);

package/src/main.ts

@@ -0,0 +1,146 @@
+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";
+
+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;
+}
+
+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;
+}
+
+export 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");
+}

package/src/prompts.ts

@@ -28,8 +28,9 @@ tana.tags.addField({ tagId, name, dataType: "plain"|"number"|"date"|"url"|"email
 tana.tags.setCheckbox({ tagId, showCheckbox, doneStateMapping? })
 
 ### Fields
-tana.fields.setOption(nodeId, attributeId, optionId, mode?)  // mode: "replace" | "append" (default: "replace")
+tana.fields.setOption(nodeId, attributeId, optionId)  // optionId: string | string[] (array for multi-value)
 tana.fields.setContent(nodeId, attributeId, content, mode?)  // content: string | null (null clears field), mode: "replace" | "append"
+tana.fields.getFieldOptions(fieldId, options?) → { id, name }[]  // discover available options for a field
 
 ### Calendar
 tana.calendar.getOrCreate(workspaceId, "day"|"week"|"month"|"year", date?)

package/src/sandbox/executor.ts

@@ -13,6 +13,7 @@ import type { SandboxResult } from "../types";
 import type { TanaAPI } from "../api/tana";
 import { saveScriptRun } from "../storage/history";
 import { createWorkflowHelper } from "./workflow";
+import { transpileTS } from "../compat";
 
 const EXECUTION_TIMEOUT = 10_000; // 10 seconds
 
@@ -110,6 +111,8 @@ function createTrackedTanaAPI(
         trackNodeId(nodeId);
         return track("fields.setContent", () => tana.fields.setContent(nodeId, attributeId, content));
       },
+      getFieldOptions: (...args) =>
+        track("fields.getFieldOptions", () => tana.fields.getFieldOptions(...args)),
     },
 
     calendar: {
@@ -190,8 +193,7 @@ export async function executeSandbox(
       "exports",
     ];
 
-    const transpiler = new Bun.Transpiler({ loader: "ts" });
-    const jsCode = transpiler.transformSync(code);
+    const jsCode = transpileTS(code);
 
     const fn = new AsyncFunction(
       "tana",

package/src/sandbox/workflow.ts

@@ -11,7 +11,7 @@
  *   workflow.complete("Done!");
  */
 
-import { Database } from "bun:sqlite";
+import type { CompatDatabase } from "../compat";
 import { initDb } from "../storage/history";
 
 export type WorkflowEventType =
@@ -45,10 +45,10 @@ export interface WorkflowHelper {
 
 let workflowTableInitialized = false;
 
-function ensureWorkflowTable(db: Database): void {
+function ensureWorkflowTable(db: CompatDatabase): void {
   if (workflowTableInitialized) return;
 
-  db.run(`
+  db.exec(`
     CREATE TABLE IF NOT EXISTS workflow_events (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
@@ -59,7 +59,7 @@ function ensureWorkflowTable(db: Database): void {
     )
   `);
 
-  db.run(`
+  db.exec(`
     CREATE INDEX IF NOT EXISTS idx_workflow_session
     ON workflow_events(session_id, timestamp)
   `);