@asad120414/mcpcall 0.1.0

package/dist/index.js

@@ -0,0 +1,1396 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z as z4 } from "zod";
+
+// ../shared/src/schema.ts
+import { z } from "zod";
+var workspaceSlugSchema = z.string().min(1).max(64).regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/, "lowercase letters, digits, hyphens; no leading/trailing hyphen");
+var filePathSchema = z.string().min(1).max(512).refine((p) => !p.startsWith("/") && !p.includes("\\"), "must be relative POSIX path").refine((p) => p.split("/").every((seg) => seg !== "" && seg !== "." && seg !== ".."), "no traversal segments").refine((p) => !p.endsWith("/"), "no trailing slash");
+var fileKindSchema = z.enum(["claude_md", "agent", "skill", "command", "rule", "other"]);
+var workspaceSchema = z.object({
+  id: z.string().uuid(),
+  ownerUserId: z.string().uuid(),
+  slug: workspaceSlugSchema,
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var fileSchema = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  path: filePathSchema,
+  kind: fileKindSchema,
+  content: z.string(),
+  sizeBytes: z.number().int().nonnegative(),
+  updatedAt: z.string().datetime()
+});
+var fileManifestEntrySchema = z.object({
+  path: filePathSchema,
+  kind: fileKindSchema,
+  sizeBytes: z.number().int().nonnegative(),
+  sha256: z.string().length(64),
+  updatedAt: z.string().datetime()
+});
+var apiKeyPublicSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(80),
+  prefix: z.string(),
+  lastUsedAt: z.string().datetime().nullable(),
+  createdAt: z.string().datetime(),
+  revokedAt: z.string().datetime().nullable()
+});
+var createWorkspaceRequestSchema = z.object({
+  slug: workspaceSlugSchema,
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).optional()
+});
+var updateWorkspaceRequestSchema = z.object({
+  name: z.string().min(1).max(120).optional(),
+  description: z.string().max(500).nullable().optional()
+});
+var upsertFileRequestSchema = z.object({
+  content: z.string().max(2e6),
+  kind: fileKindSchema.optional()
+});
+var workspaceManifestSchema = z.object({
+  workspace: workspaceSchema,
+  files: z.array(fileManifestEntrySchema)
+});
+var redeemInviteRequestSchema = z.object({
+  code: z.string().min(1).max(64)
+});
+var createApiKeyRequestSchema = z.object({
+  name: z.string().min(1).max(80)
+});
+var createApiKeyResponseSchema = apiKeyPublicSchema.extend({
+  /** Full secret; shown once at creation, never again. Format: `mc_live_<prefix>_<secret>`. */
+  token: z.string()
+});
+var apiErrorSchema = z.object({
+  error: z.object({
+    code: z.string(),
+    message: z.string(),
+    details: z.unknown().optional()
+  })
+});
+
+// ../shared/src/paths.ts
+function projectRelativeWritePath(workspaceRelPath) {
+  const path11 = workspaceRelPath.replace(/^\.\//, "");
+  if (path11 === "CLAUDE.md" || path11 === "RULES.md") return path11;
+  return `.claude/${path11}`;
+}
+function topLevelExcludePaths(workspaceRelPaths) {
+  const top = /* @__PURE__ */ new Set();
+  for (const p of workspaceRelPaths) {
+    const written = projectRelativeWritePath(p);
+    const first = written.split("/")[0];
+    if (first) top.add(first.endsWith("/") ? first : first.includes(".") ? first : `${first}/`);
+  }
+  return [...top].sort();
+}
+
+// src/api-client.ts
+import { z as z2 } from "zod";
+var DEFAULT_API_URL = "https://mcpcall.dev";
+var ApiError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(status2, code, message, details) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status2;
+    this.code = code;
+    this.details = details;
+  }
+};
+var fileContentResponseSchema = z2.object({
+  content: z2.string()
+});
+var listWorkspacesResponseSchema = z2.object({
+  workspaces: z2.array(workspaceSchema)
+});
+var ApiClient = class {
+  apiUrl;
+  apiKey;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.MCPCALL_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "MCPCALL_API_KEY is not set. Add it to your shell rc \u2014 do NOT put it in .mcp.json."
+      );
+    }
+    this.apiKey = apiKey;
+    const url = options.apiUrl ?? process.env.MCPCALL_API_URL ?? DEFAULT_API_URL;
+    this.apiUrl = url.replace(/\/+$/, "");
+  }
+  async request(method, pathname, body) {
+    const url = `${this.apiUrl}${pathname}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: "application/json"
+    };
+    let init = { method, headers };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init = { ...init, body: JSON.stringify(body) };
+    }
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (err2) {
+      throw new ApiError(0, "network_error", `Network error reaching ${url}: ${err2.message}`);
+    }
+    const text = await res.text();
+    if (res.status < 200 || res.status >= 300) {
+      let code = "http_error";
+      let message = `HTTP ${res.status} for ${method} ${pathname}`;
+      let details;
+      if (text) {
+        try {
+          const json = JSON.parse(text);
+          const parsed = apiErrorSchema.safeParse(json);
+          if (parsed.success) {
+            code = parsed.data.error.code;
+            message = parsed.data.error.message;
+            details = parsed.data.error.details;
+          } else {
+            details = json;
+          }
+        } catch {
+          details = text;
+        }
+      }
+      throw new ApiError(res.status, code, message, details);
+    }
+    return { status: res.status, text, contentType: res.headers.get("content-type") };
+  }
+  parseJson(text, schema, ctx) {
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (err2) {
+      throw new ApiError(0, "invalid_response", `Invalid JSON from ${ctx}: ${err2.message}`);
+    }
+    const parsed = schema.safeParse(json);
+    if (!parsed.success) {
+      throw new ApiError(0, "schema_error", `Response from ${ctx} failed validation: ${parsed.error.message}`, parsed.error.flatten());
+    }
+    return parsed.data;
+  }
+  async listWorkspaces() {
+    const { text } = await this.request("GET", "/api/mcp/v1/workspaces");
+    const parsed = this.parseJson(text, listWorkspacesResponseSchema, "GET /workspaces");
+    return parsed.workspaces;
+  }
+  async listFiles(slug) {
+    const { text } = await this.request("GET", `/api/mcp/v1/workspaces/${encodeURIComponent(slug)}/files`);
+    return this.parseJson(text, workspaceManifestSchema, `GET /workspaces/${slug}/files`);
+  }
+  async getFileContent(slug, filePath) {
+    const encoded = filePath.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    const { text } = await this.request(
+      "GET",
+      `/api/mcp/v1/workspaces/${encodeURIComponent(slug)}/files/${encoded}`
+    );
+    return this.parseJson(text, fileContentResponseSchema, `GET file ${filePath}`).content;
+  }
+  async putFile(slug, filePath, content, kind) {
+    const encoded = filePath.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    const body = { content };
+    if (kind !== void 0) {
+      body.kind = fileKindSchema.parse(kind);
+    }
+    await this.request(
+      "PUT",
+      `/api/mcp/v1/workspaces/${encodeURIComponent(slug)}/files/${encoded}`,
+      body
+    );
+  }
+  async deleteFile(slug, filePath) {
+    const encoded = filePath.split("/").map((seg) => encodeURIComponent(seg)).join("/");
+    await this.request(
+      "DELETE",
+      `/api/mcp/v1/workspaces/${encodeURIComponent(slug)}/files/${encoded}`
+    );
+  }
+};
+
+// src/tools/listWorkspaces.ts
+async function listWorkspaces(api) {
+  const ws = await api.listWorkspaces();
+  return { workspaces: ws.map(toSummary) };
+}
+function toSummary(w) {
+  return {
+    id: w.id,
+    slug: w.slug,
+    name: w.name,
+    description: w.description,
+    updatedAt: w.updatedAt
+  };
+}
+
+// src/tools/listFiles.ts
+async function listFiles(api, slug) {
+  const manifest = await api.listFiles(slug);
+  return {
+    workspace: {
+      id: manifest.workspace.id,
+      slug: manifest.workspace.slug,
+      name: manifest.workspace.name
+    },
+    files: manifest.files.map((f) => ({
+      path: f.path,
+      kind: f.kind,
+      sizeBytes: f.sizeBytes,
+      sha256: f.sha256,
+      updatedAt: f.updatedAt
+    }))
+  };
+}
+
+// src/tools/pullWorkspace.ts
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
+
+// src/git/findGitDir.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+async function statSafe(p) {
+  try {
+    return await fs.stat(p);
+  } catch {
+    return null;
+  }
+}
+async function findGitDir(start) {
+  let dir = path.resolve(start);
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(dir)) {
+    seen.add(dir);
+    const dotGit = path.join(dir, ".git");
+    const st = await statSafe(dotGit);
+    if (st) {
+      if (st.isDirectory()) {
+        return { workTree: dir, gitDir: dotGit };
+      }
+      if (st.isFile()) {
+        const contents = await fs.readFile(dotGit, "utf8");
+        const match = contents.match(/^gitdir:\s*(.+?)\s*$/m);
+        if (!match) {
+          return null;
+        }
+        const ref = match[1];
+        const resolved = path.isAbsolute(ref) ? ref : path.resolve(dir, ref);
+        return { workTree: dir, gitDir: resolved };
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/git/exclude.ts
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+var HEADER_RE_TEMPLATE = (slug) => new RegExp(
+  `^# >>> mcpcall managed \\(workspace: ${escapeRe(slug)}\\) >>>$`
+);
+var FOOTER_RE = /^# <<< mcpcall managed <<<$/;
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function headerLine(slug) {
+  return `# >>> mcpcall managed (workspace: ${slug}) >>>`;
+}
+var FOOTER_LINE = "# <<< mcpcall managed <<<";
+async function readExcludeFile(gitDir) {
+  const file = path2.join(gitDir, "info", "exclude");
+  try {
+    return await fs2.readFile(file, "utf8");
+  } catch (err2) {
+    const e = err2;
+    if (e.code === "ENOENT") {
+      await fs2.mkdir(path2.dirname(file), { recursive: true });
+      await fs2.writeFile(file, "", "utf8");
+      return "";
+    }
+    throw err2;
+  }
+}
+function findBlock(lines, slug) {
+  const headerRe = HEADER_RE_TEMPLATE(slug);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (headerRe.test(lines[i])) {
+      start = i;
+      break;
+    }
+  }
+  if (start === -1) return null;
+  for (let j = start + 1; j < lines.length; j++) {
+    if (FOOTER_RE.test(lines[j])) {
+      return { start, end: j };
+    }
+  }
+  return null;
+}
+function splitLines(text) {
+  if (text === "") return { lines: [], trailingNewline: false };
+  const trailingNewline = text.endsWith("\n");
+  const body = trailingNewline ? text.slice(0, -1) : text;
+  return { lines: body.split("\n"), trailingNewline };
+}
+function joinLines(lines) {
+  if (lines.length === 0) return "";
+  return lines.join("\n") + "\n";
+}
+async function applyMcpcallBlock(gitDir, workspaceSlug, ignorePaths) {
+  const file = path2.join(gitDir, "info", "exclude");
+  const current = await readExcludeFile(gitDir);
+  const { lines } = splitLines(current);
+  const block = [headerLine(workspaceSlug), ...ignorePaths, FOOTER_LINE];
+  const existing = findBlock(lines, workspaceSlug);
+  let nextLines;
+  if (existing) {
+    nextLines = [
+      ...lines.slice(0, existing.start),
+      ...block,
+      ...lines.slice(existing.end + 1)
+    ];
+  } else {
+    if (lines.length === 0) {
+      nextLines = [...block];
+    } else {
+      const trimmed = [...lines];
+      while (trimmed.length > 0 && trimmed[trimmed.length - 1] === "") trimmed.pop();
+      nextLines = [...trimmed, "", ...block];
+    }
+  }
+  const next = joinLines(nextLines);
+  if (next !== current) {
+    await fs2.writeFile(file, next, "utf8");
+  }
+}
+async function removeMcpcallBlock(gitDir, workspaceSlug) {
+  const file = path2.join(gitDir, "info", "exclude");
+  let current;
+  try {
+    current = await fs2.readFile(file, "utf8");
+  } catch (err2) {
+    const e = err2;
+    if (e.code === "ENOENT") return false;
+    throw err2;
+  }
+  const { lines } = splitLines(current);
+  const existing = findBlock(lines, workspaceSlug);
+  if (!existing) return false;
+  let cutStart = existing.start;
+  if (cutStart > 0 && lines[cutStart - 1] === "") cutStart -= 1;
+  const nextLines = [...lines.slice(0, cutStart), ...lines.slice(existing.end + 1)];
+  while (nextLines.length > 0 && nextLines[nextLines.length - 1] === "") nextLines.pop();
+  const next = joinLines(nextLines);
+  await fs2.writeFile(file, next, "utf8");
+  return true;
+}
+
+// src/manifest.ts
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
+import { z as z3 } from "zod";
+var MANIFEST_REL_PATH = path3.join(".claude", ".team-agents.json");
+var localManifestEntrySchema = z3.object({
+  /** Workspace-relative path (server-side, e.g. `agents/reviewer.md`). */
+  path: z3.string(),
+  /** Local on-disk path, project-relative POSIX. */
+  projectPath: z3.string(),
+  /** Hex SHA-256 of the content we wrote / last synced. */
+  sha256: z3.string().length(64)
+});
+var localManifestSchema = z3.object({
+  workspaceId: z3.string(),
+  workspaceSlug: z3.string(),
+  pulledAt: z3.string(),
+  apiUrl: z3.string(),
+  files: z3.array(localManifestEntrySchema)
+});
+async function readManifest(targetDir) {
+  const p = path3.join(targetDir, MANIFEST_REL_PATH);
+  try {
+    const text = await fs3.readFile(p, "utf8");
+    const json = JSON.parse(text);
+    return localManifestSchema.parse(json);
+  } catch (err2) {
+    const e = err2;
+    if (e.code === "ENOENT") return null;
+    throw err2;
+  }
+}
+async function writeManifest(targetDir, manifest) {
+  const p = path3.join(targetDir, MANIFEST_REL_PATH);
+  await fs3.mkdir(path3.dirname(p), { recursive: true });
+  await fs3.writeFile(p, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+async function deleteManifest(targetDir) {
+  const p = path3.join(targetDir, MANIFEST_REL_PATH);
+  try {
+    await fs3.unlink(p);
+    return true;
+  } catch (err2) {
+    const e = err2;
+    if (e.code === "ENOENT") return false;
+    throw err2;
+  }
+}
+
+// src/util/sha256.ts
+import { createHash } from "node:crypto";
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+// src/tools/pullWorkspace.ts
+function resolveDestination(targetDir, workspaceRelPath) {
+  const writeRel = projectRelativeWritePath(workspaceRelPath);
+  if (writeRel.includes("\\") || writeRel.startsWith("/")) return null;
+  const parts = writeRel.split("/");
+  if (parts.some((s) => s === ".." || s === "." || s === "")) return null;
+  const absTarget = path4.resolve(targetDir);
+  const absPath = path4.resolve(absTarget, ...parts);
+  const rel = path4.relative(absTarget, absPath);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) return null;
+  return { absPath, projectPath: writeRel };
+}
+async function isSymlink(p) {
+  try {
+    const st = await fs4.lstat(p);
+    return st.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function anyParentIsSymlink(targetDir, absPath) {
+  let dir = path4.dirname(absPath);
+  const root = path4.resolve(targetDir);
+  while (dir.startsWith(root) && dir !== root) {
+    if (await isSymlink(dir)) return true;
+    const next = path4.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return false;
+}
+async function pullWorkspace(api, args) {
+  const targetDir = path4.resolve(args.target_dir ?? process.cwd());
+  await fs4.mkdir(targetDir, { recursive: true });
+  const manifest = await api.listFiles(args.workspace);
+  const workspaceSlug = manifest.workspace.slug;
+  const workspaceId = manifest.workspace.id;
+  const prefixFilter = args.prefix !== void 0 ? args.prefix.replace(/\/+$/, "") : void 0;
+  const warnings = [];
+  const skipped = [];
+  const conflicts = [];
+  const writtenEntries = [];
+  const successfullyWrittenRelPaths = [];
+  for (const entry of manifest.files) {
+    if (prefixFilter !== void 0) {
+      if (entry.path !== prefixFilter && !entry.path.startsWith(`${prefixFilter}/`)) {
+        continue;
+      }
+    }
+    const pathParse = filePathSchema.safeParse(entry.path);
+    if (!pathParse.success) {
+      skipped.push({ path: entry.path, reason: `invalid path: ${pathParse.error.message}` });
+      continue;
+    }
+    const dest = resolveDestination(targetDir, entry.path);
+    if (!dest) {
+      skipped.push({ path: entry.path, reason: "path resolves outside target dir" });
+      continue;
+    }
+    if (await anyParentIsSymlink(targetDir, dest.absPath)) {
+      skipped.push({ path: entry.path, reason: "symlinked parent directory" });
+      continue;
+    }
+    if (await isSymlink(dest.absPath)) {
+      skipped.push({ path: entry.path, reason: "destination is a symlink" });
+      continue;
+    }
+    let remoteContent;
+    try {
+      remoteContent = await api.getFileContent(workspaceSlug, entry.path);
+    } catch (err2) {
+      skipped.push({ path: entry.path, reason: `fetch failed: ${err2.message}` });
+      continue;
+    }
+    const remoteHash = sha256Hex(remoteContent);
+    let existing = null;
+    try {
+      existing = await fs4.readFile(dest.absPath, "utf8");
+    } catch (err2) {
+      const e = err2;
+      if (e.code !== "ENOENT") {
+        skipped.push({ path: entry.path, reason: `read failed: ${e.message}` });
+        continue;
+      }
+    }
+    if (existing !== null) {
+      const existingHash = sha256Hex(existing);
+      if (existingHash === remoteHash) {
+        writtenEntries.push({
+          path: entry.path,
+          projectPath: dest.projectPath,
+          sha256: remoteHash
+        });
+        successfullyWrittenRelPaths.push(entry.path);
+        continue;
+      }
+      const incomingAbs = `${dest.absPath}.incoming`;
+      await fs4.mkdir(path4.dirname(incomingAbs), { recursive: true });
+      await fs4.writeFile(incomingAbs, remoteContent, "utf8");
+      conflicts.push({
+        path: entry.path,
+        incomingPath: `${dest.projectPath}.incoming`
+      });
+      successfullyWrittenRelPaths.push(entry.path);
+      writtenEntries.push({
+        path: entry.path,
+        projectPath: dest.projectPath,
+        sha256: existingHash
+      });
+      continue;
+    }
+    await fs4.mkdir(path4.dirname(dest.absPath), { recursive: true });
+    await fs4.writeFile(dest.absPath, remoteContent, "utf8");
+    writtenEntries.push({
+      path: entry.path,
+      projectPath: dest.projectPath,
+      sha256: remoteHash
+    });
+    successfullyWrittenRelPaths.push(entry.path);
+  }
+  const gitInfo = await findGitDir(targetDir);
+  let excludeUpdated = false;
+  if (!gitInfo) {
+    warnings.push(
+      `No git repository detected at or above ${targetDir}. Files were written but NOT hidden from any VCS \u2014 add them to your ignore manually.`
+    );
+  } else {
+    const ignorePaths = topLevelExcludePaths(successfullyWrittenRelPaths);
+    if (ignorePaths.length > 0) {
+      await applyMcpcallBlock(gitInfo.gitDir, workspaceSlug, ignorePaths);
+      excludeUpdated = true;
+    }
+  }
+  const local = {
+    workspaceId,
+    workspaceSlug,
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    apiUrl: api.apiUrl,
+    files: writtenEntries
+  };
+  await writeManifest(targetDir, local);
+  return {
+    workspaceId,
+    workspaceSlug,
+    targetDir,
+    written: writtenEntries.length,
+    skipped,
+    conflicts,
+    excludeUpdated,
+    gitDetected: gitInfo !== null,
+    warnings
+  };
+}
+
+// src/tools/pullFile.ts
+import { promises as fs5 } from "node:fs";
+import path5 from "node:path";
+async function isSymlink2(p) {
+  try {
+    const st = await fs5.lstat(p);
+    return st.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function anyParentIsSymlink2(targetDir, absPath) {
+  let dir = path5.dirname(absPath);
+  const root = path5.resolve(targetDir);
+  while (dir.startsWith(root) && dir !== root) {
+    if (await isSymlink2(dir)) return true;
+    const next = path5.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return false;
+}
+async function pullFile(api, args) {
+  const targetDir = path5.resolve(args.target_dir ?? process.cwd());
+  await fs5.mkdir(targetDir, { recursive: true });
+  const filePath = filePathSchema.parse(args.path);
+  const warnings = [];
+  const wsManifest = await api.listFiles(args.workspace);
+  const workspaceSlug = wsManifest.workspace.slug;
+  const workspaceId = wsManifest.workspace.id;
+  const remoteEntry = wsManifest.files.find((f) => f.path === filePath);
+  if (!remoteEntry) {
+    throw new Error(`File '${filePath}' not found in workspace '${workspaceSlug}'.`);
+  }
+  const writeRel = projectRelativeWritePath(filePath);
+  const parts = writeRel.split("/");
+  const absPath = path5.resolve(targetDir, ...parts);
+  const rel = path5.relative(path5.resolve(targetDir), absPath);
+  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
+    throw new Error(`Resolved destination ${absPath} would escape target directory.`);
+  }
+  if (await anyParentIsSymlink2(targetDir, absPath)) {
+    throw new Error(`A parent directory of the destination is a symlink \u2014 refusing to write.`);
+  }
+  if (await isSymlink2(absPath)) {
+    throw new Error(`Destination ${writeRel} is a symlink \u2014 refusing to overwrite.`);
+  }
+  const remoteContent = await api.getFileContent(workspaceSlug, filePath);
+  const remoteHash = sha256Hex(remoteContent);
+  let existing = null;
+  try {
+    existing = await fs5.readFile(absPath, "utf8");
+  } catch (err2) {
+    const e = err2;
+    if (e.code !== "ENOENT") {
+      throw new Error(`Cannot read existing file ${writeRel}: ${e.message}`);
+    }
+  }
+  let written = false;
+  let conflict = false;
+  let incomingPath = null;
+  let recordedHash;
+  if (existing !== null) {
+    const existingHash = sha256Hex(existing);
+    if (existingHash === remoteHash) {
+      written = false;
+      recordedHash = remoteHash;
+    } else {
+      const incomingAbs = `${absPath}.incoming`;
+      await fs5.mkdir(path5.dirname(incomingAbs), { recursive: true });
+      await fs5.writeFile(incomingAbs, remoteContent, "utf8");
+      conflict = true;
+      incomingPath = `${writeRel}.incoming`;
+      recordedHash = existingHash;
+    }
+  } else {
+    await fs5.mkdir(path5.dirname(absPath), { recursive: true });
+    await fs5.writeFile(absPath, remoteContent, "utf8");
+    written = true;
+    recordedHash = remoteHash;
+  }
+  const existingManifest = await readManifest(targetDir);
+  const newEntry = {
+    path: filePath,
+    projectPath: writeRel,
+    sha256: recordedHash
+  };
+  let manifest;
+  if (existingManifest) {
+    const idx = existingManifest.files.findIndex((f) => f.path === filePath);
+    if (idx >= 0) {
+      existingManifest.files[idx] = newEntry;
+    } else {
+      existingManifest.files.push(newEntry);
+    }
+    manifest = { ...existingManifest, pulledAt: (/* @__PURE__ */ new Date()).toISOString() };
+  } else {
+    manifest = {
+      workspaceId,
+      workspaceSlug,
+      pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      apiUrl: api.apiUrl,
+      files: [newEntry]
+    };
+  }
+  await writeManifest(targetDir, manifest);
+  const gitInfo = await findGitDir(targetDir);
+  let excludeUpdated = false;
+  if (!gitInfo) {
+    warnings.push(
+      `No git repository detected at or above ${targetDir}. File was written but NOT hidden from any VCS \u2014 add it to your ignore manually.`
+    );
+  } else {
+    const allProjectPaths = manifest.files.map((f) => f.path);
+    const ignorePaths = topLevelExcludePaths(allProjectPaths);
+    if (ignorePaths.length > 0) {
+      await applyMcpcallBlock(gitInfo.gitDir, workspaceSlug, ignorePaths);
+      excludeUpdated = true;
+    }
+  }
+  return {
+    workspaceSlug,
+    path: filePath,
+    projectPath: writeRel,
+    sha256: recordedHash,
+    written,
+    conflict,
+    incomingPath,
+    excludeUpdated,
+    gitDetected: gitInfo !== null,
+    warnings
+  };
+}
+
+// src/tools/importFolder.ts
+import { promises as fs6 } from "node:fs";
+import path6 from "node:path";
+var MAX_FILES = 200;
+var MAX_BYTES = 2 * 1024 * 1024;
+function matchGlob(pattern, filePath) {
+  const p = filePath.replace(/\\/g, "/");
+  const g = pattern.replace(/\\/g, "/");
+  let re = "";
+  let i = 0;
+  while (i < g.length) {
+    const ch = g[i];
+    if (ch === "*" && g[i + 1] === "*") {
+      re += ".*";
+      i += 2;
+      if (g[i] === "/") i += 1;
+    } else if (ch === "*") {
+      re += "[^/]*";
+      i += 1;
+    } else if (ch === "?") {
+      re += "[^/]";
+      i += 1;
+    } else if (/[.+^${}()|[\]\\]/.test(ch)) {
+      re += "\\" + ch;
+      i += 1;
+    } else {
+      re += ch;
+      i += 1;
+    }
+  }
+  return new RegExp(`^${re}$`).test(p);
+}
+function matchesAnyGlob(patterns, filePath) {
+  return patterns.some((pat) => matchGlob(pat, filePath));
+}
+async function walkDir(sourceDir, relBase, collector) {
+  let entries;
+  try {
+    entries = await fs6.readdir(path6.join(sourceDir, relBase), { withFileTypes: true });
+  } catch (err2) {
+    const e = err2;
+    throw new Error(`Cannot read directory ${path6.join(sourceDir, relBase)}: ${e.message}`);
+  }
+  for (const entry of entries) {
+    const entryRel = relBase ? `${relBase}/${entry.name}` : entry.name;
+    const entryAbs = path6.join(sourceDir, entryRel);
+    const st = await fs6.lstat(entryAbs);
+    if (st.isSymbolicLink()) {
+      collector.push({ rel: `__symlink__:${entryRel}`, abs: entryAbs });
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await walkDir(sourceDir, entryRel, collector);
+    } else if (entry.isFile()) {
+      collector.push({ rel: entryRel, abs: entryAbs });
+    }
+  }
+}
+function validateDestPrefix(raw) {
+  const p = raw.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (p === "") return "";
+  filePathSchema.parse(p);
+  return p;
+}
+async function importFolder(api, args) {
+  const dryRun = args.dry_run === true;
+  const include = args.include ?? ["**/*.md", "**/*.mdx"];
+  const destPrefix = args.dest_prefix !== void 0 ? validateDestPrefix(args.dest_prefix) : "";
+  const sourceDir = path6.resolve(args.source_dir);
+  let stat;
+  try {
+    stat = await fs6.stat(sourceDir);
+  } catch (err2) {
+    const e = err2;
+    throw new Error(`source_dir does not exist or is not accessible: ${e.message}`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`source_dir is not a directory: ${sourceDir}`);
+  }
+  const allEntries = [];
+  await walkDir(sourceDir, "", allEntries);
+  const uploaded = [];
+  const skipped = [];
+  const realEntries = allEntries.filter((e) => !e.rel.startsWith("__symlink__:"));
+  const symlinkEntries = allEntries.filter((e) => e.rel.startsWith("__symlink__:"));
+  for (const s of symlinkEntries) {
+    skipped.push({ path: s.rel.slice("__symlink__:".length), reason: "symlink \u2014 skipped" });
+  }
+  const matched = realEntries.filter((e) => matchesAnyGlob(include, e.rel));
+  if (matched.length > MAX_FILES) {
+    throw new Error(
+      `Found ${matched.length} files matching the include patterns \u2014 exceeds the cap of ${MAX_FILES}. Use a narrower 'include' glob to proceed.`
+    );
+  }
+  for (const entry of matched) {
+    const wsPath = destPrefix ? `${destPrefix}/${entry.rel}` : entry.rel;
+    const pathParse = filePathSchema.safeParse(wsPath);
+    if (!pathParse.success) {
+      skipped.push({ path: wsPath, reason: `invalid workspace path: ${pathParse.error.message}` });
+      continue;
+    }
+    let fileStat;
+    try {
+      fileStat = await fs6.stat(entry.abs);
+    } catch (err2) {
+      skipped.push({ path: wsPath, reason: `stat failed: ${err2.message}` });
+      continue;
+    }
+    if (fileStat.size > MAX_BYTES) {
+      skipped.push({ path: wsPath, reason: `file too large (${fileStat.size} bytes > 2 MB limit)` });
+      continue;
+    }
+    if (dryRun) {
+      uploaded.push({ path: wsPath, sizeBytes: fileStat.size });
+      continue;
+    }
+    let content;
+    try {
+      content = await fs6.readFile(entry.abs, "utf8");
+    } catch (err2) {
+      skipped.push({ path: wsPath, reason: `read failed: ${err2.message}` });
+      continue;
+    }
+    const sizeBytes = Buffer.byteLength(content, "utf8");
+    try {
+      await api.putFile(args.workspace, wsPath, content);
+      uploaded.push({ path: wsPath, sizeBytes });
+    } catch (err2) {
+      skipped.push({ path: wsPath, reason: `upload failed: ${err2.message}` });
+    }
+  }
+  return {
+    workspaceSlug: args.workspace,
+    sourceDir,
+    uploaded,
+    skipped,
+    dryRun
+  };
+}
+
+// src/tools/createFile.ts
+async function createFile(api, args) {
+  const filePath = filePathSchema.parse(args.path);
+  const kind = fileKindSchema.parse(args.kind);
+  await api.putFile(args.workspace, filePath, args.content, kind);
+  if (args.target_dir) {
+    const manifest = await readManifest(args.target_dir);
+    if (manifest && manifest.workspaceSlug === args.workspace) {
+      const sha = sha256Hex(args.content);
+      const projectPath = projectRelativeWritePath(filePath);
+      const idx = manifest.files.findIndex((f) => f.path === filePath);
+      const entry = { path: filePath, projectPath, sha256: sha };
+      if (idx >= 0) manifest.files[idx] = entry;
+      else manifest.files.push(entry);
+      await writeManifest(args.target_dir, manifest);
+    }
+  }
+  return { workspace: args.workspace, path: filePath, kind, sha256: sha256Hex(args.content) };
+}
+
+// src/tools/pushFile.ts
+import { promises as fs7 } from "node:fs";
+import path7 from "node:path";
+async function pushFile(api, args) {
+  const filePath = filePathSchema.parse(args.path);
+  const targetDir = path7.resolve(args.target_dir ?? process.cwd());
+  let content = args.content;
+  if (content === void 0) {
+    const projectPath = projectRelativeWritePath(filePath);
+    const abs = path7.resolve(targetDir, projectPath);
+    try {
+      content = await fs7.readFile(abs, "utf8");
+    } catch (err2) {
+      const e = err2;
+      throw new Error(`Cannot read local file ${projectPath}: ${e.message}`);
+    }
+  }
+  await api.putFile(args.workspace, filePath, content);
+  const sha = sha256Hex(content);
+  const manifest = await readManifest(targetDir);
+  if (manifest && manifest.workspaceSlug === args.workspace) {
+    const projectPath = projectRelativeWritePath(filePath);
+    const entry = { path: filePath, projectPath, sha256: sha };
+    const idx = manifest.files.findIndex((f) => f.path === filePath);
+    if (idx >= 0) manifest.files[idx] = entry;
+    else manifest.files.push(entry);
+    await writeManifest(targetDir, manifest);
+  }
+  return { workspace: args.workspace, path: filePath, sha256: sha };
+}
+
+// src/tools/deleteFile.ts
+import path8 from "node:path";
+async function deleteFile(api, args) {
+  const filePath = filePathSchema.parse(args.path);
+  await api.deleteFile(args.workspace, filePath);
+  const targetDir = path8.resolve(args.target_dir ?? process.cwd());
+  const manifest = await readManifest(targetDir);
+  if (manifest && manifest.workspaceSlug === args.workspace) {
+    const before = manifest.files.length;
+    manifest.files = manifest.files.filter((f) => f.path !== filePath);
+    if (manifest.files.length !== before) {
+      await writeManifest(targetDir, manifest);
+    }
+  }
+  return { workspace: args.workspace, path: filePath, deleted: true };
+}
+
+// src/tools/cleanup.ts
+import { promises as fs8 } from "node:fs";
+import path9 from "node:path";
+async function pruneEmptyParents(absFile, stopAt) {
+  let dir = path9.dirname(absFile);
+  const root = path9.resolve(stopAt);
+  while (dir.startsWith(root) && dir !== root) {
+    try {
+      const entries = await fs8.readdir(dir);
+      if (entries.length > 0) return;
+      await fs8.rmdir(dir);
+    } catch {
+      return;
+    }
+    const next = path9.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+}
+async function cleanup(args) {
+  const targetDir = path9.resolve(args.target_dir ?? process.cwd());
+  const manifest = await readManifest(targetDir);
+  if (!manifest) {
+    return {
+      removed: 0,
+      skipped: [],
+      excludeBlockRemoved: false,
+      manifestRemoved: false,
+      workspaceSlug: null
+    };
+  }
+  const force = args.force === true;
+  let removed = 0;
+  const skipped = [];
+  for (const entry of manifest.files) {
+    const abs = path9.resolve(targetDir, ...entry.projectPath.split("/"));
+    let content;
+    try {
+      content = await fs8.readFile(abs, "utf8");
+    } catch (err2) {
+      const e = err2;
+      if (e.code === "ENOENT") {
+        removed += 1;
+        continue;
+      }
+      skipped.push({ path: entry.path, reason: `read failed: ${e.message}` });
+      continue;
+    }
+    const localHash = sha256Hex(content);
+    if (!force && localHash !== entry.sha256) {
+      skipped.push({
+        path: entry.path,
+        reason: "local edits detected (sha mismatch). Re-run with force: true to override."
+      });
+      continue;
+    }
+    try {
+      await fs8.unlink(abs);
+      removed += 1;
+      await pruneEmptyParents(abs, targetDir);
+    } catch (err2) {
+      const e = err2;
+      skipped.push({ path: entry.path, reason: `unlink failed: ${e.message}` });
+    }
+  }
+  let excludeBlockRemoved = false;
+  const gitInfo = await findGitDir(targetDir);
+  if (gitInfo) {
+    excludeBlockRemoved = await removeMcpcallBlock(gitInfo.gitDir, manifest.workspaceSlug);
+  }
+  const manifestRemoved = await deleteManifest(targetDir);
+  const claudeDir = path9.join(targetDir, ".claude");
+  try {
+    const remaining = await fs8.readdir(claudeDir);
+    if (remaining.length === 0) await fs8.rmdir(claudeDir);
+  } catch {
+  }
+  return {
+    removed,
+    skipped,
+    excludeBlockRemoved,
+    manifestRemoved,
+    workspaceSlug: manifest.workspaceSlug
+  };
+}
+
+// src/tools/status.ts
+import { promises as fs9 } from "node:fs";
+import path10 from "node:path";
+async function status(api, args) {
+  const targetDir = path10.resolve(args.target_dir ?? process.cwd());
+  const manifest = await readManifest(targetDir);
+  if (!manifest) {
+    return {
+      workspaceId: null,
+      workspaceSlug: null,
+      pulledAt: null,
+      targetDir,
+      files: [],
+      remoteOnly: [],
+      hasManifest: false
+    };
+  }
+  const remote = await api.listFiles(manifest.workspaceSlug);
+  const remoteBy = new Map(remote.files.map((f) => [f.path, f]));
+  const seenRemote = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const entry of manifest.files) {
+    const remoteEntry = remoteBy.get(entry.path);
+    const absLocal = path10.resolve(targetDir, ...entry.projectPath.split("/"));
+    let localSha = null;
+    try {
+      const content = await fs9.readFile(absLocal, "utf8");
+      localSha = sha256Hex(content);
+    } catch (err2) {
+      const e = err2;
+      if (e.code !== "ENOENT") throw err2;
+    }
+    if (remoteEntry) seenRemote.add(entry.path);
+    let s;
+    if (!remoteEntry) {
+      s = "remote_missing";
+    } else if (localSha === null) {
+      s = "local_missing";
+    } else {
+      const local = localSha === entry.sha256;
+      const remoteSame = remoteEntry.sha256 === entry.sha256;
+      if (local && remoteSame) s = "in_sync";
+      else if (!local && remoteSame) s = "local_drift";
+      else if (local && !remoteSame) s = "remote_drift";
+      else s = "conflict";
+    }
+    files.push({
+      path: entry.path,
+      status: s,
+      localSha,
+      remoteSha: remoteEntry?.sha256 ?? null,
+      manifestSha: entry.sha256
+    });
+  }
+  const remoteOnly = remote.files.filter((f) => !seenRemote.has(f.path) && !manifest.files.some((m) => m.path === f.path)).map((f) => ({ path: f.path, sha256: f.sha256 }));
+  return {
+    workspaceId: manifest.workspaceId,
+    workspaceSlug: manifest.workspaceSlug,
+    pulledAt: manifest.pulledAt,
+    targetDir,
+    files,
+    remoteOnly,
+    hasManifest: true
+  };
+}
+
+// src/index.ts
+var listWorkspacesInput = z4.object({}).strict();
+var listFilesInput = z4.object({ workspace: workspaceSlugSchema }).strict();
+var pullWorkspaceInput = z4.object({
+  workspace: workspaceSlugSchema,
+  target_dir: z4.string().min(1).optional(),
+  prefix: z4.string().min(1).optional()
+}).strict();
+var pullFileInput = z4.object({
+  workspace: workspaceSlugSchema,
+  path: filePathSchema,
+  target_dir: z4.string().min(1).optional()
+}).strict();
+var importFolderInput = z4.object({
+  workspace: workspaceSlugSchema,
+  source_dir: z4.string().min(1),
+  include: z4.array(z4.string().min(1)).optional(),
+  dest_prefix: z4.string().optional(),
+  dry_run: z4.boolean().optional()
+}).strict();
+var createFileInput = z4.object({
+  workspace: workspaceSlugSchema,
+  path: filePathSchema,
+  kind: fileKindSchema,
+  content: z4.string(),
+  target_dir: z4.string().min(1).optional()
+}).strict();
+var pushFileInput = z4.object({
+  workspace: workspaceSlugSchema,
+  path: filePathSchema,
+  content: z4.string().optional(),
+  target_dir: z4.string().min(1).optional()
+}).strict();
+var deleteFileInput = z4.object({
+  workspace: workspaceSlugSchema,
+  path: filePathSchema,
+  target_dir: z4.string().min(1).optional()
+}).strict();
+var cleanupInput = z4.object({
+  target_dir: z4.string().min(1).optional(),
+  force: z4.boolean().optional()
+}).strict();
+var statusInput = z4.object({ target_dir: z4.string().min(1).optional() }).strict();
+var TOOLS = [
+  {
+    name: "list_workspaces",
+    description: "List workspaces accessible to the configured API key.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  },
+  {
+    name: "list_files",
+    description: "List files in a workspace with size, sha256, and last-modified timestamps.",
+    inputSchema: {
+      type: "object",
+      properties: { workspace: { type: "string", description: "Workspace slug." } },
+      required: ["workspace"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "pull_workspace",
+    description: "Pull all files (or a filtered subset) for a workspace into the target directory's `.claude/` (and root for CLAUDE.md/RULES.md), and append a sentinel block to `.git/info/exclude` so the client's git status stays clean. Never clobbers local edits \u2014 writes `.incoming` siblings on conflict. Use `prefix` to pull only files whose workspace path starts with that prefix (e.g. `agents` to pull the agents subtree).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string", description: "Workspace slug." },
+        target_dir: {
+          type: "string",
+          description: "Absolute target directory. Defaults to process.cwd()."
+        },
+        prefix: {
+          type: "string",
+          description: "Only pull files whose workspace path starts with this prefix or equals it exactly. E.g. 'agents' pulls only the agents subtree; 'agents/reviewer.md' pulls a single file."
+        }
+      },
+      required: ["workspace"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "pull_file",
+    description: "Pull a single file from a workspace into the project's `.claude/` directory (or project root for CLAUDE.md/RULES.md). Applies the same conflict-safe semantics as pull_workspace: writes a `.incoming` sibling on conflict, updates the local manifest, and refreshes the `.git/info/exclude` sentinel block.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string", description: "Workspace slug." },
+        path: {
+          type: "string",
+          description: "Workspace-relative file path (POSIX), e.g. `agents/reviewer.md`."
+        },
+        target_dir: {
+          type: "string",
+          description: "Absolute target directory. Defaults to process.cwd()."
+        }
+      },
+      required: ["workspace", "path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "import_folder",
+    description: "Bulk-import a local directory tree into a workspace. Walks the source directory, filters by glob patterns, and uploads matched files via PUT. Validates each workspace path, rejects symlinks, skips files > 2 MB, and caps at 200 files per call. Use dry_run: true to preview what would be uploaded without making any changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string", description: "Workspace slug." },
+        source_dir: {
+          type: "string",
+          description: "Absolute or cwd-relative path to the local directory to import from."
+        },
+        include: {
+          type: "array",
+          items: { type: "string" },
+          description: "Minimatch-style glob patterns of files to include. Defaults to ['**/*.md', '**/*.mdx']. Supports `**` (recursive), `*` (single segment), and exact paths."
+        },
+        dest_prefix: {
+          type: "string",
+          description: "Prepend to every uploaded file's workspace path. E.g. dest_prefix='agents/' makes './reviewer.md' upload as 'agents/reviewer.md'."
+        },
+        dry_run: {
+          type: "boolean",
+          description: "List what would be uploaded without uploading. Defaults to false."
+        }
+      },
+      required: ["workspace", "source_dir"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "create_file",
+    description: "Create a new file on the platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string" },
+        path: { type: "string", description: "Workspace-relative path (POSIX)." },
+        kind: {
+          type: "string",
+          enum: ["claude_md", "agent", "skill", "command", "rule", "other"]
+        },
+        content: { type: "string" },
+        target_dir: { type: "string" }
+      },
+      required: ["workspace", "path", "kind", "content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "push_file",
+    description: "Upsert a file on the platform. If `content` is omitted, reads the file from the local on-disk path resolved via projectRelativeWritePath.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string" },
+        path: { type: "string" },
+        content: { type: "string" },
+        target_dir: { type: "string" }
+      },
+      required: ["workspace", "path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "delete_file",
+    description: "Soft-delete a file on the platform. Does not touch local disk.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        workspace: { type: "string" },
+        path: { type: "string" },
+        target_dir: { type: "string" }
+      },
+      required: ["workspace", "path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "cleanup",
+    description: "Reverse a previous pull: delete files whose local sha matches what was written, strip the sentinel block from `.git/info/exclude`, and remove the local manifest. Files with local edits are skipped unless `force` is true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target_dir: { type: "string" },
+        force: { type: "boolean" }
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "status",
+    description: "Compare local manifest against remote manifest, reporting drift per file.",
+    inputSchema: {
+      type: "object",
+      properties: { target_dir: { type: "string" } },
+      additionalProperties: false
+    }
+  }
+];
+function ok(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+  };
+}
+function err(message) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }]
+  };
+}
+function formatError(e) {
+  if (e instanceof ApiError) {
+    return `API error (${e.status} ${e.code}): ${e.message}`;
+  }
+  if (e instanceof z4.ZodError) {
+    return `Invalid arguments: ${e.errors.map((x) => `${x.path.join(".") || "<root>"}: ${x.message}`).join("; ")}`;
+  }
+  if (e instanceof Error) return e.message;
+  return String(e);
+}
+async function main() {
+  const server = new Server(
+    { name: "mcpcall", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: rawArgs } = req.params;
+    const args = rawArgs ?? {};
+    try {
+      const api = () => new ApiClient();
+      switch (name) {
+        case "list_workspaces": {
+          listWorkspacesInput.parse(args);
+          return ok(await listWorkspaces(api()));
+        }
+        case "list_files": {
+          const parsed = listFilesInput.parse(args);
+          return ok(await listFiles(api(), parsed.workspace));
+        }
+        case "pull_workspace": {
+          const parsed = pullWorkspaceInput.parse(args);
+          return ok(await pullWorkspace(api(), parsed));
+        }
+        case "pull_file": {
+          const parsed = pullFileInput.parse(args);
+          return ok(await pullFile(api(), parsed));
+        }
+        case "import_folder": {
+          const parsed = importFolderInput.parse(args);
+          return ok(await importFolder(api(), parsed));
+        }
+        case "create_file": {
+          const parsed = createFileInput.parse(args);
+          return ok(await createFile(api(), parsed));
+        }
+        case "push_file": {
+          const parsed = pushFileInput.parse(args);
+          return ok(await pushFile(api(), parsed));
+        }
+        case "delete_file": {
+          const parsed = deleteFileInput.parse(args);
+          return ok(await deleteFile(api(), parsed));
+        }
+        case "cleanup": {
+          const parsed = cleanupInput.parse(args);
+          return ok(await cleanup(parsed));
+        }
+        case "status": {
+          const parsed = statusInput.parse(args);
+          return ok(await status(api(), parsed));
+        }
+        default:
+          return err(`Unknown tool: ${name}`);
+      }
+    } catch (e) {
+      return err(formatError(e));
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((e) => {
+  console.error("[mcpcall] fatal:", e);
+  process.exit(1);
+});