tana-mcp-codemode 0.2.3 → 0.3.0

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/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
 
@@ -192,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)
   `);

package/src/storage/history.ts

@@ -8,13 +8,13 @@
  * Configure database location via TANA_HISTORY_PATH env var.
  */
 
-import { Database } from "bun:sqlite";
+import { createDatabase, type CompatDatabase } from "../compat";
 import { homedir } from "os";
 import { join, dirname } from "path";
 import { mkdirSync, existsSync } from "fs";
 import type { ScriptRun } from "../types";
 
-let db: Database | null = null;
+let db: CompatDatabase | null = null;
 
 function getDbPath(): string {
   // Allow custom path via env var
@@ -46,7 +46,7 @@ function getDbPath(): string {
   return join(baseDir, "history.db");
 }
 
-function migrateDb(database: Database): void {
+function migrateDb(database: CompatDatabase): void {
   // Get existing columns
   const columns = database
     .prepare("PRAGMA table_info(script_runs)")
@@ -63,18 +63,18 @@ function migrateDb(database: Database): void {
 
   for (const col of newColumns) {
     if (!columnNames.has(col.name)) {
-      database.run(`ALTER TABLE script_runs ADD COLUMN ${col.name} ${col.type}`);
+      database.exec(`ALTER TABLE script_runs ADD COLUMN ${col.name} ${col.type}`);
     }
   }
 }
 
-export function initDb(): Database {
+export function initDb(): CompatDatabase {
   if (db) return db;
 
   const dbPath = getDbPath();
-  db = new Database(dbPath, { create: true });
+  db = createDatabase(dbPath);
 
-  db.run(`
+  db.exec(`
     CREATE TABLE IF NOT EXISTS script_runs (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       timestamp INTEGER NOT NULL,
@@ -94,22 +94,22 @@ export function initDb(): Database {
   // Migrate existing databases
   migrateDb(db);
 
-  db.run(`
+  db.exec(`
     CREATE INDEX IF NOT EXISTS idx_script_runs_timestamp
     ON script_runs(timestamp DESC)
   `);
 
-  db.run(`
+  db.exec(`
     CREATE INDEX IF NOT EXISTS idx_script_runs_session
     ON script_runs(session_id)
   `);
 
-  db.run(`
+  db.exec(`
     CREATE INDEX IF NOT EXISTS idx_script_runs_workspace
     ON script_runs(workspace_id)
   `);
 
-  return db;
+  return db!;
 }
 
 export interface SaveScriptRunOptions {