@tempo-ai/mcp 0.0.100-staging.1

package/dist/chunk-JDPG7F4Z.js

@@ -0,0 +1,688 @@
+import { createRequire as __tempoCreateRequire } from 'node:module'; const require = __tempoCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../mcp-runtime/auth/token-store.ts
+import fs from "fs";
+import fsp from "fs/promises";
+import path2 from "path";
+
+// ../mcp-runtime/paths.ts
+import os from "os";
+import path from "path";
+function tempoHome() {
+  return process.env.TEMPO_MCP_HOME ?? path.join(os.homedir(), ".tempo");
+}
+function authFilePath() {
+  return path.join(tempoHome(), "auth.json");
+}
+function logsDir() {
+  return path.join(tempoHome(), "logs");
+}
+function logFilePath(binaryName) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return path.join(logsDir(), `mcp-${binaryName}-${date}.log`);
+}
+
+// ../mcp-runtime/auth/token-store.ts
+async function readAuth() {
+  try {
+    const raw = await fsp.readFile(authFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.token === "string" && typeof parsed.sessionId === "string" && typeof parsed.userId === "string" && typeof parsed.expiresAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    return null;
+  }
+}
+function readAuthSync() {
+  try {
+    const raw = fs.readFileSync(authFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.token === "string" && typeof parsed.sessionId === "string" && typeof parsed.userId === "string" && typeof parsed.expiresAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function writeAuth(auth) {
+  const dir = tempoHome();
+  await fsp.mkdir(dir, { recursive: true, mode: 448 });
+  const target = authFilePath();
+  const tmp = path2.join(dir, `auth.json.tmp.${process.pid}.${Date.now()}`);
+  const data = JSON.stringify(auth, null, 2);
+  await fsp.writeFile(tmp, data, { mode: 384 });
+  await fsp.rename(tmp, target);
+  try {
+    await fsp.chmod(target, 384);
+  } catch {
+  }
+}
+async function clearAuth() {
+  try {
+    await fsp.unlink(authFilePath());
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+// ../mcp-runtime/auth/refresh-loop.ts
+function createRefreshLoop(opts) {
+  const leadMs = opts.refreshLeadMs ?? 6e4;
+  const retryDelay = opts.retryDelayMs ?? 5e3;
+  const maxRetries = opts.maxRetries ?? 3;
+  let timer = null;
+  let stopped = false;
+  async function refreshNow() {
+    const current = await readAuth();
+    if (!current) {
+      opts.onReauthRequired();
+      return null;
+    }
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const res = await fetch(`${opts.convexSiteUrl}/auth/refresh`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ sessionId: current.sessionId })
+        });
+        if (res.status === 401) {
+          await clearAuth();
+          opts.onReauthRequired();
+          return null;
+        }
+        if (!res.ok) {
+          if (attempt < maxRetries) {
+            await sleep(retryDelay * Math.pow(1.5, attempt));
+            continue;
+          }
+          opts.onReauthRequired();
+          return null;
+        }
+        const body = await res.json();
+        if (!body.token) {
+          opts.onReauthRequired();
+          return null;
+        }
+        const next = {
+          ...current,
+          token: body.token,
+          expiresAt: decodeJwtExp(body.token)
+        };
+        await writeAuth(next);
+        return body.token;
+      } catch (err) {
+        if (attempt < maxRetries) {
+          await sleep(retryDelay * Math.pow(1.5, attempt));
+          continue;
+        }
+        opts.onReauthRequired();
+        return null;
+      }
+    }
+    return null;
+  }
+  function schedule(auth) {
+    if (timer) clearTimeout(timer);
+    if (stopped) return;
+    const delay = Math.max(0, auth.expiresAt - Date.now() - leadMs);
+    timer = setTimeout(() => {
+      void refreshNow().then((newToken) => {
+        if (newToken && !stopped) {
+          void readAuth().then((a) => {
+            if (a) schedule(a);
+          });
+        }
+      });
+    }, delay);
+  }
+  function start() {
+    stopped = false;
+    void readAuth().then((auth) => {
+      if (auth) schedule(auth);
+    });
+  }
+  function stop() {
+    stopped = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  return { start, stop, refreshNow };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function decodeJwtExp(jwt) {
+  try {
+    const [, payload] = jwt.split(".");
+    const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    if (typeof decoded.exp === "number") return decoded.exp * 1e3;
+  } catch {
+  }
+  return Date.now() + 5 * 6e4;
+}
+
+// ../mcp-runtime/auth/auth-provider.ts
+function createAuthProvider(refreshLoop) {
+  return {
+    async getToken() {
+      const auth = await readAuth();
+      if (!auth) {
+        throw new Error(
+          "Not authenticated. Run `tempo-mcp login` (or sign in via Tempo)."
+        );
+      }
+      if (auth.expiresAt - Date.now() < 3e4) {
+        const newToken = await refreshLoop.refreshNow();
+        if (newToken) {
+          const fresh = await readAuth();
+          if (fresh) {
+            return { jwt: fresh.token, expiresAt: fresh.expiresAt };
+          }
+        }
+        throw new Error(
+          "Tempo session expired. Run `tempo-mcp login` to sign in again."
+        );
+      }
+      return { jwt: auth.token, expiresAt: auth.expiresAt };
+    }
+  };
+}
+
+// ../mcp-runtime/auth/browser-flow.ts
+import http from "http";
+async function startBrowserAuthFlow(opts = {}) {
+  const authUrl = opts.authUrl ?? "https://auth.tempo.build";
+  const timeoutMs = opts.timeoutMs ?? 10 * 6e4;
+  const bindAddress = opts.bindAddress ?? "127.0.0.1";
+  let resolveDone;
+  let rejectDone;
+  const done = new Promise((resolve, reject) => {
+    resolveDone = resolve;
+    rejectDone = reject;
+  });
+  const server = http.createServer(async (req, res) => {
+    if (req.method === "POST" && req.url && req.url.startsWith("/tempo/auth")) {
+      try {
+        const body = await readJson(req);
+        if (!body || typeof body.token !== "string" || typeof body.sessionId !== "string" || typeof body.userId !== "string") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "missing fields" }));
+          return;
+        }
+        await writeAuth({
+          token: body.token,
+          sessionId: body.sessionId,
+          userId: body.userId,
+          email: typeof body.email === "string" ? body.email : void 0,
+          firstName: typeof body.firstName === "string" ? body.firstName : void 0,
+          lastName: typeof body.lastName === "string" ? body.lastName : void 0,
+          expiresAt: decodeJwtExp(body.token),
+          lastOrgId: typeof body.orgId === "string" ? body.orgId : null
+        });
+        res.writeHead(200, {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.end(JSON.stringify({ ok: true }));
+        setImmediate(() => {
+          server.close();
+          resolveDone();
+        });
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+      }
+      return;
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      });
+      res.end();
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port ?? 0, bindAddress, () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("Failed to bind callback listener");
+  }
+  const callbackPort = address.port;
+  const signInUrl = `${authUrl}/sign-in?callbackPort=${callbackPort}`;
+  const timeoutTimer = setTimeout(() => {
+    server.close();
+    rejectDone(new Error(`Sign-in timeout after ${timeoutMs}ms`));
+  }, timeoutMs);
+  if (typeof timeoutTimer.unref === "function") timeoutTimer.unref();
+  done.finally(() => clearTimeout(timeoutTimer)).catch(() => {
+  });
+  return {
+    signInUrl,
+    callbackPort,
+    done,
+    cancel: () => {
+      server.close();
+      rejectDone(new Error("Sign-in cancelled"));
+    }
+  };
+}
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      raw += chunk;
+      if (raw.length > 1e6) {
+        req.destroy();
+        reject(new Error("payload too large"));
+      }
+    });
+    req.on("end", () => {
+      if (!raw) return resolve(null);
+      try {
+        resolve(JSON.parse(raw));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// ../mcp-runtime/aggregate/aggregator.ts
+import { randomUUID } from "crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var BACKEND_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
+async function createAggregateServer(options) {
+  const {
+    name,
+    version,
+    instructions,
+    backends,
+    filterTool,
+    injectParams,
+    onScopedCall
+  } = options;
+  const connected = [];
+  for (const backend of backends) {
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({
+      name: `${name}-aggregator`,
+      version
+    });
+    await backend.server.connect(serverTransport);
+    await client.connect(clientTransport);
+    connected.push({ ...backend, client });
+  }
+  const toolRoutes = /* @__PURE__ */ new Map();
+  const injectedByTool = /* @__PURE__ */ new Map();
+  const toolsByBackend = /* @__PURE__ */ new Map();
+  for (const backend of connected) {
+    if (!backend.client.getServerCapabilities()?.tools) {
+      toolsByBackend.set(backend.toolset, []);
+      continue;
+    }
+    const listed = await backend.client.listTools();
+    const kept = [];
+    for (const tool of listed.tools) {
+      if (filterTool && !filterTool(backend.toolset, tool.name)) continue;
+      const existing = toolRoutes.get(tool.name);
+      if (existing) {
+        throw new Error(
+          `MCP aggregate tool name collision: "${tool.name}" registered by both "${existing.toolset}" and "${backend.toolset}"`
+        );
+      }
+      toolRoutes.set(tool.name, backend);
+      const injected = injectParams?.(backend.toolset, tool.name) ?? [];
+      if (injected.length === 0) {
+        kept.push(tool);
+        continue;
+      }
+      injectedByTool.set(tool.name, injected);
+      const schema = tool.inputSchema ?? { type: "object" };
+      kept.push({
+        ...tool,
+        inputSchema: {
+          ...schema,
+          type: "object",
+          properties: {
+            ...schema.properties ?? {},
+            ...Object.fromEntries(
+              injected.map((param) => [
+                param.name,
+                { type: "string", description: param.description }
+              ])
+            )
+          },
+          required: [
+            .../* @__PURE__ */ new Set([
+              ...schema.required ?? [],
+              ...injected.map((param) => param.name)
+            ])
+          ]
+        }
+      });
+    }
+    toolsByBackend.set(backend.toolset, kept);
+  }
+  const server = new Server(
+    { name, version },
+    {
+      capabilities: { tools: {}, resources: {} },
+      instructions
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: connected.flatMap(
+      (backend) => toolsByBackend.get(backend.toolset) ?? []
+    )
+  }));
+  let callChain = Promise.resolve();
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const backend = toolRoutes.get(toolName);
+    if (!backend) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: {
+                code: "unknown_tool",
+                message: `No registered tool named "${toolName}"`
+              }
+            })
+          }
+        ]
+      };
+    }
+    const args = {
+      ...request.params.arguments ?? {}
+    };
+    const injected = injectedByTool.get(toolName) ?? [];
+    const scopeValues = {};
+    for (const param of injected) {
+      const value = args[param.name];
+      delete args[param.name];
+      if (typeof value !== "string" || value.length === 0) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: {
+                  code: "missing_scope_param",
+                  message: `"${toolName}" requires "${param.name}". ${param.description}`
+                }
+              })
+            }
+          ]
+        };
+      }
+      scopeValues[param.name] = value;
+    }
+    const run = callChain.then(async () => {
+      if (injected.length > 0) onScopedCall?.(scopeValues);
+      const requestId = randomUUID();
+      backend.onRequestStart?.(requestId);
+      try {
+        return await backend.client.callTool(
+          { name: toolName, arguments: args },
+          void 0,
+          { timeout: BACKEND_CALL_TIMEOUT_MS }
+        );
+      } finally {
+        backend.onRequestEnd?.(requestId);
+      }
+    });
+    callChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  });
+  const listResourcesForBackend = async (backend) => {
+    const caps = backend.client.getServerCapabilities();
+    if (!caps?.resources) return [];
+    const listed = await backend.client.listResources();
+    return listed.resources;
+  };
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const all = await Promise.all(connected.map(listResourcesForBackend));
+    return { resources: all.flat() };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    for (const backend of connected) {
+      const resources = await listResourcesForBackend(backend);
+      if (resources.some((resource) => resource.uri === uri)) {
+        return backend.client.readResource({ uri });
+      }
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+  return {
+    server,
+    connect: (transport) => server.connect(transport),
+    dispose: async () => {
+      for (const backend of connected) {
+        await backend.client.close().catch(() => {
+        });
+        backend.dispose?.();
+      }
+      await server.close().catch(() => {
+      });
+    }
+  };
+}
+
+// ../mcp-runtime/safety/process-handlers.ts
+import fs2 from "fs";
+import fsp2 from "fs/promises";
+import path3 from "path";
+function installProcessSafety(opts = {}) {
+  const binaryName = opts.binaryName ?? path3.basename(process.argv[1] ?? "tempo-mcp");
+  const logError = (label, err) => {
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${label}: ${err instanceof Error ? err.stack || err.message : String(err)}
+`;
+    try {
+      fs2.mkdirSync(logsDir(), { recursive: true, mode: 448 });
+      fs2.appendFileSync(logFilePath(binaryName), line, { mode: 384 });
+    } catch {
+      try {
+        process.stderr.write(line);
+      } catch {
+      }
+    }
+  };
+  const onUncaught = (err) => logError("uncaughtException", err);
+  const onUnhandled = (reason) => logError("unhandledRejection", reason);
+  process.on("uncaughtException", onUncaught);
+  process.on("unhandledRejection", onUnhandled);
+  const stdoutError = (err) => {
+    if (err.code !== "EPIPE") logError("stdout-error", err);
+  };
+  process.stdout.on("error", stdoutError);
+  const onSignal = (signal) => {
+    Promise.resolve(opts.onShutdown?.()).catch((err) => logError(`shutdown:${signal}`, err)).finally(() => {
+      setTimeout(() => process.exit(0), 50);
+    });
+  };
+  process.once("SIGTERM", () => onSignal("SIGTERM"));
+  process.once("SIGINT", () => onSignal("SIGINT"));
+  return () => {
+    process.off("uncaughtException", onUncaught);
+    process.off("unhandledRejection", onUnhandled);
+    process.stdout.off("error", stdoutError);
+  };
+}
+
+// ../mcp-runtime/elicitation/auth-elicitation.ts
+async function requestAuthElicitation(opts = {}) {
+  const handle = await startBrowserAuthFlow({
+    authUrl: opts.authUrl,
+    timeoutMs: opts.timeoutMs ?? 5 * 6e4
+  });
+  return {
+    signInUrl: handle.signInUrl,
+    waitForSignIn: () => handle.done,
+    cancel: () => handle.cancel()
+  };
+}
+async function ensureAuth(opts = {}) {
+  const existing = await readAuth();
+  if (existing && existing.expiresAt - Date.now() > 6e4) {
+    return { hadExistingAuth: true };
+  }
+  const eli = await requestAuthElicitation(opts);
+  await eli.waitForSignIn();
+  return { hadExistingAuth: false, signInUrl: eli.signInUrl };
+}
+
+// ../mcp-runtime/transport/pin-interceptor.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/config.ts
+import fs3 from "fs";
+import path4 from "path";
+var DEFAULT_CONVEX_URL = "https://greedy-jackal-526.convex.cloud";
+function resolveConvexUrl() {
+  return process.env.TEMPO_CONVEX_URL ?? DEFAULT_CONVEX_URL;
+}
+function resolveConvexSiteUrl(convexUrl) {
+  const explicit = process.env.TEMPO_CONVEX_SITE_URL;
+  if (explicit) return explicit;
+  return convexUrl.replace(/\.convex\.cloud$/, ".convex.site");
+}
+var ALL_TOOLSETS = [
+  "issues",
+  "docs",
+  "comments",
+  "agents",
+  "scripts",
+  "slack",
+  "linear",
+  "canvas"
+];
+function parseServeArgs(args) {
+  let toolsets = [...ALL_TOOLSETS];
+  let readonly = process.env.TEMPO_MCP_READONLY === "1";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--readonly") {
+      readonly = true;
+    } else if (arg === "--toolsets") {
+      const value = args[++i];
+      if (!value) return { error: "--toolsets requires a comma-separated list" };
+      const requested = value.split(",").map((t) => t.trim()).filter(Boolean);
+      const unknown = requested.filter(
+        (t) => !ALL_TOOLSETS.includes(t)
+      );
+      if (unknown.length) {
+        return {
+          error: `Unknown toolset(s): ${unknown.join(", ")}. Valid: ${ALL_TOOLSETS.join(", ")}`
+        };
+      }
+      toolsets = requested;
+    } else {
+      return { error: `Unknown flag: ${arg}` };
+    }
+  }
+  return { toolsets, readonly };
+}
+function discoverWorkspace(startDir = process.cwd()) {
+  let dir = path4.resolve(startDir);
+  for (; ; ) {
+    const configPath = path4.join(dir, "tempo", "tempo.config.json");
+    if (fs3.existsSync(configPath)) {
+      let canvasesRel = "./designs";
+      try {
+        const parsed = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+        if (parsed.paths?.canvases) canvasesRel = parsed.paths.canvases;
+      } catch {
+      }
+      return {
+        workspaceRoot: dir,
+        canvasesDir: path4.resolve(dir, "tempo", canvasesRel)
+      };
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  readAuth,
+  readAuthSync,
+  clearAuth,
+  createRefreshLoop,
+  createAuthProvider,
+  startBrowserAuthFlow,
+  createAggregateServer,
+  installProcessSafety,
+  ensureAuth,
+  resolveConvexUrl,
+  resolveConvexSiteUrl,
+  parseServeArgs,
+  discoverWorkspace
+};
+//# sourceMappingURL=chunk-JDPG7F4Z.js.map