npm - trelly - Versions diffs - 0.1.0 - Mend

trelly 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/README.md +191 -0
package/bin/run-ts +31 -0
package/bin/trelly +2 -0
package/bin/trelly-mcp +2 -0
package/package.json +64 -0
package/src/api/client.ts +332 -0
package/src/api/http.ts +86 -0
package/src/auth/browser-flow.ts +217 -0
package/src/auth/profiles.ts +163 -0
package/src/cli/commands/actions.ts +17 -0
package/src/cli/commands/api.ts +46 -0
package/src/cli/commands/auth.ts +248 -0
package/src/cli/commands/boards.ts +152 -0
package/src/cli/commands/cards.ts +194 -0
package/src/cli/commands/checklists.ts +79 -0
package/src/cli/commands/custom-fields.ts +75 -0
package/src/cli/commands/labels.ts +47 -0
package/src/cli/commands/lists.ts +54 -0
package/src/cli/commands/members.ts +14 -0
package/src/cli/commands/orgs.ts +23 -0
package/src/cli/commands/run.ts +32 -0
package/src/cli/commands/search.ts +23 -0
package/src/cli/commands/ui.ts +48 -0
package/src/cli/commands/webhooks.ts +44 -0
package/src/cli/context.ts +70 -0
package/src/cli/index.ts +47 -0
package/src/cli/ui/app.tsx +753 -0
package/src/cli/ui/custom-fields.ts +75 -0
package/src/cli/ui/palette.ts +69 -0
package/src/cli/ui/shapes.ts +68 -0
package/src/cli/ui/static.tsx +382 -0
package/src/index.test.ts +117 -0
package/src/mcp/handlers.ts +61 -0
package/src/mcp/server.ts +17 -0
package/src/mcp/tools/api.ts +27 -0
package/src/mcp/tools/boards.ts +116 -0
package/src/mcp/tools/cards.ts +138 -0
package/src/mcp/tools/checklists.ts +40 -0
package/src/mcp/tools/index.ts +22 -0
package/src/mcp/tools/labels.ts +40 -0
package/src/mcp/tools/lists.ts +37 -0
package/src/mcp/tools/profiles.ts +40 -0
package/src/mcp/tools/search.ts +31 -0
package/src/mcp/tools/webhooks.ts +52 -0
package/src/util/runtime.ts +39 -0
package/src/version.ts +15 -0

package/src/api/http.ts ADDED Viewed

@@ -0,0 +1,86 @@
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+export type Query = Record<string, string | number | boolean | undefined>;
+export class TrelloError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+    readonly body: unknown,
+  ) {
+    super(message);
+    this.name = "TrelloError";
+  }
+}
+export type RequestOptions = {
+  timeoutMs?: number;
+  maxRetries?: number;
+};
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RETRIES = 3;
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryAfterMs(res: Response, attempt: number): number {
+  const header = res.headers.get("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) return seconds * 1000;
+  }
+  return Math.min(1000 * 2 ** attempt, 8000);
+}
+export async function trelloFetch(
+  url: URL,
+  init: RequestInit,
+  opts: RequestOptions = {},
+): Promise<Response> {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const res = await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (res.status !== 429 || attempt === maxRetries) {
+      return res;
+    }
+    await sleep(retryAfterMs(res, attempt));
+  }
+  throw new TrelloError("Rate limit exceeded", 429, null);
+}
+export function parseTrelloResponse(text: string): unknown {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+export function trelloErrorMessage(parsed: unknown, status: number): string {
+  if (
+    typeof parsed === "object" &&
+    parsed &&
+    "message" in parsed &&
+    typeof (parsed as { message: unknown }).message === "string"
+  ) {
+    return (parsed as { message: string }).message;
+  }
+  return `Trello API ${status}`;
+}

package/src/auth/browser-flow.ts ADDED Viewed

@@ -0,0 +1,217 @@
+import { randomBytes } from "node:crypto";
+import { createServer, type Server } from "node:http";
+import { openInBrowser } from "../util/runtime.ts";
+import { type AuthScope, authLoginUrl } from "./profiles.ts";
+export type BrowserAuthResult = {
+  token: string;
+  port: number;
+  returnUrl: string;
+};
+export type BrowserAuthError = {
+  error: string;
+  port: number;
+};
+const DEFAULT_PORT = 14189;
+function callbackCaptureHtml(state: string): string {
+  return `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>trelly</title></head>
+<body style="font-family: system-ui; max-width: 32rem; margin: 4rem auto; text-align: center;">
+  <p id="status">Finishing authorization…</p>
+  <script>
+    (function () {
+      var state = ${JSON.stringify(state)};
+      var params = new URLSearchParams(window.location.hash.replace(/^#/, ""));
+      var token = params.get("token");
+      var error = params.get("error");
+      var status = document.getElementById("status");
+      function post(path, body) {
+        return fetch(path, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+      }
+      if (error) {
+        post("/callback/error", { error: error, state: state }).finally(function () {
+          status.textContent = "Authorization denied: " + error;
+        });
+        return;
+      }
+      if (!token) {
+        status.textContent = "No token in callback URL. Check allowed origins in trelly auth setup.";
+        post("/callback/error", {
+          error: "No token in callback fragment — add http://127.0.0.1:${DEFAULT_PORT} to allowed origins",
+          state: state
+        });
+        return;
+      }
+      post("/callback/token", { token: token, state: state })
+        .then(function (res) { return res.json(); })
+        .then(function () {
+          status.textContent = "Connected! Return to your terminal.";
+        })
+        .catch(function () {
+          status.textContent = "Could not send token to trelly.";
+        });
+    })();
+  </script>
+</body>
+</html>`;
+}
+export function browserAuthorizeUrl(
+  apiKey: string,
+  port: number,
+  scope: AuthScope[] = ["read", "write"],
+): string {
+  return authLoginUrl(apiKey, {
+    returnUrl: `http://127.0.0.1:${port}/callback`,
+    scope,
+    expiration: "30days",
+  });
+}
+async function readJsonBody(
+  req: import("node:http").IncomingMessage,
+): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text ? JSON.parse(text) : {};
+}
+export async function captureTokenViaBrowser(
+  apiKey: string,
+  opts: {
+    port?: number;
+    timeoutMs?: number;
+    openBrowser?: boolean;
+    scope?: AuthScope[];
+  } = {},
+): Promise<BrowserAuthResult | BrowserAuthError> {
+  const port = opts.port ?? DEFAULT_PORT;
+  const timeoutMs = opts.timeoutMs ?? 120_000;
+  const returnUrl = `http://127.0.0.1:${port}/callback`;
+  const state = randomBytes(16).toString("hex");
+  const authorizeUrl = browserAuthorizeUrl(apiKey, port, opts.scope);
+  return new Promise((resolve) => {
+    let settled = false;
+    let httpServer: Server | undefined;
+    const finish = (result: BrowserAuthResult | BrowserAuthError) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      httpServer?.close();
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      finish({
+        error: "Timed out waiting for browser authorization",
+        port,
+      });
+    }, timeoutMs);
+    httpServer = createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (url.pathname === "/callback" && req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(callbackCaptureHtml(state));
+        return;
+      }
+      if (url.pathname === "/callback/token" && req.method === "POST") {
+        try {
+          const body = (await readJsonBody(req)) as { token?: string; state?: string };
+          if (body.state !== state) {
+            res.writeHead(403, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: "invalid state" }));
+            return;
+          }
+          if (!body.token) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false }));
+            finish({ error: "Empty token in callback", port });
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+          finish({ token: body.token, port, returnUrl });
+        } catch {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false }));
+          finish({ error: "Failed to read callback token", port });
+        }
+        return;
+      }
+      if (url.pathname === "/callback/error" && req.method === "POST") {
+        try {
+          const body = (await readJsonBody(req)) as { error?: string; state?: string };
+          if (body.state !== state) {
+            res.writeHead(403, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false }));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false }));
+          finish({ error: body.error ?? "Authorization denied", port });
+        } catch {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false }));
+          finish({ error: "Authorization failed", port });
+        }
+        return;
+      }
+      if (url.pathname === "/" || url.pathname === "/start") {
+        res.writeHead(302, { Location: authorizeUrl });
+        res.end();
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not found");
+    });
+    httpServer.listen(port, "127.0.0.1", () => {
+      if (opts.openBrowser !== false) {
+        openInBrowser(`http://127.0.0.1:${port}/start`).catch(() => {
+          process.stderr.write(
+            `Open this URL in your browser:\nhttp://127.0.0.1:${port}/start\n`,
+          );
+        });
+      } else {
+        process.stderr.write(
+          `Open this URL in your browser:\nhttp://127.0.0.1:${port}/start\n`,
+        );
+      }
+    });
+    httpServer.on("error", (err) => {
+      finish({
+        error:
+          err instanceof Error
+            ? `Local callback server failed on port ${port}: ${err.message}`
+            : `Local callback server failed on port ${port}`,
+        port,
+      });
+    });
+  });
+}
+export const SETUP_ALLOWED_ORIGIN = `http://127.0.0.1:${DEFAULT_PORT}`;

package/src/auth/profiles.ts ADDED Viewed

@@ -0,0 +1,163 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+const profileSchema = z.object({
+  apiKey: z.string().min(1),
+  token: z.string().min(1),
+  label: z.string().optional(),
+});
+const configSchema = z.object({
+  version: z.literal(1),
+  appApiKey: z.string().min(1).optional(),
+  defaultProfile: z.string().min(1),
+  profiles: z.record(z.string(), profileSchema),
+});
+export type Profile = z.infer<typeof profileSchema>;
+export type Config = z.infer<typeof configSchema>;
+const LEGACY_CONFIG_DIR = join(homedir(), ".config", "trello-cli");
+const CONFIG_DIR = join(homedir(), ".config", "trelly");
+const LEGACY_CONFIG_PATH = join(LEGACY_CONFIG_DIR, "config.json");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function readConfigPath(): string {
+  if (existsSync(CONFIG_PATH)) return CONFIG_PATH;
+  if (existsSync(LEGACY_CONFIG_PATH)) return LEGACY_CONFIG_PATH;
+  return CONFIG_PATH;
+}
+export function configPath(): string {
+  return CONFIG_PATH;
+}
+function emptyConfig(): Config {
+  return { version: 1, defaultProfile: "default", profiles: {} };
+}
+export function loadConfig(): Config {
+  const path = readConfigPath();
+  if (!existsSync(path)) {
+    return emptyConfig();
+  }
+  const raw = readFileSync(path, "utf8");
+  return configSchema.parse(JSON.parse(raw));
+}
+export function saveConfig(config: Config): void {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, {
+    mode: 0o600,
+  });
+  chmodSync(CONFIG_PATH, 0o600);
+}
+export function resolveProfile(name?: string): {
+  name: string;
+  profile: Profile;
+} {
+  const fromEnv = process.env.TRELLO_PROFILE;
+  const profileName = name ?? fromEnv ?? loadConfig().defaultProfile;
+  const envKey = process.env.TRELLO_API_KEY;
+  const envToken = process.env.TRELLO_TOKEN;
+  if (envKey && envToken && !name && !fromEnv) {
+    return {
+      name: "env",
+      profile: { apiKey: envKey, token: envToken, label: "environment" },
+    };
+  }
+  const config = loadConfig();
+  const profile = config.profiles[profileName];
+  if (!profile) {
+    const known = Object.keys(config.profiles);
+    throw new Error(
+      known.length === 0
+        ? `No Trello profile "${profileName}". Run: trelly auth login`
+        : `Unknown profile "${profileName}". Known: ${known.join(", ")}`,
+    );
+  }
+  return { name: profileName, profile };
+}
+export function upsertProfile(
+  name: string,
+  creds: Profile,
+  makeDefault = false,
+): Config {
+  const config = loadConfig();
+  config.profiles[name] = creds;
+  if (makeDefault || Object.keys(config.profiles).length === 1) {
+    config.defaultProfile = name;
+  }
+  saveConfig(config);
+  return config;
+}
+export function removeProfile(name: string): Config {
+  const config = loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  delete config.profiles[name];
+  const remaining = Object.keys(config.profiles);
+  if (remaining.length === 0) {
+    config.defaultProfile = "default";
+  } else if (config.defaultProfile === name) {
+    config.defaultProfile = remaining[0]!;
+  }
+  saveConfig(config);
+  return config;
+}
+export function setDefaultProfile(name: string): Config {
+  const config = loadConfig();
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  config.defaultProfile = name;
+  saveConfig(config);
+  return config;
+}
+export function setAppApiKey(apiKey: string): Config {
+  const config = loadConfig();
+  config.appApiKey = apiKey;
+  saveConfig(config);
+  return config;
+}
+export function getAppApiKey(): string | undefined {
+  return process.env.TRELLO_APP_API_KEY ?? loadConfig().appApiKey;
+}
+export type AuthScope = "read" | "write" | "account";
+export type AuthUrlOptions = {
+  returnUrl?: string;
+  expiration?: "1hour" | "1day" | "30days" | "never";
+  scope?: AuthScope[];
+  appName?: string;
+};
+export function authLoginUrl(apiKey: string, opts: AuthUrlOptions = {}): string {
+  const scope = opts.scope ?? ["read", "write"];
+  const params = new URLSearchParams({
+    key: apiKey,
+    name: opts.appName ?? "trelly",
+    expiration: opts.expiration ?? "30days",
+    response_type: "token",
+    scope: scope.join(","),
+  });
+  if (opts.returnUrl) {
+    params.set("callback_method", "fragment");
+    params.set("return_url", opts.returnUrl);
+  }
+  return `https://trello.com/1/authorize?${params}`;
+}

package/src/cli/commands/actions.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import { getClient } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+export function registerActionCommands(program: Command): void {
+  const actions = program.command("actions").description("Action (audit) operations");
+  actions
+    .command("get <id>")
+    .description("Get an action by id")
+    .action((id, _opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.actionGet(id);
+      }),
+    );
+}

package/src/cli/commands/api.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import type { Command } from "commander";
+import type { JsonValue } from "../../api/client.ts";
+import { TrelloError } from "../../api/client.ts";
+import {
+  failure,
+  getClient,
+  parseJsonFlag,
+  parseKvPairs,
+  printResult,
+  success,
+} from "../context.ts";
+import { rootOpts } from "./run.ts";
+export function registerApiCommand(program: Command): void {
+  program
+    .command("api")
+    .description("Raw Trello REST call (escape hatch)")
+    .requiredOption("-X, --method <method>", "HTTP method")
+    .requiredOption("--path <path>", "API path e.g. /boards/{id}")
+    .option("--query <kv...>", "Query key=value pairs")
+    .option("--body <json>", "JSON request body")
+    .action(async (opts, cmd) => {
+      const root = rootOpts(cmd);
+      try {
+        const { profileName, client } = getClient(root.profile);
+        const body = parseJsonFlag(opts.body, "--body");
+        const data = await client.request(
+          opts.method,
+          opts.path,
+          parseKvPairs(opts.query),
+          body as JsonValue | undefined,
+        );
+        printResult(success(profileName, data), root);
+      } catch (err) {
+        if (err instanceof TrelloError) {
+          printResult(
+            failure(err.message, { status: err.status, details: err.body }),
+            root,
+          );
+        } else {
+          printResult(failure(err instanceof Error ? err.message : String(err)), root);
+        }
+        process.exitCode = 1;
+      }
+    });
+}