skyboard-cli 0.1.0

package/src/__tests__/materialize.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect } from "vitest";
+import { materializeTasks } from "../lib/materialize.js";
+import {
+  OWNER_DID,
+  TRUSTED_DID,
+  USER_DID,
+  UNTRUSTED_DID,
+  BOARD_URI,
+  TASK_RKEY_1,
+  TASK_RKEY_2,
+  TASK_URI_1,
+  TASK_URI_2,
+  makeTask,
+  makeOp,
+} from "./helpers.js";
+
+describe("materializeTasks", () => {
+  const trustedDids = new Set([TRUSTED_DID]);
+
+  it("returns a materialized task with no ops applied", () => {
+    const task = makeTask();
+    const result = materializeTasks([task], [], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].effectiveTitle).toBe("Test Task");
+    expect(result[0].effectiveColumnId).toBe("col-todo");
+    expect(result[0].effectiveDescription).toBe("A task for testing");
+    expect(result[0].appliedOps).toHaveLength(0);
+    expect(result[0].sourceTask).toBe(task);
+  });
+
+  it("applies owner ops (per-field LWW)", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+    const op = makeOp({
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Updated Title" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].effectiveTitle).toBe("Updated Title");
+    expect(result[0].appliedOps).toHaveLength(1);
+  });
+
+  it("applies trusted user ops", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+    const op = makeOp({
+      did: TRUSTED_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { columnId: "col-done" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].effectiveColumnId).toBe("col-done");
+    expect(result[0].appliedOps).toHaveLength(1);
+  });
+
+  it("applies current user ops (even if not trusted)", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+    const op = makeOp({
+      did: USER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "My Edit" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].effectiveTitle).toBe("My Edit");
+    expect(result[0].appliedOps).toHaveLength(1);
+  });
+
+  it("filters out untrusted ops", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+    const op = makeOp({
+      did: UNTRUSTED_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Hacked Title" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].effectiveTitle).toBe("Test Task"); // unchanged
+    expect(result[0].appliedOps).toHaveLength(0);
+  });
+
+  it("resolves per-field LWW independently", () => {
+    const task = makeTask({
+      title: "Original",
+      description: "Original desc",
+      createdAt: "2025-01-01T00:00:00.000Z",
+    });
+
+    const op1 = makeOp({
+      rkey: "op1",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Title v2" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const op2 = makeOp({
+      rkey: "op2",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { description: "Desc v2" },
+      createdAt: "2025-01-03T00:00:00.000Z",
+    });
+
+    const op3 = makeOp({
+      rkey: "op3",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Title v3" },
+      createdAt: "2025-01-04T00:00:00.000Z",
+    });
+
+    const result = materializeTasks(
+      [task],
+      [op1, op2, op3],
+      trustedDids,
+      USER_DID,
+      OWNER_DID,
+    );
+
+    expect(result[0].effectiveTitle).toBe("Title v3");
+    expect(result[0].effectiveDescription).toBe("Desc v2");
+    expect(result[0].appliedOps).toHaveLength(3);
+  });
+
+  it("latest op wins (LWW) even if received out of order", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+
+    const earlyOp = makeOp({
+      rkey: "early",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Early" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const lateOp = makeOp({
+      rkey: "late",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Late" },
+      createdAt: "2025-01-03T00:00:00.000Z",
+    });
+
+    // Pass late op first — should still resolve to "Late"
+    const result = materializeTasks(
+      [task],
+      [lateOp, earlyOp],
+      trustedDids,
+      USER_DID,
+      OWNER_DID,
+    );
+
+    expect(result[0].effectiveTitle).toBe("Late");
+  });
+
+  it("does not apply op older than the task creation", () => {
+    const task = makeTask({ createdAt: "2025-01-05T00:00:00.000Z" });
+    const op = makeOp({
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Old Op" },
+      createdAt: "2025-01-01T00:00:00.000Z", // before task creation
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].effectiveTitle).toBe("Test Task"); // base task wins
+  });
+
+  it("deduplicates tasks with same did:rkey", () => {
+    const task = makeTask();
+    const dupe = makeTask(); // same rkey+did
+
+    const result = materializeTasks([task, dupe], [], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result).toHaveLength(1);
+  });
+
+  it("handles multiple tasks with separate ops", () => {
+    const task1 = makeTask({ rkey: TASK_RKEY_1 });
+    const task2 = makeTask({ rkey: TASK_RKEY_2, title: "Task 2" });
+
+    const op1 = makeOp({
+      rkey: "op-for-t1",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Task 1 Updated" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+    const op2 = makeOp({
+      rkey: "op-for-t2",
+      did: OWNER_DID,
+      targetTaskUri: TASK_URI_2,
+      fields: { title: "Task 2 Updated" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks(
+      [task1, task2],
+      [op1, op2],
+      trustedDids,
+      USER_DID,
+      OWNER_DID,
+    );
+
+    expect(result).toHaveLength(2);
+    expect(result[0].effectiveTitle).toBe("Task 1 Updated");
+    expect(result[1].effectiveTitle).toBe("Task 2 Updated");
+  });
+
+  it("tracks lastModifiedBy and lastModifiedAt", () => {
+    const task = makeTask({ createdAt: "2025-01-01T00:00:00.000Z" });
+    const op = makeOp({
+      did: TRUSTED_DID,
+      targetTaskUri: TASK_URI_1,
+      fields: { title: "Trusted Edit" },
+      createdAt: "2025-01-05T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, USER_DID, OWNER_DID);
+
+    expect(result[0].lastModifiedBy).toBe(TRUSTED_DID);
+    expect(result[0].lastModifiedAt).toBe("2025-01-05T00:00:00.000Z");
+  });
+
+  it("applies task author ops on their own task", () => {
+    const task = makeTask({
+      did: USER_DID,
+      rkey: TASK_RKEY_1,
+      createdAt: "2025-01-01T00:00:00.000Z",
+    });
+    // The task URI for user-owned task
+    const taskUri = `at://${USER_DID}/dev.skyboard.task/${TASK_RKEY_1}`;
+    const op = makeOp({
+      did: USER_DID,
+      targetTaskUri: taskUri,
+      fields: { title: "Author Edit" },
+      createdAt: "2025-01-02T00:00:00.000Z",
+    });
+
+    const result = materializeTasks([task], [op], trustedDids, "did:plc:somebodyelse", OWNER_DID);
+
+    expect(result[0].effectiveTitle).toBe("Author Edit");
+    expect(result[0].appliedOps).toHaveLength(1);
+  });
+});

package/src/__tests__/pds.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  OWNER_DID,
+  USER_DID,
+  BOARD_RKEY,
+  BOARD_URI,
+  TASK_RKEY_1,
+  PDS_ENDPOINT,
+  COLUMNS,
+  makePLCResponse,
+  makeListRecordsResponse,
+} from "./helpers.js";
+
+// We need to reset the pdsCache between tests since it's a module-level Map.
+// The simplest approach: re-import fresh each time via dynamic import + vi.resetModules.
+
+let resolvePDS: typeof import("../lib/pds.js").resolvePDS;
+let fetchBoard: typeof import("../lib/pds.js").fetchBoard;
+let resolveHandle: typeof import("../lib/pds.js").resolveHandle;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.restoreAllMocks();
+
+  const mod = await import("../lib/pds.js");
+  resolvePDS = mod.resolvePDS;
+  fetchBoard = mod.fetchBoard;
+  resolveHandle = mod.resolveHandle;
+});
+
+function stubFetch(handler: (url: string) => Response | Promise<Response>) {
+  const mockFetch = vi.fn(async (input: string | URL | Request) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    return handler(url);
+  });
+  vi.stubGlobal("fetch", mockFetch);
+  return mockFetch;
+}
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function textResponse(text: string, status = 200): Response {
+  return new Response(text, { status });
+}
+
+describe("resolvePDS", () => {
+  it("resolves a did:plc via plc.directory", async () => {
+    stubFetch((url) => {
+      if (url.includes("plc.directory")) {
+        return jsonResponse(makePLCResponse(OWNER_DID, PDS_ENDPOINT));
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolvePDS(OWNER_DID);
+    expect(result).toBe(PDS_ENDPOINT);
+  });
+
+  it("resolves a did:web via .well-known/did.json", async () => {
+    const webDid = "did:web:example.com";
+    stubFetch((url) => {
+      if (url.includes("example.com/.well-known/did.json")) {
+        return jsonResponse(makePLCResponse(webDid, PDS_ENDPOINT));
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolvePDS(webDid);
+    expect(result).toBe(PDS_ENDPOINT);
+  });
+
+  it("returns null for unknown DID method", async () => {
+    stubFetch(() => new Response("", { status: 404 }));
+    const result = await resolvePDS("did:key:z12345");
+    expect(result).toBeNull();
+  });
+
+  it("returns null on fetch failure", async () => {
+    stubFetch(() => new Response("", { status: 500 }));
+    const result = await resolvePDS(OWNER_DID);
+    expect(result).toBeNull();
+  });
+
+  it("caches resolved PDS endpoints", async () => {
+    const mockFetch = stubFetch((url) => {
+      if (url.includes("plc.directory")) {
+        return jsonResponse(makePLCResponse(OWNER_DID, PDS_ENDPOINT));
+      }
+      return new Response("", { status: 404 });
+    });
+
+    await resolvePDS(OWNER_DID);
+    await resolvePDS(OWNER_DID);
+
+    // Should only call fetch once (second call uses cache)
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("fetchBoard", () => {
+  it("fetches and parses a board record", async () => {
+    const boardRecord = {
+      $type: "dev.skyboard.board",
+      name: "Test Board",
+      description: "A test board",
+      columns: COLUMNS,
+      createdAt: "2025-01-01T00:00:00.000Z",
+    };
+
+    stubFetch((url) => {
+      if (url.includes("plc.directory")) {
+        return jsonResponse(makePLCResponse(OWNER_DID, PDS_ENDPOINT));
+      }
+      if (url.includes("getRecord")) {
+        return jsonResponse({ uri: `at://${OWNER_DID}/dev.skyboard.board/${BOARD_RKEY}`, value: boardRecord });
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const board = await fetchBoard(OWNER_DID, BOARD_RKEY);
+    expect(board).not.toBeNull();
+    expect(board!.name).toBe("Test Board");
+    expect(board!.columns).toEqual(COLUMNS);
+    expect(board!.did).toBe(OWNER_DID);
+    expect(board!.rkey).toBe(BOARD_RKEY);
+  });
+
+  it("returns null when board not found", async () => {
+    stubFetch((url) => {
+      if (url.includes("plc.directory")) {
+        return jsonResponse(makePLCResponse(OWNER_DID, PDS_ENDPOINT));
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const board = await fetchBoard(OWNER_DID, "nonexistent");
+    expect(board).toBeNull();
+  });
+
+  it("returns null when PDS cannot be resolved", async () => {
+    stubFetch(() => new Response("", { status: 500 }));
+    const board = await fetchBoard(OWNER_DID, BOARD_RKEY);
+    expect(board).toBeNull();
+  });
+});
+
+describe("resolveHandle", () => {
+  it("resolves via .well-known/atproto-did", async () => {
+    stubFetch((url) => {
+      if (url.includes(".well-known/atproto-did")) {
+        return textResponse(OWNER_DID);
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolveHandle("alice.example.com");
+    expect(result).toBe(OWNER_DID);
+  });
+
+  it("falls back to bsky.social resolution", async () => {
+    stubFetch((url) => {
+      if (url.includes(".well-known/atproto-did")) {
+        return new Response("", { status: 404 });
+      }
+      if (url.includes("bsky.social/xrpc/com.atproto.identity.resolveHandle")) {
+        return jsonResponse({ did: USER_DID });
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolveHandle("bob.bsky.social");
+    expect(result).toBe(USER_DID);
+  });
+
+  it("returns null when all resolution methods fail", async () => {
+    stubFetch(() => new Response("", { status: 404 }));
+
+    const result = await resolveHandle("nobody.example.com");
+    expect(result).toBeNull();
+  });
+
+  it("trims whitespace from .well-known response", async () => {
+    stubFetch((url) => {
+      if (url.includes(".well-known/atproto-did")) {
+        return textResponse(`  ${OWNER_DID}  \n`);
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolveHandle("alice.example.com");
+    expect(result).toBe(OWNER_DID);
+  });
+
+  it("rejects .well-known response that is not a DID", async () => {
+    stubFetch((url) => {
+      if (url.includes(".well-known/atproto-did")) {
+        return textResponse("not-a-did");
+      }
+      if (url.includes("bsky.social")) {
+        return new Response("", { status: 404 });
+      }
+      return new Response("", { status: 404 });
+    });
+
+    const result = await resolveHandle("alice.example.com");
+    expect(result).toBeNull();
+  });
+});

package/src/commands/add.ts

@@ -0,0 +1,47 @@
+import { requireAgent } from "../lib/auth.js";
+import { fetchBoard } from "../lib/pds.js";
+import { addKnownBoard } from "../lib/config.js";
+import { BOARD_COLLECTION } from "../lib/tid.js";
+import chalk from "chalk";
+
+export async function addCommand(link: string): Promise<void> {
+  await requireAgent();
+
+  let boardDid: string | undefined;
+  let boardRkey: string | undefined;
+
+  // Parse AT URI
+  if (link.startsWith("at://")) {
+    const parts = link.replace("at://", "").split("/");
+    if (parts.length >= 3 && parts[1] === BOARD_COLLECTION) {
+      boardDid = parts[0];
+      boardRkey = parts[2];
+    }
+  }
+
+  // Parse web URL
+  if (!boardDid && (link.startsWith("http://") || link.startsWith("https://"))) {
+    const url = new URL(link);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    if (pathParts.length >= 3 && pathParts[0] === "board") {
+      boardDid = pathParts[1];
+      boardRkey = pathParts[2];
+    }
+  }
+
+  if (!boardDid || !boardRkey) {
+    console.error(chalk.red("Could not parse board link. Provide an AT URI or web URL."));
+    console.error(chalk.dim("  AT URI: at://did:plc:xxx/dev.skyboard.board/rkey"));
+    console.error(chalk.dim("  URL:    https://skyboard.dev/board/did:plc:xxx/rkey"));
+    process.exit(1);
+  }
+
+  const board = await fetchBoard(boardDid, boardRkey);
+  if (!board) {
+    console.error(chalk.red("Board not found."));
+    process.exit(1);
+  }
+
+  addKnownBoard({ did: boardDid, rkey: boardRkey, name: board.name });
+  console.log(chalk.green(`Added board: ${chalk.bold(board.name)}`));
+}

package/src/commands/boards.ts

@@ -0,0 +1,64 @@
+import { requireAgent } from "../lib/auth.js";
+import { fetchMyBoards, fetchBoardData } from "../lib/pds.js";
+import { loadConfig, getDefaultBoard } from "../lib/config.js";
+import { buildAtUri, BOARD_COLLECTION } from "../lib/tid.js";
+import chalk from "chalk";
+
+export async function boardsCommand(opts: { json?: boolean }): Promise<void> {
+  const { agent, did } = await requireAgent();
+
+  const boards = await fetchMyBoards(agent, did);
+
+  // Also include known boards from other users
+  const config = loadConfig();
+  const defaultBoard = getDefaultBoard();
+
+  if (opts.json) {
+    console.log(JSON.stringify(boards.map((b) => ({
+      rkey: b.rkey,
+      did: b.did,
+      name: b.name,
+      description: b.description,
+      columns: b.columns.length,
+      open: b.open ?? false,
+    })), null, 2));
+    return;
+  }
+
+  if (boards.length === 0) {
+    console.log("No boards found.");
+    return;
+  }
+
+  console.log(chalk.bold("Your boards:\n"));
+
+  for (const board of boards) {
+    const isDefault = defaultBoard?.did === board.did && defaultBoard?.rkey === board.rkey;
+    const marker = isDefault ? chalk.green(" *") : "  ";
+    const cols = board.columns.sort((a, b) => a.order - b.order);
+    const colSummary = cols.map((c) => c.name).join(" | ");
+
+    console.log(`${marker} ${chalk.bold(board.name)} ${chalk.dim(`(${board.rkey})`)}`);
+    if (board.description) {
+      console.log(`    ${chalk.dim(board.description)}`);
+    }
+    console.log(`    ${chalk.dim(colSummary)}`);
+    console.log();
+  }
+
+  // Show known boards from other users
+  const otherBoards = config.knownBoards.filter((b) => b.did !== did);
+  if (otherBoards.length > 0) {
+    console.log(chalk.bold("Joined boards:\n"));
+    for (const board of otherBoards) {
+      const isDefault = defaultBoard?.did === board.did && defaultBoard?.rkey === board.rkey;
+      const marker = isDefault ? chalk.green(" *") : "  ";
+      console.log(`${marker} ${chalk.bold(board.name)} ${chalk.dim(`(${board.did.slice(0, 20)}.../${board.rkey})`)}`);
+    }
+    console.log();
+  }
+
+  if (defaultBoard) {
+    console.log(chalk.dim(`* = default board. Change with: sb use <board>`));
+  }
+}

package/src/commands/cards.ts

@@ -0,0 +1,65 @@
+import { requireAgent } from "../lib/auth.js";
+import { fetchBoardData } from "../lib/pds.js";
+import { getDefaultBoard } from "../lib/config.js";
+import { printBoardCards, shortRkey, formatDate } from "../lib/display.js";
+import chalk from "chalk";
+
+export async function cardsCommand(opts: {
+  column?: string;
+  label?: string;
+  search?: string;
+  board?: string;
+  json?: boolean;
+}): Promise<void> {
+  const { did } = await requireAgent();
+
+  const boardRef = resolveBoard(opts.board);
+
+  const data = await fetchBoardData(boardRef.did, boardRef.rkey, did);
+  if (!data) {
+    console.error(chalk.red("Board not found."));
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    const sorted = [...data.board.columns].sort((a, b) => a.order - b.order);
+    const result = sorted.map((col) => ({
+      column: col.name,
+      cards: data.tasks
+        .filter((t) => t.effectiveColumnId === col.id)
+        .sort((a, b) => a.effectivePosition.localeCompare(b.effectivePosition))
+        .map((t) => ({
+          rkey: t.rkey,
+          shortRef: shortRkey(t.rkey),
+          title: t.effectiveTitle,
+          description: t.effectiveDescription,
+          labels: t.effectiveLabelIds,
+          createdAt: t.createdAt,
+          lastModifiedAt: t.lastModifiedAt,
+        })),
+    }));
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold(data.board.name));
+  printBoardCards(data.board, data.tasks, {
+    column: opts.column,
+    label: opts.label,
+    search: opts.search,
+  });
+}
+
+function resolveBoard(boardOpt?: string): { did: string; rkey: string } {
+  if (boardOpt) {
+    const defaultBoard = getDefaultBoard();
+    if (defaultBoard) return defaultBoard;
+  }
+
+  const defaultBoard = getDefaultBoard();
+  if (!defaultBoard) {
+    console.error(chalk.red("No default board set. Run `sb use <board>` first."));
+    process.exit(1);
+  }
+  return defaultBoard;
+}

package/src/commands/cols.ts

@@ -0,0 +1,51 @@
+import { requireAgent } from "../lib/auth.js";
+import { fetchBoardData } from "../lib/pds.js";
+import { getDefaultBoard } from "../lib/config.js";
+import chalk from "chalk";
+
+export async function colsCommand(opts: { board?: string; json?: boolean }): Promise<void> {
+  const { did } = await requireAgent();
+
+  const boardRef = resolveBoard(opts.board);
+
+  const data = await fetchBoardData(boardRef.did, boardRef.rkey, did);
+  if (!data) {
+    console.error(chalk.red("Board not found."));
+    process.exit(1);
+  }
+
+  const sortedColumns = [...data.board.columns].sort((a, b) => a.order - b.order);
+
+  if (opts.json) {
+    console.log(JSON.stringify(sortedColumns.map((col, i) => ({
+      index: i + 1,
+      id: col.id,
+      name: col.name,
+      taskCount: data.tasks.filter((t) => t.effectiveColumnId === col.id).length,
+    })), null, 2));
+    return;
+  }
+
+  console.log(chalk.bold(data.board.name) + "\n");
+
+  for (let i = 0; i < sortedColumns.length; i++) {
+    const col = sortedColumns[i];
+    const count = data.tasks.filter((t) => t.effectiveColumnId === col.id).length;
+    console.log(`  ${chalk.dim(`${i + 1}.`)} ${col.name} ${chalk.dim(`(${count})`)}`);
+  }
+}
+
+function resolveBoard(boardOpt?: string): { did: string; rkey: string } {
+  if (boardOpt) {
+    // TODO: support full board ref parsing like use command
+    const defaultBoard = getDefaultBoard();
+    if (defaultBoard) return defaultBoard;
+  }
+
+  const defaultBoard = getDefaultBoard();
+  if (!defaultBoard) {
+    console.error(chalk.red("No default board set. Run `sb use <board>` first."));
+    process.exit(1);
+  }
+  return defaultBoard;
+}