trelly 0.1.0

package/src/cli/commands/auth.ts

@@ -0,0 +1,248 @@
+import type { Command } from "commander";
+import { createClient } from "../../api/client.ts";
+import {
+  captureTokenViaBrowser,
+  SETUP_ALLOWED_ORIGIN,
+} from "../../auth/browser-flow.ts";
+import {
+  type AuthScope,
+  authLoginUrl,
+  configPath,
+  getAppApiKey,
+  loadConfig,
+  removeProfile,
+  setAppApiKey,
+  setDefaultProfile,
+  upsertProfile,
+} from "../../auth/profiles.ts";
+import { openInBrowser, readLine } from "../../util/runtime.ts";
+import { failure, printResult, success } from "../context.ts";
+import { rootOpts } from "./run.ts";
+
+const POWER_UPS_ADMIN = "https://trello.com/power-ups/admin";
+
+export function registerAuthCommands(program: Command): void {
+  const auth = program.command("auth").description("Manage Trello credentials");
+
+  auth
+    .command("setup")
+    .description("One-time app setup: save API key + allowed-origin instructions")
+    .option("-k, --api-key <key>", "Trello API key to save")
+    .option("--no-open", "Do not open Power-Ups admin in the browser")
+    .action(async (opts, cmd) => {
+      const root = rootOpts(cmd);
+      try {
+        if (opts.open !== false) {
+          process.stderr.write(`Opening ${POWER_UPS_ADMIN}\n`);
+          await openInBrowser(POWER_UPS_ADMIN).catch(() => {
+            process.stderr.write(`Open manually: ${POWER_UPS_ADMIN}\n`);
+          });
+        }
+
+        process.stderr.write(`
+One-time setup (per Trello account / Power-Up):
+
+1. Create or open a Power-Up → API Key tab → Generate API Key
+   (Pick any workspace you admin — personal is fine. This does not
+   limit which boards you can use. Never install the app on a board.)
+2. Allowed Origins → add: ${SETUP_ALLOWED_ORIGIN}
+   (required for automatic browser login)
+3. Paste your API key below
+
+`);
+
+        let apiKey = opts.apiKey as string | undefined;
+        if (!apiKey) {
+          process.stderr.write("API key: ");
+          apiKey = (await readLine()).trim();
+        }
+
+        if (!apiKey) {
+          throw new Error("API key is required");
+        }
+
+        setAppApiKey(apiKey);
+        printResult(
+          success("default", {
+            message: "Saved app API key for trelly",
+            configPath: configPath(),
+            allowedOrigin: SETUP_ALLOWED_ORIGIN,
+            next: "Run: trelly auth login",
+          }),
+          root,
+        );
+      } catch (err) {
+        printResult(failure(err instanceof Error ? err.message : String(err)), root);
+        process.exitCode = 1;
+      }
+    });
+
+  auth
+    .command("login")
+    .description("Authorize a profile via browser (default) or manual token paste")
+    .option("-p, --profile <name>", "Profile name", "default")
+    .option("-k, --api-key <key>", "Override app API key for this login")
+    .option("-t, --token <token>", "Token (skips browser flow)")
+    .option(
+      "--manual",
+      "Skip browser callback; paste token after opening authorize URL",
+    )
+    .option("--no-open", "Do not open a browser automatically")
+    .option("--default", "Set as default profile")
+    .option("--label <label>", "Human label for this profile")
+    .option(
+      "--full-access",
+      "Request read,write,account scope and never-expiring token",
+    )
+    .action(async (opts, cmd) => {
+      const root = rootOpts(cmd);
+      try {
+        let apiKey = (opts.apiKey as string | undefined) ?? getAppApiKey() ?? undefined;
+        let token = opts.token as string | undefined;
+
+        if (!apiKey) {
+          process.stderr.write("No app API key saved. Running guided setup...\n\n");
+          if (opts.open !== false) {
+            await openInBrowser(POWER_UPS_ADMIN).catch(() => undefined);
+          }
+          process.stderr.write(
+            `Create a Power-Up API key at ${POWER_UPS_ADMIN}\n` +
+              `Add allowed origin: ${SETUP_ALLOWED_ORIGIN}\n` +
+              "API key: ",
+          );
+          apiKey = (await readLine()).trim();
+          if (!apiKey) throw new Error("API key is required");
+          setAppApiKey(apiKey);
+        }
+
+        const authScope: AuthScope[] = opts.fullAccess
+          ? ["read", "write", "account"]
+          : ["read", "write"];
+        const authExpiration = opts.fullAccess
+          ? ("never" as const)
+          : ("30days" as const);
+
+        if (!token) {
+          if (opts.manual) {
+            const url = authLoginUrl(apiKey, {
+              scope: authScope,
+              expiration: authExpiration,
+            });
+            process.stderr.write(`Authorize in browser:\n${url}\n`);
+            if (opts.open !== false) {
+              await openInBrowser(url).catch(() => undefined);
+            }
+            process.stderr.write("Paste token: ");
+            token = (await readLine()).trim();
+          } else {
+            process.stderr.write("Opening browser for Trello authorization...\n");
+            const result = await captureTokenViaBrowser(apiKey, {
+              openBrowser: opts.open !== false,
+              scope: authScope,
+            });
+            if ("error" in result) {
+              throw new Error(
+                `${result.error}\n` +
+                  `If redirect was blocked, run:\n` +
+                  `  trelly auth setup   # add ${SETUP_ALLOWED_ORIGIN} to allowed origins\n` +
+                  `  trelly auth login --manual`,
+              );
+            }
+            token = result.token;
+          }
+        }
+
+        if (!token) {
+          throw new Error("Token is required");
+        }
+
+        upsertProfile(opts.profile, { apiKey, token, label: opts.label }, opts.default);
+
+        const client = createClient(apiKey, token);
+        const me = await client.memberMe("fullName,username,url");
+
+        printResult(
+          success(opts.profile, {
+            message: `Saved profile "${opts.profile}"`,
+            configPath: configPath(),
+            member: me,
+          }),
+          root,
+        );
+      } catch (err) {
+        printResult(failure(err instanceof Error ? err.message : String(err)), root);
+        process.exitCode = 1;
+      }
+    });
+
+  auth
+    .command("list")
+    .description("List saved profiles")
+    .action((_opts, cmd) => {
+      const root = rootOpts(cmd);
+      const config = loadConfig();
+      printResult(
+        success(config.defaultProfile, {
+          defaultProfile: config.defaultProfile,
+          hasAppApiKey: Boolean(config.appApiKey ?? process.env.TRELLO_APP_API_KEY),
+          profiles: Object.entries(config.profiles).map(([name, p]) => ({
+            name,
+            label: p.label,
+            isDefault: name === config.defaultProfile,
+          })),
+        }),
+        root,
+      );
+    });
+
+  auth
+    .command("use <profile>")
+    .description("Set default profile")
+    .action((profile, _opts, cmd) => {
+      const root = rootOpts(cmd);
+      try {
+        setDefaultProfile(profile);
+        printResult(
+          success(profile, { message: `Default profile is now "${profile}"` }),
+          root,
+        );
+      } catch (err) {
+        printResult(failure(err instanceof Error ? err.message : String(err)), root);
+        process.exitCode = 1;
+      }
+    });
+
+  auth
+    .command("logout")
+    .description("Remove a saved profile")
+    .option("-p, --profile <name>", "Profile to remove")
+    .action((opts, cmd) => {
+      const root = rootOpts(cmd);
+      const config = loadConfig();
+      const profile = opts.profile ?? config.defaultProfile;
+      try {
+        removeProfile(profile);
+        printResult(
+          success(profile, { message: `Removed profile "${profile}"` }),
+          root,
+        );
+      } catch (err) {
+        printResult(failure(err instanceof Error ? err.message : String(err)), root);
+        process.exitCode = 1;
+      }
+    });
+
+  auth
+    .command("url")
+    .description("Print browser authorization URL")
+    .option("-k, --api-key <key>", "Trello API key")
+    .action(async (opts, cmd) => {
+      const root = rootOpts(cmd);
+      let apiKey = (opts.apiKey as string | undefined) ?? getAppApiKey() ?? undefined;
+      if (!apiKey) {
+        process.stderr.write("API key: ");
+        apiKey = (await readLine()).trim();
+      }
+      printResult(success("env", { url: authLoginUrl(apiKey) }), root);
+    });
+}

package/src/cli/commands/boards.ts

@@ -0,0 +1,152 @@
+import type { Command } from "commander";
+import { getClient, parseJsonFlag, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerBoardCommands(program: Command): void {
+  const boards = program.command("boards").description("Board operations");
+
+  boards
+    .command("list")
+    .description("List boards for the current member")
+    .option("--fields <fields>", "Comma-separated fields")
+    .option("--filter <filter>", "Board filter e.g. open")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.memberBoards("me", {
+          fields: opts.fields,
+          filter: opts.filter ?? "open",
+        });
+      }),
+    );
+
+  boards
+    .command("get <id>")
+    .description("Get a board")
+    .option("--fields <fields>", "Comma-separated fields")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardGet(id, { fields: opts.fields });
+      }),
+    );
+
+  boards
+    .command("create")
+    .description("Create a board")
+    .requiredOption("--name <name>", "Board name")
+    .option("--desc <desc>", "Description")
+    .option("--org <id>", "Workspace id")
+    .option("--default-lists", "Create default lists")
+    .option("--params <kv...>", "Extra key=value params")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardCreate({
+          name: opts.name,
+          desc: opts.desc,
+          idOrganization: opts.org,
+          defaultLists: opts.defaultLists,
+          ...parseKvPairs(opts.params),
+        });
+      }),
+    );
+
+  boards
+    .command("update <id>")
+    .description("Update a board")
+    .option("--params <kv...>", "key=value params")
+    .option("--json <json>", "JSON body merged with params")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        const body = {
+          ...parseKvPairs(opts.params),
+          ...(parseJsonFlag(opts.json, "--json") as object),
+        };
+        return client.boardUpdate(id, body);
+      }),
+    );
+
+  boards
+    .command("archive <id>")
+    .description("Close (archive) a board — reversible in Trello UI")
+    .action((id, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardArchive(id);
+      }),
+    );
+
+  boards
+    .command("delete <id>")
+    .description("Permanently delete a board — irreversible")
+    .action((id, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardDelete(id);
+      }),
+    );
+
+  boards
+    .command("lists <boardId>")
+    .description("List lists on a board")
+    .option("--filter <filter>", "open|closed|all", "open")
+    .action((boardId, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardLists(boardId, { filter: opts.filter });
+      }),
+    );
+
+  boards
+    .command("cards <boardId>")
+    .description("List cards on a board")
+    .action((boardId, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardCards(boardId);
+      }),
+    );
+
+  boards
+    .command("labels <boardId>")
+    .description("List labels on a board")
+    .action((boardId, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardLabels(boardId);
+      }),
+    );
+
+  boards
+    .command("members <boardId>")
+    .description("List board members")
+    .action((boardId, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardMembers(boardId);
+      }),
+    );
+
+  boards
+    .command("actions <boardId>")
+    .description("Board activity feed")
+    .option("--limit <n>", "Max actions", "50")
+    .action((boardId, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardActions(boardId, { limit: opts.limit });
+      }),
+    );
+
+  boards
+    .command("custom-fields <boardId>")
+    .description("List custom field definitions")
+    .action((boardId, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.boardCustomFields(boardId);
+      }),
+    );
+}

package/src/cli/commands/cards.ts

@@ -0,0 +1,194 @@
+import type { Command } from "commander";
+import { getClient, parseJsonFlag, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerCardCommands(program: Command): void {
+  const cards = program.command("cards").description("Card operations");
+
+  cards
+    .command("get <id>")
+    .option("--fields <fields>", "Comma-separated fields")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardGet(id, { fields: opts.fields });
+      }),
+    );
+
+  cards
+    .command("list")
+    .description("List cards on a list")
+    .requiredOption("--list <listId>", "List id")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.listCards(opts.list);
+      }),
+    );
+
+  cards
+    .command("create")
+    .requiredOption("--list <listId>", "Target list")
+    .requiredOption("--name <name>", "Card name")
+    .option("--desc <desc>", "Description")
+    .option("--due <iso>", "Due date ISO8601")
+    .option("--pos <pos>", "Position")
+    .option("--params <kv...>", "Extra key=value params")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardCreate({
+          idList: opts.list,
+          name: opts.name,
+          desc: opts.desc,
+          due: opts.due,
+          pos: opts.pos,
+          ...parseKvPairs(opts.params),
+        });
+      }),
+    );
+
+  cards
+    .command("update <id>")
+    .option("--params <kv...>", "key=value params")
+    .option("--json <json>", "JSON body")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardUpdate(id, {
+          ...parseKvPairs(opts.params),
+          ...(parseJsonFlag(opts.json, "--json") as object),
+        });
+      }),
+    );
+
+  cards
+    .command("move <id>")
+    .description("Move card to another list")
+    .requiredOption("--list <listId>", "Destination list")
+    .option("--pos <pos>", "Position")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardUpdate(id, { idList: opts.list, pos: opts.pos });
+      }),
+    );
+
+  cards
+    .command("comments <id>")
+    .description("List comments on a card")
+    .option("--limit <n>", "Max comments", "50")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardComments(id, { limit: opts.limit });
+      }),
+    );
+
+  cards
+    .command("comment <id>")
+    .requiredOption("--text <text>", "Comment body")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardComment(id, opts.text);
+      }),
+    );
+
+  cards
+    .command("archive <id>")
+    .description("Close (archive) a card — reversible in Trello UI")
+    .action((id, _opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardArchive(id);
+      }),
+    );
+
+  cards
+    .command("delete <id>")
+    .description("Permanently delete a card — irreversible")
+    .action((id, _opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardDelete(id);
+      }),
+    );
+
+  cards.command("members <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardMembers(id);
+    }),
+  );
+
+  cards.command("add-member <id> <memberId>").action((id, memberId, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardAddMember(id, memberId);
+    }),
+  );
+
+  cards.command("remove-member <id> <memberId>").action((id, memberId, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardRemoveMember(id, memberId);
+    }),
+  );
+
+  cards.command("labels <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardLabels(id);
+    }),
+  );
+
+  cards.command("add-label <id> <labelId>").action((id, labelId, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardAddLabel(id, labelId);
+    }),
+  );
+
+  cards.command("remove-label <id> <labelId>").action((id, labelId, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardRemoveLabel(id, labelId);
+    }),
+  );
+
+  cards
+    .command("actions <id>")
+    .option("--limit <n>", "Max actions", "50")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardActions(id, { limit: opts.limit });
+      }),
+    );
+
+  cards.command("attachments <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardAttachments(id);
+    }),
+  );
+
+  cards
+    .command("add-attachment <id>")
+    .requiredOption("--url <url>", "Attachment URL")
+    .option("--name <name>", "Attachment name")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.cardAddAttachment(id, { url: opts.url, name: opts.name });
+      }),
+    );
+
+  cards.command("custom-fields <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.cardCustomFieldItems(id);
+    }),
+  );
+}

package/src/cli/commands/checklists.ts

@@ -0,0 +1,79 @@
+import type { Command } from "commander";
+import { getClient, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerChecklistCommands(program: Command): void {
+  const checklists = program.command("checklists").description("Checklist operations");
+
+  checklists.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.checklistGet(id);
+    }),
+  );
+
+  checklists
+    .command("create")
+    .requiredOption("--card <cardId>", "Card id")
+    .requiredOption("--name <name>", "Checklist name")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.checklistCreate({ idCard: opts.card, name: opts.name });
+      }),
+    );
+
+  checklists
+    .command("update <id>")
+    .option("--params <kv...>", "key=value params")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.checklistUpdate(id, parseKvPairs(opts.params));
+      }),
+    );
+
+  checklists.command("delete <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.checklistDelete(id);
+    }),
+  );
+
+  checklists
+    .command("add-item <id>")
+    .requiredOption("--name <name>", "Item name")
+    .option("--checked", "Mark checked")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.checklistAddItem(id, {
+          name: opts.name,
+          checked: opts.checked,
+        });
+      }),
+    );
+
+  checklists
+    .command("update-item <checklistId> <itemId>")
+    .option("--params <kv...>", "key=value params")
+    .action((checklistId, itemId, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.checklistUpdateItem(
+          checklistId,
+          itemId,
+          parseKvPairs(opts.params),
+        );
+      }),
+    );
+
+  checklists
+    .command("delete-item <checklistId> <itemId>")
+    .action((checklistId, itemId, _opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.checklistDeleteItem(checklistId, itemId);
+      }),
+    );
+}