mcp-pachca 0.3.0 → 0.5.1

package/src/client.ts

@@ -1,130 +0,0 @@
-import { logger } from "./logger.js";
-import type { Session } from "./auth.js";
-
-export class PachcaClient {
-  private readonly baseUrl = "https://app.pachca.com/api/v3";
-  private readonly session: Session;
-
-  constructor(session: Session) {
-    this.session = session;
-  }
-
-  async get<T>(path: string, params?: Record<string, string>): Promise<T> {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined && value !== "") {
-          url.searchParams.set(key, value);
-        }
-      }
-    }
-    return (await this.request<T>("GET", url.toString())) as T;
-  }
-
-  async getWithArrayParams<T>(
-    path: string,
-    arrayParams: Record<string, (string | number)[]>,
-    params?: Record<string, string>,
-  ): Promise<T> {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined && value !== "") {
-          url.searchParams.set(key, value);
-        }
-      }
-    }
-    for (const [key, values] of Object.entries(arrayParams)) {
-      for (const v of values) {
-        url.searchParams.append(`${key}[]`, String(v));
-      }
-    }
-    return (await this.request<T>("GET", url.toString())) as T;
-  }
-
-  async post<T>(path: string, body: unknown): Promise<T | undefined> {
-    return this.request<T>("POST", `${this.baseUrl}${path}`, body);
-  }
-
-  private async request<T>(
-    method: string,
-    url: string,
-    body?: unknown,
-  ): Promise<T | undefined> {
-    logger.debug("Pachca API request", { method, url });
-
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 30_000);
-
-    try {
-      const headers: Record<string, string> = {
-        Authorization: `Bearer ${this.session.workspaceJwt}`,
-        Accept: "application/json",
-        "user-id": String(this.session.profileId),
-      };
-
-      if (this.session.cookies.length > 0) {
-        headers["Cookie"] = this.session.cookies.join("; ");
-      }
-
-      if (body !== undefined) {
-        headers["Content-Type"] = "application/json; charset=utf-8";
-      }
-
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      if (response.status === 204) {
-        return undefined;
-      }
-
-      if (response.status === 401) {
-        await response.text();
-        throw new Error("Session expired. Run: npx mcp-pachca --setup");
-      }
-
-      if (!response.ok) {
-        const rawBody = await response.text();
-        let errorBody: unknown;
-        try {
-          errorBody = JSON.parse(rawBody);
-        } catch {
-          errorBody = rawBody;
-        }
-        logger.error("Pachca API error", {
-          status: response.status,
-          body: errorBody,
-        });
-        throw new Error(
-          `Pachca API error (HTTP ${response.status}): ${JSON.stringify(errorBody)}`,
-        );
-      }
-
-      const rawText = await response.text();
-      let data: T;
-      try {
-        data = JSON.parse(rawText) as T;
-      } catch {
-        throw new Error(
-          `Pachca API returned non-JSON response (HTTP ${response.status}): ${rawText.slice(0, 200)}`,
-        );
-      }
-      if (process.env["DEBUG"]) {
-        logger.debug("Pachca API response", { method, url, body: data });
-      }
-      return data;
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        logger.error("Pachca API request timeout", { url });
-        throw new Error(`Pachca API request timeout: ${url}`);
-      }
-      throw err;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-}

package/src/index.ts

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createServer } from "./server.js";
-import { loadSession } from "./auth.js";
-import { logger } from "./logger.js";
-import { runSetup } from "./setup.js";
-
-async function main(): Promise<void> {
-  if (process.argv[2] === "--setup") {
-    await runSetup();
-    process.exit(0);
-  }
-
-  const session = loadSession();
-  if (!session) {
-    logger.error("No session found. Run: npx mcp-pachca --setup");
-    process.exit(1);
-  }
-
-  const server = createServer(session);
-  const transport = new StdioServerTransport();
-
-  const shutdown = async (signal: string): Promise<void> => {
-    logger.info(`Received ${signal}, shutting down`);
-    await server.close();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", () =>
-    shutdown("SIGINT").catch((err) => {
-      logger.error("Error during shutdown", { error: String(err) });
-      process.exit(1);
-    }),
-  );
-  process.on("SIGTERM", () =>
-    shutdown("SIGTERM").catch((err) => {
-      logger.error("Error during shutdown", { error: String(err) });
-      process.exit(1);
-    }),
-  );
-
-  await server.connect(transport);
-  logger.info("MCP Pachca server started");
-}
-
-main().catch((err: unknown) => {
-  logger.error("Fatal error", err);
-  process.exit(1);
-});

package/src/logger.ts

@@ -1,33 +0,0 @@
-export interface Logger {
-  info(message: string, data?: unknown): void;
-  warn(message: string, data?: unknown): void;
-  error(message: string, data?: unknown): void;
-  debug(message: string, data?: unknown): void;
-}
-
-function formatLog(level: string, message: string, data?: unknown): string {
-  const entry: Record<string, unknown> = {
-    ts: new Date().toISOString(),
-    level,
-    msg: message,
-  };
-  if (data !== undefined) {
-    entry["data"] = data;
-  }
-  return JSON.stringify(entry);
-}
-
-export const logger: Logger = {
-  info(message, data) {
-    process.stderr.write(formatLog("info", message, data) + "\n");
-  },
-  warn(message, data) {
-    process.stderr.write(formatLog("warn", message, data) + "\n");
-  },
-  error(message, data) {
-    process.stderr.write(formatLog("error", message, data) + "\n");
-  },
-  debug(message, data) {
-    process.stderr.write(formatLog("debug", message, data) + "\n");
-  },
-};

package/src/server.ts

@@ -1,51 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import type { Session } from "./auth.js";
-import { PachcaClient } from "./client.js";
-import { toolDefinitions } from "./tools/schemas.js";
-import { handlerRegistry } from "./tools/handlers.js";
-import { logger } from "./logger.js";
-
-export function createServer(session: Session): Server {
-  const client = new PachcaClient(session);
-
-  const server = new Server(
-    { name: "mcp-pachca", version: "0.3.0" },
-    { capabilities: { tools: {} } },
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: toolDefinitions,
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const handler = handlerRegistry[name];
-
-    if (!handler) {
-      return {
-        content: [{ type: "text" as const, text: `Unknown tool: ${name}` }],
-        isError: true,
-      };
-    }
-
-    try {
-      const result = await handler(client, (args ?? {}) as Record<string, unknown>);
-      const text = JSON.stringify(result, null, 2) ?? "null";
-      return { content: [{ type: "text" as const, text }] };
-    } catch (err) {
-      logger.error("Tool call failed", { tool: name, error: String(err) });
-      const message =
-        err instanceof Error ? err.message : "Unknown error during tool call";
-      return {
-        content: [{ type: "text" as const, text: message }],
-        isError: true,
-      };
-    }
-  });
-
-  return server;
-}

package/src/setup.ts

@@ -1,201 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import * as rl from "node:readline/promises";
-import { requestOTP, performLogin, saveSession } from "./auth.js";
-
-const CLIENTS = ["Claude Code", "Cursor"] as const;
-type Client = (typeof CLIENTS)[number];
-
-const SCOPES = ["Project", "Global"] as const;
-type Scope = (typeof SCOPES)[number];
-
-function stderr(msg: string): void {
-  process.stderr.write(msg);
-}
-
-function stderrln(msg: string = ""): void {
-  process.stderr.write(msg + "\n");
-}
-
-// --- Prompt helpers ---
-
-/** Collect all lines from a non-TTY stdin upfront (avoids readline buffering issues). */
-function readAllLines(): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    const lines: string[] = [];
-    const iface = rl.createInterface({ input: process.stdin });
-    iface.on("line", (line) => lines.push(line));
-    iface.on("close", () => resolve(lines));
-    iface.on("error", (err) => {
-      iface.close();
-      reject(err);
-    });
-  });
-}
-
-/** Simple line-based prompter backed by a pre-read array (non-TTY). */
-function makePipePrompter(lines: string[]) {
-  let idx = 0;
-  return {
-    ask(question: string): string {
-      stderr(question);
-      if (idx >= lines.length) {
-        stderrln("\nError: not enough input lines.");
-        process.exit(1);
-      }
-      const answer = lines[idx++]!.trim();
-      stderrln(answer);
-      return answer;
-    },
-  };
-}
-
-/** Interactive TTY prompter using readline/promises. */
-function makeTTYPrompter() {
-  const iface = rl.createInterface({ input: process.stdin, output: process.stderr });
-  return {
-    async ask(question: string): Promise<string> {
-      const answer = await iface.question(question);
-      return answer.trim();
-    },
-    close() {
-      iface.close();
-    },
-  };
-}
-
-// --- Choice helper ---
-
-async function askChoice<T extends string>(
-  ask: (q: string) => string | Promise<string>,
-  question: string,
-  choices: readonly T[],
-  retry = true,
-): Promise<T> {
-  stderrln(question);
-  for (let i = 0; i < choices.length; i++) {
-    stderrln(`  ${i + 1}) ${choices[i]}`);
-  }
-  while (true) {
-    const raw = await ask("Enter choice: ");
-    const n = parseInt(raw, 10);
-    if (n >= 1 && n <= choices.length) {
-      return choices[n - 1]!;
-    }
-    if (!retry) {
-      stderrln(`Error: invalid choice "${raw}". Expected a number between 1 and ${choices.length}.`);
-      process.exit(1);
-    }
-    stderrln(`Please enter a number between 1 and ${choices.length}.`);
-  }
-}
-
-// --- Config helpers ---
-
-function resolveConfigPath(client: Client, scope: Scope): string {
-  if (client === "Claude Code") {
-    return scope === "Project"
-      ? path.join(process.cwd(), ".mcp.json")
-      : path.join(os.homedir(), ".mcp.json");
-  }
-  // Cursor
-  return scope === "Project"
-    ? path.join(process.cwd(), ".cursor", "mcp.json")
-    : path.join(os.homedir(), ".cursor", "mcp.json");
-}
-
-function buildEntry(): Record<string, unknown> {
-  const entry: Record<string, unknown> = {
-    type: "stdio",
-    command: "npx",
-    args: ["-y", "mcp-pachca@latest"],
-  };
-  if (process.env["DEBUG"]) {
-    entry["env"] = { DEBUG: "1" };
-  }
-  return entry;
-}
-
-// --- Main ---
-
-export async function runSetup(): Promise<void> {
-  stderrln("mcp-pachca setup wizard\n");
-
-  let client: Client;
-  let scope: Scope;
-  let email: string;
-  let code: string;
-
-  if (!process.stdin.isTTY) {
-    stderrln("Error: --setup requires an interactive terminal (OTP code is sent via email).");
-    process.exit(1);
-  }
-
-  const prompter = makeTTYPrompter();
-  try {
-    client = await askChoice(prompter.ask, "Select your MCP client:", CLIENTS);
-    scope = await askChoice(prompter.ask, "Select config scope:", SCOPES);
-
-    email = await prompter.ask("Enter your Pachca email: ");
-    if (!email || !email.includes("@")) {
-      stderrln("Error: invalid email address.");
-      process.exit(1);
-    }
-
-    stderrln("\nRequesting login code...");
-    await requestOTP(email);
-    stderrln("Check your email for the 6-digit code.");
-
-    code = await prompter.ask("Enter the code: ");
-  } finally {
-    prompter.close();
-  }
-
-  if (!code || !/^\d{6}$/.test(code)) {
-    stderrln("Error: code must be exactly 6 digits.");
-    process.exit(1);
-  }
-
-  stderrln("Logging in...");
-  let session;
-  try {
-    session = await performLogin(email, code);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    stderrln(`\nLogin failed: ${msg}`);
-    process.exit(1);
-  }
-  saveSession(session);
-  stderrln(`Session saved to ~/.config/mcp-pachca/session.json`);
-
-  // Write MCP config
-  const configPath = resolveConfigPath(client, scope);
-  const dir = path.dirname(configPath);
-  fs.mkdirSync(dir, { recursive: true });
-
-  let config: Record<string, unknown>;
-  if (fs.existsSync(configPath)) {
-    const raw = fs.readFileSync(configPath, "utf8");
-    try {
-      config = JSON.parse(raw) as Record<string, unknown>;
-    } catch {
-      stderrln(
-        `Error: ${configPath} contains malformed JSON. Fix it manually before re-running setup.`,
-      );
-      process.exit(1);
-    }
-  } else {
-    config = {};
-  }
-
-  const raw = config["mcpServers"];
-  const servers = (raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {}) as Record<string, unknown>;
-  servers["pachca"] = buildEntry();
-  config["mcpServers"] = servers;
-
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
-
-  stderrln(`\nConfig written to ${configPath}`);
-  stderrln("Restart your MCP client to apply changes.");
-}

package/src/tools/handlers.ts

@@ -1,212 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { PachcaClient } from "../client.js";
-import type {
-  PachcaUser,
-  PachcaChat,
-  PachcaMessage,
-  PachcaFolder,
-  PachcaProfile,
-  PachcaPresence,
-  PachcaSearchResult,
-  PachcaPaginate,
-} from "./types.js";
-
-type HandlerFn = (
-  client: PachcaClient,
-  args: Record<string, unknown>,
-) => Promise<unknown>;
-
-async function handleSearchUsers(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const params: Record<string, string> = {
-    type: "user",
-    query: String(args["query"]),
-  };
-  if (args["cursor"] !== undefined) params["cursor"] = String(args["cursor"]);
-  return client.get<PachcaSearchResult<PachcaUser>>("/search", params);
-}
-
-async function handleGetUser(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const data = await client.getWithArrayParams<{ data: PachcaUser[] }>(
-    "/users",
-    { ids: [Number(args["id"])] },
-  );
-  if (!data?.data?.length) throw new Error(`User ${args["id"]} not found`);
-  return data.data[0];
-}
-
-async function handleListChats(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const res = await client.get<{ data: PachcaFolder[] }>("/menu/folders");
-  const folders = res?.data ?? [];
-
-  const folderKind = args["folder"] as string | undefined;
-  if (!folderKind) {
-    return {
-      folders: folders.map((f) => ({
-        id: f.id,
-        title: f.title,
-        kind: f.kind,
-      })),
-    };
-  }
-
-  const folder = folders.find((f) => f.kind === folderKind);
-  if (!folder) {
-    throw new Error(`Folder "${folderKind}" not found. Available: ${folders.map((f) => f.kind).join(", ")}`);
-  }
-
-  const params: Record<string, string> = {};
-  if (args["cursor"] !== undefined) params["cursor"] = String(args["cursor"]);
-
-  return client.get<{ records: PachcaChat[]; paginate: PachcaPaginate }>(
-    `/menu/folders/${folder.id}/chats`,
-    params,
-  );
-}
-
-async function handleGetChat(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const data = await client.getWithArrayParams<{ records: PachcaChat[] }>(
-    "/chats",
-    { ids: [Number(args["id"])] },
-  );
-  if (!data?.records?.length) throw new Error(`Chat ${args["id"]} not found`);
-  return data.records[0];
-}
-
-async function handleGetChatMembers(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const chatId = Number(args["id"]);
-  const params: Record<string, string> = {};
-  if (args["limit"] !== undefined) params["limit"] = String(args["limit"]);
-  if (args["cursor"] !== undefined) params["cursor"] = String(args["cursor"]);
-  return client.get<{
-    users: PachcaUser[];
-    total_users: number;
-    paginate: PachcaPaginate;
-  }>(`/chats/${chatId}/users`, params);
-}
-
-async function handleListMessages(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const params: Record<string, string> = {
-    chat_id: String(args["chat_id"]),
-  };
-  if (args["per"] !== undefined) params["per"] = String(args["per"]);
-  if (args["message_id"] !== undefined) params["message_id"] = String(args["message_id"]);
-  if (args["direction"] !== undefined) {
-    if (args["message_id"] === undefined) {
-      throw new Error("direction requires message_id to be set");
-    }
-    params["direction"] = String(args["direction"]);
-  }
-  return client.get<PachcaMessage[]>("/messages", params);
-}
-
-async function handleGetMessage(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const data = await client.getWithArrayParams<PachcaMessage[]>("/messages", {
-    ids: [Number(args["id"])],
-  });
-  if (!data?.length) throw new Error(`Message ${args["id"]} not found`);
-  return data[0];
-}
-
-async function handleSendMessage(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const message: Record<string, unknown> = {
-    uuid: randomUUID(),
-    content: String(args["text"]),
-    markup: [],
-    kind: 0,
-    files: [],
-    skip_invite_mentions: false,
-  };
-  if (args["parent_message_id"] !== undefined) {
-    message["parent_message_id"] = Number(args["parent_message_id"]);
-  }
-  const body = {
-    chat_id: Number(args["chat_id"]),
-    message,
-  };
-  const result = await client.post<PachcaMessage>("/messages", body);
-  return result ?? { success: true, uuid: message.uuid, chat_id: body.chat_id };
-}
-
-async function handleSearch(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const params: Record<string, string> = {
-    type: "message",
-    query: String(args["query"]),
-  };
-  if (args["cursor"] !== undefined) params["cursor"] = String(args["cursor"]);
-  return client.get<PachcaSearchResult<PachcaMessage>>("/search", params);
-}
-
-async function handleGetProfile(client: PachcaClient): Promise<unknown> {
-  return client.get<PachcaProfile>("/profile");
-}
-
-async function handleGetUnread(client: PachcaClient): Promise<unknown> {
-  return client.get<number[]>("/chats/unread_ids");
-}
-
-async function handleGetPresence(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const rawIds = args["ids"];
-  if (!Array.isArray(rawIds) || rawIds.length === 0) {
-    throw new Error("ids must be a non-empty array of numbers");
-  }
-  const ids = rawIds.map((id) => Number(id));
-  return client.getWithArrayParams<PachcaPresence[]>("/friends/presence", {
-    ids,
-  });
-}
-
-async function handleGetPersonalChat(
-  client: PachcaClient,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  return client.getWithArrayParams<Record<string, number>>(
-    "/users/personal_chats",
-    { ids: [Number(args["id"])] },
-  );
-}
-
-export const handlerRegistry: Record<string, HandlerFn> = {
-  pachca_search_users: handleSearchUsers,
-  pachca_get_user: handleGetUser,
-  pachca_list_chats: handleListChats,
-  pachca_get_chat: handleGetChat,
-  pachca_get_chat_members: handleGetChatMembers,
-  pachca_list_messages: handleListMessages,
-  pachca_get_message: handleGetMessage,
-  pachca_send_message: handleSendMessage,
-  pachca_search: handleSearch,
-  pachca_get_profile: handleGetProfile,
-  pachca_get_unread: handleGetUnread,
-  pachca_get_presence: handleGetPresence,
-  pachca_get_personal_chat: handleGetPersonalChat,
-};