trelly 0.1.0

package/src/mcp/tools/webhooks.ts

@@ -0,0 +1,52 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { profileField, toolEnvelopeSchema, withClient } from "../handlers.ts";
+
+export function registerWebhookTools(server: McpServer): void {
+  const outputSchema = toolEnvelopeSchema;
+
+  server.registerTool(
+    "trello_webhooks_list",
+    {
+      description: "List webhooks registered for the current token.",
+      inputSchema: { profile: profileField },
+      annotations: { readOnlyHint: true },
+      outputSchema,
+    },
+    async ({ profile }) => withClient(profile, (client) => client.webhooksForToken()),
+  );
+
+  server.registerTool(
+    "trello_webhook_create",
+    {
+      description: "Create a webhook on a board or card model.",
+      inputSchema: {
+        profile: profileField,
+        callbackUrl: z.string().url(),
+        modelId: z.string().min(1),
+        description: z.string().optional(),
+      },
+      outputSchema,
+    },
+    async ({ profile, callbackUrl, modelId, description }) =>
+      withClient(profile, (client) =>
+        client.webhookCreate({
+          callbackURL: callbackUrl,
+          idModel: modelId,
+          description,
+        }),
+      ),
+  );
+
+  server.registerTool(
+    "trello_webhook_delete",
+    {
+      description: "Delete a webhook by id.",
+      inputSchema: { profile: profileField, webhookId: z.string().min(1) },
+      annotations: { destructiveHint: true },
+      outputSchema,
+    },
+    async ({ profile, webhookId }) =>
+      withClient(profile, (client) => client.webhookDelete(webhookId)),
+  );
+}

package/src/util/runtime.ts

@@ -0,0 +1,39 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+export async function readLine(): Promise<string> {
+  if (!process.stdin.isTTY) {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8").trim();
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.once("line", (line) => {
+      rl.close();
+      resolve(line.trim());
+    });
+  });
+}
+
+export async function openInBrowser(url: string): Promise<void> {
+  const platform = process.platform;
+  const cmd =
+    platform === "darwin"
+      ? ["open", url]
+      : platform === "win32"
+        ? ["cmd", "/c", "start", "", url]
+        : ["xdg-open", url];
+
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(cmd[0]!, cmd.slice(1), { stdio: "ignore" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`open browser exited with code ${code}`));
+    });
+  });
+}

package/src/version.ts

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+let cachedVersion: string | undefined;
+
+export function packageVersion(): string {
+  if (cachedVersion) return cachedVersion;
+  const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
+    version: string;
+  };
+  cachedVersion = pkg.version;
+  return cachedVersion;
+}