@terminal49/bridge-cli 0.1.1 → 0.1.3

package/README.md

@@ -1,10 +1,11 @@
 # @terminal49/bridge-cli
 
-Private npm package containing the Bridge CLI meeting search skill for LLMs.
+Public npm package containing the Bridge CLI and meeting search skill for LLMs.
 
 ## Contents
 
 - `SKILL.md` — instructions for using the Bridge CLI to search Fathom meetings.
+- CLI binary `t49bridge`
 
 ## Install
 
@@ -12,4 +13,23 @@ Private npm package containing the Bridge CLI meeting search skill for LLMs.
 npm install @terminal49/bridge-cli
 ```
 
-Then open `node_modules/@terminal49/bridge-cli/SKILL.md`.
+Or install globally:
+
+```bash
+npm install -g @terminal49/bridge-cli
+```
+
+Or run directly:
+
+```bash
+npx @terminal49/bridge-cli -- help
+```
+
+## Usage
+
+```bash
+t49bridge login
+t49bridge query "export status blocker" --limit 5
+```
+
+Then open `node_modules/@terminal49/bridge-cli/SKILL.md` for the full workflow.

package/SKILL.md

@@ -7,33 +7,37 @@ description: Search Terminal49 Fathom meeting transcripts, retrieve meeting deta
 
 Search and retrieve meeting data from Terminal49's Fathom.video ingestion platform via the Bridge CLI.
 
-## Prerequisites
+## Install
 
-The CLI requires authentication. If commands fail with "Not logged in", run:
+Install the public npm package (CLI included):
 
 ```bash
-npm run cli:t49bridge -- login
+npm install -g @terminal49/bridge-cli
 ```
 
-Verify with:
+Or run via npx:
 
 ```bash
-npm run cli:t49bridge -- whoami
+npx @terminal49/bridge-cli -- help
 ```
 
-## Repo Setup
+## Prerequisites
+
+The CLI requires authentication. If commands fail with "Not logged in", run:
 
-Clone the Bridge repo and install dependencies:
+```bash
+t49bridge login
+```
+
+Verify with:
 
 ```bash
-git clone https://github.com/Terminal49/bridge.git
-cd bridge
-npm install
+t49bridge whoami
 ```
 
 ## Commands
 
-Run commands from the cloned repo directory.
+Use `t49bridge` if installed globally or via npx.
 
 ### Search Transcripts
 
@@ -41,13 +45,13 @@ Three search modes — use `query` (hybrid) by default:
 
 ```bash
 # Hybrid search (recommended) — combines keyword + semantic
-npm run cli:t49bridge -- query "<natural language question>" --limit 10
+t49bridge query "<natural language question>" --limit 10
 
 # Keyword search (BM25) — best for exact terms, names, product names
-npm run cli:t49bridge -- search "<keywords>" --limit 10
+t49bridge search "<keywords>" --limit 10
 
 # Semantic search — best for conceptual/meaning-based queries
-npm run cli:t49bridge -- vsearch "<description of what you're looking for>" --limit 10
+t49bridge vsearch "<description of what you're looking for>" --limit 10
 ```
 
 #### Search filters (work with all three modes)
@@ -74,34 +78,34 @@ npm run cli:t49bridge -- vsearch "<description of what you're looking for>" --li
 
 ```bash
 # Summary and metadata
-npm run cli:t49bridge -- get <meetingId>
+t49bridge get <meetingId>
 
 # Just the summary
-npm run cli:t49bridge -- get <meetingId> --summary
+t49bridge get <meetingId> --summary
 
 # Full transcript
-npm run cli:t49bridge -- get <meetingId> --transcript
+t49bridge get <meetingId> --transcript
 
 # Timestamped segments
-npm run cli:t49bridge -- get <meetingId> --segments
+t49bridge get <meetingId> --segments
 
 # JSON output
-npm run cli:t49bridge -- get <meetingId> --json
+t49bridge get <meetingId> --json
 ```
 
 ### List Meetings
 
 ```bash
 # Recent meetings
-npm run cli:t49bridge -- list --limit 20
+t49bridge list --limit 20
 
 # Filter by date, company, host, type
-npm run cli:t49bridge -- list --from 2026-01-01 --to 2026-01-31 --company "Maersk"
-npm run cli:t49bridge -- list --host "akshay" --external --limit 50
-npm run cli:t49bridge -- list --attendee "john@example.com"
+t49bridge list --from 2026-01-01 --to 2026-01-31 --company "Maersk"
+t49bridge list --host "akshay" --external --limit 50
+t49bridge list --attendee "john@example.com"
 
 # JSON output
-npm run cli:t49bridge -- list --json --limit 100
+t49bridge list --json --limit 100
 ```
 
 ## Workflow
@@ -110,23 +114,23 @@ Follow this sequence to answer questions about meetings:
 
 1. **Search** — Start with `query` using the question as-is:
    ```bash
-   npm run cli:t49bridge -- query "what pricing concerns did Maersk raise" --limit 10
+   t49bridge query "what pricing concerns did Maersk raise" --limit 10
    ```
 
 2. **Get details** — Fetch full context for relevant meetings:
    ```bash
-   npm run cli:t49bridge -- get <meetingId> --summary
-   npm run cli:t49bridge -- get <meetingId> --transcript
+   t49bridge get <meetingId> --summary
+   t49bridge get <meetingId> --transcript
    ```
 
 3. **Narrow** — Add filters if too many results:
    ```bash
-   npm run cli:t49bridge -- query "pricing" --company "Maersk" --from 2026-01-01 --full-text
+   t49bridge query "pricing" --company "Maersk" --from 2026-01-01 --full-text
    ```
 
 4. **Browse** — Use `list` to see what meetings happened in a period:
    ```bash
-   npm run cli:t49bridge -- list --from 2026-01-27 --to 2026-02-02 --external
+   t49bridge list --from 2026-01-27 --to 2026-02-02 --external
    ```
 
 ## Output Format

package/bin/t49bridge.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const { spawn } = require("node:child_process");
+const { resolve } = require("node:path");
+
+const cliPath = resolve(__dirname, "../cli/bridge-cli.ts");
+const args = ["--import", "tsx", cliPath, ...process.argv.slice(2)];
+
+const child = spawn(process.execPath, args, { stdio: "inherit" });
+child.on("exit", (code) => process.exit(code ?? 0));

package/cli/bridge-cli.ts

@@ -0,0 +1,727 @@
+#!/usr/bin/env npx tsx
+
+import { Command } from "commander";
+import { api } from "../convex/_generated/api";
+import { config } from "dotenv";
+import { resolve } from "path";
+import {
+  login,
+  deleteCredentials,
+  getCredentials,
+  getAuthenticatedClient,
+} from "./lib/cli-auth";
+
+// Load local env files if they exist (for non-Convex env vars like BRIDGE_APP_URL)
+config({ path: resolve(__dirname, "../.env.local") });
+
+// Default to production, but allow overrides for testing.
+const convexUrl =
+  process.env.BRIDGE_CONVEX_URL ??
+  process.env.NEXT_PUBLIC_CONVEX_URL ??
+  "https://accomplished-loris-658.convex.cloud";
+
+const program = new Command();
+
+program
+  .name("t49bridge")
+  .description("Bridge CLI — search Fathom transcripts and manage ingestion")
+  .version("0.2.0");
+
+// --- Auth commands (no client needed) ---
+
+program
+  .command("login")
+  .description("Sign in with your Terminal49 Google account")
+  .action(async () => {
+    try {
+      await login();
+      // Verify with the server to get the real name/email
+      const client = await getAuthenticatedClient(convexUrl);
+      try {
+        const user = await client.query(api.users.whoami);
+        if (user?.name || user?.email) {
+          console.log(`Logged in as ${user.name ?? user.email}`);
+        } else {
+          console.log("Logged in successfully.");
+        }
+      } catch {
+        console.log("Logged in successfully.");
+      } finally {
+        await client.close();
+      }
+    } catch (err: any) {
+      console.error("Login failed:", err.message ?? err);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("logout")
+  .description("Remove stored credentials")
+  .action(() => {
+    if (deleteCredentials()) {
+      console.log("Logged out. Credentials removed.");
+    } else {
+      console.log("No credentials found.");
+    }
+  });
+
+program
+  .command("whoami")
+  .description("Show the currently authenticated user")
+  .action(async () => {
+    const creds = getCredentials();
+    if (!creds) {
+      console.log("Not logged in. Run `t49bridge login` first.");
+      process.exit(1);
+    }
+
+    // Also verify with the server
+    const client = await getAuthenticatedClient(convexUrl);
+    try {
+      const user = await client.query(api.users.whoami);
+      if (user) {
+        console.log(`Name:  ${user.name ?? "—"}`);
+        console.log(`Email: ${user.email ?? "—"}`);
+      } else {
+        console.log(
+          "Token is invalid or expired. Run `t49bridge login` to re-authenticate.",
+        );
+      }
+    } catch (err: any) {
+      console.error("Failed to verify identity:", err.message ?? err);
+    } finally {
+      await client.close();
+    }
+  });
+
+// --- Authenticated commands ---
+
+/**
+ * Get an authenticated ConvexClient. Exits if not logged in.
+ * Automatically refreshes expired tokens.
+ */
+async function requireClient() {
+  return await getAuthenticatedClient(convexUrl);
+}
+
+function buildFilters(options: any) {
+  const filters: any = {};
+  if (options.meetingId) filters.meetingId = options.meetingId;
+  if (options.speaker) filters.speaker = options.speaker;
+  if (options.meetingDay) filters.meetingDay = options.meetingDay;
+  if (options.team) filters.team = options.team;
+  if (options.company) filters.company = options.company;
+  if (options.crm) filters.crmRecordName = options.crm;
+  if (options.includePrivate) filters.includePrivate = true;
+  if (typeof options.recentDays === "number" && !Number.isNaN(options.recentDays)) {
+    filters.recentDays = options.recentDays;
+  }
+  if (
+    typeof options.recencyWeight === "number" &&
+    !Number.isNaN(options.recencyWeight)
+  ) {
+    filters.recencyWeight = options.recencyWeight;
+  }
+  if (options.from && options.to) {
+    filters.dateRange = { start: options.from, end: options.to };
+  }
+  return Object.keys(filters).length > 0 ? filters : undefined;
+}
+
+function formatTimestamp(seconds?: number): string | null {
+  if (typeof seconds !== "number" || Number.isNaN(seconds)) return null;
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${String(secs).padStart(2, "0")}`;
+}
+
+function extractQueryTokens(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/\s+/)
+    .map((token) => token.replace(/[^a-z0-9]/g, ""))
+    .filter((token) => token.length >= 2);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function highlightTerms(text: string, query: string): string {
+  const tokens = extractQueryTokens(query).sort((a, b) => b.length - a.length);
+  let output = text;
+  for (const token of tokens) {
+    const pattern = new RegExp(`\\b(${escapeRegExp(token)})\\b`, "gi");
+    output = output.replace(pattern, "**$1**");
+  }
+  return output;
+}
+
+function makeSnippet(text: string, query: string, maxLength: number): string {
+  const tokens = extractQueryTokens(query);
+  if (tokens.length === 0) {
+    return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+  }
+
+  const lowered = text.toLowerCase();
+  let matchIndex = -1;
+  for (const token of tokens) {
+    const index = lowered.indexOf(token);
+    if (index !== -1 && (matchIndex === -1 || index < matchIndex)) {
+      matchIndex = index;
+    }
+  }
+
+  if (matchIndex === -1) {
+    return text.length > maxLength ? `${text.slice(0, maxLength)}...` : text;
+  }
+
+  const start = Math.max(0, matchIndex - Math.floor(maxLength / 2));
+  const end = Math.min(text.length, start + maxLength);
+  let snippet = text.slice(start, end).trim();
+  if (start > 0) snippet = `...${snippet}`;
+  if (end < text.length) snippet = `${snippet}...`;
+  return snippet;
+}
+
+function formatScore(result: any): string {
+  const score = result?.score;
+  const source = result?.source ?? result?.sources?.[0] ?? "unknown";
+  if (typeof score !== "number") {
+    return `n/a (${source})`;
+  }
+  if (score >= 0 && score <= 1) {
+    return `${Math.round(score * 100)}% (${source})`;
+  }
+  return `${score.toFixed(3)} (${source})`;
+}
+
+function getOutputFormat(options: any): "human" | "json" | "llm" {
+  const format =
+    typeof options.format === "string" ? options.format.toLowerCase() : undefined;
+  if (format === "llm") return "llm";
+  if (format === "json") return "json";
+  if (options.json) return "json";
+  return "human";
+}
+
+function printResults(
+  results: any[],
+  options: { query: string; snippetChars: number; fullText: boolean; highlight?: boolean },
+) {
+  if (results.length === 0) {
+    console.log("No results.");
+    return;
+  }
+
+  results.forEach((result) => {
+    const resultType = result.resultType || "chunk";
+    const title = result.meetingTitle || result.title || "Untitled";
+    const date =
+      result.meetingDay || (result.meetingStart ? result.meetingStart.slice(0, 10) : "");
+    const shortId = String(result.chunkId || "").slice(-6);
+    const header =
+      resultType === "summary"
+        ? `${date || "meeting"} [summary]`
+        : `${date || "meeting"} #${shortId}`;
+    console.log(header);
+    console.log(`Meeting: ${title}`);
+    if (result.meetingId) {
+      console.log(`MeetingId: ${result.meetingId}`);
+    }
+    if (resultType !== "summary") {
+      const speaker = result.primarySpeaker || "Unknown";
+      console.log(`Speaker: ${speaker}`);
+      const start = formatTimestamp(result.startTime);
+      const end = formatTimestamp(result.endTime);
+      if (start && end) {
+        console.log(`Range: ${start}–${end}`);
+      } else if (start) {
+        console.log(`Timestamp: ${start}`);
+      }
+    }
+    const sources =
+      result.sources && result.sources.length > 0
+        ? result.sources
+        : result.source
+          ? [result.source]
+          : [];
+    if (sources.length > 0) {
+      console.log(`Sources: ${sources.join(", ")}`);
+    }
+    if (typeof result.rank === "number") {
+      console.log(`Rank: ${result.rank}`);
+    }
+    console.log(`Score: ${formatScore(result)}`);
+    if (result.shareUrl) {
+      console.log(`ShareUrl: ${result.shareUrl}`);
+    }
+
+    const text =
+      resultType === "summary"
+        ? result.summary || result.text || "No summary available."
+        : result.text || "";
+    const snippet = options.fullText
+      ? text
+      : result.snippet || makeSnippet(text, options.query, options.snippetChars);
+    const highlighted = options.highlight ? highlightTerms(snippet, options.query) : snippet;
+    const label = resultType === "summary" ? "Summary" : "Snippet";
+    console.log(`${label}: ${highlighted}`);
+    console.log("");
+  });
+}
+
+function printLlmResults(results: any[], options: { query: string }) {
+  if (results.length === 0) {
+    console.log(JSON.stringify({ type: "empty", query: options.query, results: [] }));
+    return;
+  }
+
+  results.forEach((result) => {
+    const resultType = result.resultType || "chunk";
+    const start = formatTimestamp(result.startTime);
+    const end = formatTimestamp(result.endTime);
+    const payload: Record<string, any> = {
+      type: resultType,
+      meetingId: result.meetingId,
+      title: result.meetingTitle || result.title,
+      day:
+        result.meetingDay ||
+        (result.meetingStart ? result.meetingStart.slice(0, 10) : undefined),
+      sources:
+        result.sources && result.sources.length > 0
+          ? result.sources
+          : result.source
+            ? [result.source]
+            : [],
+      rank: result.rank,
+      score: result.score,
+      timestamp: start || undefined,
+      range: start && end ? `${start}–${end}` : undefined,
+    };
+
+    if (result.shareUrl) payload.shareUrl = result.shareUrl;
+
+    if (resultType === "summary") {
+      payload.summary = result.summary || result.text || "";
+    } else {
+      payload.snippet = result.snippet || result.text || "";
+      if (result.primarySpeaker) payload.speaker = result.primarySpeaker;
+    }
+
+    console.log(JSON.stringify(payload));
+  });
+}
+
+const commonOptions = (command: Command) =>
+  command
+    .option("--meeting-id <id>")
+    .option("--speaker <name>")
+    .option("--meeting-day <YYYY-MM-DD>")
+    .option("--from <date>")
+    .option("--to <date>")
+    .option("--team <name>")
+    .option("--company <name>")
+    .option("--crm <record>")
+    .option("--include-private", "include private calls")
+    .option("--include-url", "include share URL in output")
+    .option(
+      "--recent-days <n>",
+      "boost meetings within the last N days",
+      (value) => parseInt(value, 10),
+    )
+    .option(
+      "--recency-weight <n>",
+      "recency weight (default: 0.25)",
+      (value) => parseFloat(value),
+    )
+    .option(
+      "--snippet-chars <n>",
+      "snippet length in characters",
+      (value) => parseInt(value, 10),
+    )
+    .option("--full-text", "print full chunk text")
+    .option("--format <format>", "output format: human | llm | json")
+    .option("--json", "print raw JSON output")
+    .option(
+      "--limit <n>",
+      "number of results",
+      (value) => parseInt(value, 10),
+    );
+
+commonOptions(
+  program
+    .command("search")
+    .argument("<query>")
+    .description("BM25 search over transcript chunks")
+    .action(async (query, options) => {
+      const client = await requireClient();
+      const filters = buildFilters(options);
+      const limit = options.limit ? Number(options.limit) : undefined;
+      const includeUrl = Boolean(options.includeUrl);
+      const response = await client.query(api.transcriptSearch.searchBm25, {
+        query,
+        filters,
+        limit,
+        includeUrl,
+      });
+      const output = getOutputFormat(options);
+      if (output === "json") {
+        console.log(JSON.stringify(response, null, 2));
+      } else if (output === "llm") {
+        printLlmResults(response.results, { query });
+      } else {
+        printResults(response.results, {
+          query,
+          snippetChars: options.snippetChars ?? 240,
+          fullText: Boolean(options.fullText),
+          highlight: true,
+        });
+      }
+      await client.close();
+    }),
+);
+
+commonOptions(
+  program
+    .command("vsearch")
+    .argument("<query>")
+    .description("Vector search over transcript chunks")
+    .action(async (query, options) => {
+      const client = await requireClient();
+      const filters = buildFilters(options);
+      const limit = options.limit ? Number(options.limit) : undefined;
+      const includeUrl = Boolean(options.includeUrl);
+      const response = await client.action(api.transcriptSearch.searchVector, {
+        query,
+        filters,
+        limit,
+        includeUrl,
+      });
+      const output = getOutputFormat(options);
+      if (output === "json") {
+        console.log(JSON.stringify(response, null, 2));
+      } else if (output === "llm") {
+        printLlmResults(response.results, { query });
+      } else {
+        printResults(response.results, {
+          query,
+          snippetChars: options.snippetChars ?? 240,
+          fullText: Boolean(options.fullText),
+          highlight: true,
+        });
+      }
+      await client.close();
+    }),
+);
+
+commonOptions(
+  program
+    .command("query")
+    .argument("<query>")
+    .description("Hybrid BM25 + vector search")
+    .action(async (query, options) => {
+      const client = await requireClient();
+      const filters = buildFilters(options);
+      const limit = options.limit ? Number(options.limit) : undefined;
+      const includeUrl = Boolean(options.includeUrl);
+      const response = await client.action(api.transcriptSearch.searchHybrid, {
+        query,
+        filters,
+        limit,
+        includeUrl,
+      });
+      const output = getOutputFormat(options);
+      if (output === "json") {
+        console.log(JSON.stringify(response, null, 2));
+      } else if (output === "llm") {
+        printLlmResults(response.results, { query });
+      } else {
+        printResults(response.results, {
+          query,
+          snippetChars: options.snippetChars ?? 240,
+          fullText: Boolean(options.fullText),
+          highlight: true,
+        });
+      }
+      await client.close();
+    }),
+);
+
+program
+  .command("backfill")
+  .description("Backfill transcript chunks and embeddings")
+  .option(
+    "--batch-size <n>",
+    "number of meetings per batch",
+    (value) => parseInt(value, 10),
+  )
+  .option("--no-embed", "skip embedding generation")
+  .option("--force", "rebuild chunks and embeddings")
+  .action(async (options) => {
+    const client = await requireClient();
+    const response = await client.action(
+      api.transcriptIndexing.startTranscriptSearchBackfill,
+      {
+        batchSize: options.batchSize,
+        embed: options.embed,
+        force: options.force,
+      },
+    );
+    console.log("Backfill started:", response);
+    await client.close();
+  });
+
+program
+  .command("get")
+  .argument("<meetingId>")
+  .description("Fetch meeting details with optional transcript")
+  .option("--transcript", "include transcript")
+  .option("--segments", "print transcript segments instead of full text")
+  .option(
+    "--max-segments <n>",
+    "limit transcript segments",
+    (value) => parseInt(value, 10),
+  )
+  .option("--summary", "print only the meeting summary")
+  .option("--json", "print raw JSON output")
+  .action(async (meetingId, options) => {
+    const client = await requireClient();
+    const response = await client.query(api.meetings.getByMeetingId, {
+      meetingId,
+      includeTranscript: Boolean(options.transcript || options.segments),
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(response, null, 2));
+      await client.close();
+      return;
+    }
+
+    if (!response) {
+      console.log("Meeting not found.");
+      await client.close();
+      return;
+    }
+
+    const meeting = response.meeting;
+    if (options.summary) {
+      console.log(meeting.summary || "No summary available.");
+      await client.close();
+      return;
+    }
+
+    console.log(`Meeting: ${meeting.title}`);
+    console.log(`MeetingId: ${meeting.meetingId}`);
+    console.log(`Date: ${meeting.startedAt}`);
+    console.log(`Duration: ${Math.round(meeting.duration / 60)} min`);
+    console.log(`Host: ${meeting.hostName} <${meeting.hostEmail}>`);
+    console.log(`Internal: ${meeting.isInternal ? "yes" : "no"}`);
+    if (meeting.teams?.length)
+      console.log(`Teams: ${meeting.teams.join(", ")}`);
+    if (meeting.externalCompanies?.length) {
+      console.log(`Companies: ${meeting.externalCompanies.join(", ")}`);
+    }
+    if (meeting.shareUrl) console.log(`ShareUrl: ${meeting.shareUrl}`);
+    if (meeting.visibility) console.log(`Visibility: ${meeting.visibility}`);
+    if (meeting.summary) console.log(`Summary: ${meeting.summary}`);
+    if (meeting.actionItems?.length) {
+      console.log("Action Items:");
+      meeting.actionItems.forEach((item: any, index: number) => {
+        console.log(
+          `  ${index + 1}. ${item.text}${item.assignee ? ` (${item.assignee})` : ""}`,
+        );
+      });
+    }
+
+    if (options.transcript || options.segments) {
+      const transcript = response.transcript;
+      if (!transcript) {
+        console.log("Transcript: not found.");
+      } else if (options.segments) {
+        const maxSegments =
+          typeof options.maxSegments === "number"
+            ? options.maxSegments
+            : transcript.segments.length;
+        transcript.segments.slice(0, maxSegments).forEach((seg: any) => {
+          const start = formatTimestamp(seg.startTime);
+          const end = formatTimestamp(seg.endTime);
+          console.log(
+            `[${start ?? "?"}-${end ?? "?"}] ${seg.speakerName || "Unknown"}: ${seg.text}`,
+          );
+        });
+      } else {
+        console.log(transcript.fullText || "");
+      }
+    }
+
+    await client.close();
+  });
+
+program
+  .command("list")
+  .description("List recent meetings")
+  .option("--limit <n>", "number of meetings to show", (value) => parseInt(value, 10))
+  .option("--from <date>", "filter meetings from date (YYYY-MM-DD)")
+  .option("--to <date>", "filter meetings to date (YYYY-MM-DD)")
+  .option("--company <name>", "filter by company (partial match)")
+  .option("--host <name>", "filter by host name or email (partial match)")
+  .option("--attendee <name>", "filter by attendee name or email (partial match)")
+  .option("--internal", "show only internal meetings")
+  .option("--external", "show only external meetings")
+  .option("--asc", "sort by oldest first (default: newest first)")
+  .option("--json", "print raw JSON output")
+  .action(async (options) => {
+    const client = await requireClient();
+    const limit = options.limit ?? 20;
+    const sortOrder = options.asc ? "asc" : "desc";
+    const fromDate = options.from ? new Date(options.from + "T00:00:00Z") : null;
+    const toDate = options.to ? new Date(options.to + "T23:59:59Z") : null;
+    const companyFilter = options.company?.toLowerCase();
+    const hostFilter = options.host?.toLowerCase();
+    const attendeeFilter = options.attendee?.toLowerCase();
+
+    // Check if any filters are applied
+    const hasFilters =
+      fromDate ||
+      toDate ||
+      companyFilter ||
+      hostFilter ||
+      attendeeFilter ||
+      options.internal ||
+      options.external;
+
+    // Fetch more meetings if filtering to ensure we get enough results
+    const fetchLimit = hasFilters ? Math.max(limit * 5, 100) : limit;
+
+    let meetings = await client.query(api.meetings.getRecentMeetings, {
+      limit: fetchLimit,
+      sortOrder,
+    });
+
+    // Apply filters client-side
+    if (hasFilters) {
+      meetings = meetings.filter((meeting) => {
+        // Date filter
+        if (fromDate || toDate) {
+          const meetingDate = new Date(meeting.startedAt);
+          if (fromDate && meetingDate < fromDate) return false;
+          if (toDate && meetingDate > toDate) return false;
+        }
+
+        // Company filter (partial match on external companies)
+        if (companyFilter) {
+          const companies = meeting.externalCompanies || [];
+          const hasMatch = companies.some((c: string) =>
+            c.toLowerCase().includes(companyFilter),
+          );
+          if (!hasMatch) return false;
+        }
+
+        // Host filter (partial match on name or email)
+        if (hostFilter) {
+          const hostName = meeting.hostName?.toLowerCase() || "";
+          const hostEmail = meeting.hostEmail?.toLowerCase() || "";
+          if (!hostName.includes(hostFilter) && !hostEmail.includes(hostFilter)) return false;
+        }
+
+        // Attendee filter (partial match on external participants)
+        if (attendeeFilter) {
+          const participants = meeting.externalParticipants || [];
+          const hasMatch = participants.some((p: any) => {
+            const name = p.name?.toLowerCase() || "";
+            const email = p.email?.toLowerCase() || "";
+            const company = p.company?.toLowerCase() || "";
+            return (
+              name.includes(attendeeFilter) ||
+              email.includes(attendeeFilter) ||
+              company.includes(attendeeFilter)
+            );
+          });
+          if (!hasMatch) return false;
+        }
+
+        // Internal/external filter
+        if (options.internal && !meeting.isInternal) return false;
+        if (options.external && meeting.isInternal) return false;
+
+        return true;
+      });
+
+      // Apply limit after filtering
+      meetings = meetings.slice(0, limit);
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(meetings, null, 2));
+      await client.close();
+      return;
+    }
+
+    if (meetings.length === 0) {
+      console.log("No meetings found.");
+      const filters: string[] = [];
+      if (fromDate || toDate)
+        filters.push(`date: ${options.from || "any"} to ${options.to || "any"}`);
+      if (companyFilter) filters.push(`company: ${options.company}`);
+      if (hostFilter) filters.push(`host: ${options.host}`);
+      if (attendeeFilter) filters.push(`attendee: ${options.attendee}`);
+      if (options.internal) filters.push("internal only");
+      if (options.external) filters.push("external only");
+      if (filters.length > 0) console.log(`Filters: ${filters.join(", ")}`);
+      await client.close();
+      return;
+    }
+
+    // Build filter info string
+    const filterParts: string[] = [];
+    if (fromDate || toDate) filterParts.push(`${options.from || "any"} to ${options.to || "any"}`);
+    if (companyFilter) filterParts.push(`company: ${options.company}`);
+    if (hostFilter) filterParts.push(`host: ${options.host}`);
+    if (attendeeFilter) filterParts.push(`attendee: ${options.attendee}`);
+    if (options.internal) filterParts.push("internal");
+    if (options.external) filterParts.push("external");
+    const filterInfo = filterParts.length > 0 ? ` (${filterParts.join(", ")})` : "";
+
+    console.log(`Found ${meetings.length} meeting(s)${filterInfo}:\n`);
+
+    // Group meetings by date
+    const byDate = new Map<string, typeof meetings>();
+    for (const meeting of meetings) {
+      const date = meeting.startedAt.split("T")[0];
+      if (!byDate.has(date)) byDate.set(date, []);
+      byDate.get(date)!.push(meeting);
+    }
+
+    for (const [date, dateMeetings] of byDate) {
+      console.log(`=== ${date} ===`);
+      for (const meeting of dateMeetings) {
+        const time = meeting.startedAt.split("T")[1]?.slice(0, 5) || "";
+        const duration = Math.round(meeting.duration / 60);
+        const type = meeting.isInternal ? "internal" : "external";
+        const companies = meeting.externalCompanies?.join(", ") || "";
+        const transcript = meeting.hasTranscript ? "✓" : "✗";
+
+        console.log(`  ${time} | ${meeting.title}`);
+        console.log(`         ID: ${meeting.meetingId} | Host: ${meeting.hostName}`);
+        console.log(
+          `         Duration: ${duration} min | Type: ${type} | Transcript: ${transcript}`,
+        );
+        if (companies) {
+          console.log(`         Companies: ${companies}`);
+        }
+        if (meeting.actionItemCount > 0) {
+          console.log(`         Action Items: ${meeting.actionItemCount}`);
+        }
+        console.log("");
+      }
+    }
+
+    await client.close();
+  });
+
+program.parseAsync(process.argv).catch(async (error) => {
+  console.error(error);
+  process.exit(1);
+});

package/cli/lib/cli-auth.ts

@@ -0,0 +1,292 @@
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  chmodSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { exec } from "node:child_process";
+import { ConvexClient } from "convex/browser";
+
+const CREDENTIALS_DIR = join(homedir(), ".t49bridge");
+const CREDENTIALS_FILE = join(CREDENTIALS_DIR, "credentials.json");
+const APP_URL = process.env.BRIDGE_APP_URL ?? "https://bridge.t49.co";
+
+interface Credentials {
+  token: string;
+  refreshToken: string | null;
+  email: string | null;
+  name: string | null;
+  savedAt: string;
+}
+
+/**
+ * Open a URL in the default browser (cross-platform).
+ */
+function openBrowser(url: string): void {
+  const cmd =
+    process.platform === "darwin"
+      ? `open "${url}"`
+      : process.platform === "win32"
+        ? `start "${url}"`
+        : `xdg-open "${url}"`;
+  exec(cmd);
+}
+
+/**
+ * Run the browser-based login flow:
+ * 1. Start a local HTTP server on a random port
+ * 2. Open the browser to the CLI auth page
+ * 3. Wait for the callback with the token
+ * 4. Save credentials to ~/.t49bridge/credentials.json
+ */
+export async function login(): Promise<Credentials> {
+  const state = randomBytes(16).toString("hex");
+
+  return new Promise<Credentials>((resolve, reject) => {
+    const server = createServer(
+      (req: IncomingMessage, res: ServerResponse) => {
+        const url = new URL(req.url ?? "/", `http://localhost`);
+
+        if (url.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+
+        const receivedState = url.searchParams.get("state");
+        const token = url.searchParams.get("token");
+        const refreshToken = url.searchParams.get("refreshToken") || null;
+        const email = url.searchParams.get("email") || null;
+        const name = url.searchParams.get("name") || null;
+
+        if (receivedState !== state) {
+          res.writeHead(403);
+          res.end("State mismatch — possible CSRF attack. Please try again.");
+          return;
+        }
+
+        if (!token) {
+          res.writeHead(400);
+          res.end("No token received. Please try again.");
+          return;
+        }
+
+        // Save credentials
+        const credentials: Credentials = {
+          token,
+          refreshToken,
+          email,
+          name,
+          savedAt: new Date().toISOString(),
+        };
+        saveCredentials(credentials);
+
+        // Send success page to browser
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+            <head><title>Bridge CLI - Authenticated</title></head>
+            <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #18181b; color: #fafafa;">
+              <div style="text-align: center;">
+                <h1>Authenticated!</h1>
+                <p>You can close this tab and return to your terminal.</p>
+              </div>
+            </body>
+          </html>
+        `);
+
+        // Close server, clear timeout, and resolve
+        clearTimeout(timeout);
+        server.close();
+        resolve(credentials);
+      },
+    );
+
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+
+      const port = addr.port;
+      const authUrl = `${APP_URL}/cli/auth?port=${port}&state=${state}`;
+
+      console.log(`Opening browser for authentication...`);
+      console.log(`If the browser doesn't open, visit: ${authUrl}`);
+      console.log();
+
+      openBrowser(authUrl);
+    });
+
+    // Timeout after 5 minutes
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 5 minutes."));
+    }, 5 * 60 * 1000);
+  });
+}
+
+/**
+ * Save credentials to disk.
+ */
+function saveCredentials(credentials: Credentials): void {
+  if (!existsSync(CREDENTIALS_DIR)) {
+    mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  }
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2));
+  // Restrict permissions to owner only
+  chmodSync(CREDENTIALS_FILE, 0o600);
+}
+
+/**
+ * Load stored credentials from disk.
+ */
+export function getCredentials(): Credentials | null {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(data) as Credentials;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Delete stored credentials (logout).
+ */
+export function deleteCredentials(): boolean {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return false;
+  }
+  unlinkSync(CREDENTIALS_FILE);
+  return true;
+}
+
+/**
+ * Decode a JWT payload without verification (for expiry checks only).
+ */
+function decodeJwtPayload(token: string): Record<string, unknown> | null {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = Buffer.from(parts[1], "base64url").toString();
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a JWT token is expired (with a 60-second buffer).
+ */
+function isTokenExpired(token: string): boolean {
+  const payload = decodeJwtPayload(token);
+  if (!payload || typeof payload.exp !== "number") return false;
+  const now = Math.floor(Date.now() / 1000);
+  return payload.exp < now + 60; // expired or expiring within 60s
+}
+
+/**
+ * Refresh an expired token using the stored refresh token.
+ * Calls the Convex auth:signIn action directly via the HTTP API.
+ * Returns new credentials on success, or null if refresh failed.
+ */
+async function refreshTokens(
+  convexUrl: string,
+  refreshToken: string,
+): Promise<{ token: string; refreshToken: string } | null> {
+  try {
+    const res = await fetch(`${convexUrl}/api/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        path: "auth:signIn",
+        args: { refreshToken },
+        format: "json",
+      }),
+    });
+
+    if (!res.ok) {
+      return null;
+    }
+
+    const result = await res.json();
+    const tokens = result?.value?.tokens ?? result?.tokens;
+
+    if (tokens?.token && tokens?.refreshToken) {
+      return { token: tokens.token, refreshToken: tokens.refreshToken };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the stored auth token, or null if not logged in.
+ */
+export function getAuthToken(): string | null {
+  const credentials = getCredentials();
+  return credentials?.token ?? null;
+}
+
+/**
+ * Create a ConvexClient authenticated with the stored token.
+ * Automatically refreshes expired tokens using the refresh token.
+ * Throws if not logged in or refresh fails.
+ */
+export async function getAuthenticatedClient(convexUrl: string): Promise<ConvexClient> {
+  const credentials = getCredentials();
+  if (!credentials?.token) {
+    console.error(
+      "Not logged in. Run `t49bridge login` first.",
+    );
+    process.exit(1);
+  }
+
+  let { token } = credentials;
+
+  // Auto-refresh if token is expired or about to expire
+  if (isTokenExpired(token)) {
+    if (!credentials.refreshToken) {
+      console.error(
+        "Session expired and no refresh token available. Run `t49bridge login` to re-authenticate.",
+      );
+      process.exit(1);
+    }
+
+    const newTokens = await refreshTokens(convexUrl, credentials.refreshToken);
+    if (!newTokens) {
+      console.error(
+        "Session expired and refresh failed. Run `t49bridge login` to re-authenticate.",
+      );
+      process.exit(1);
+    }
+
+    // Save refreshed credentials
+    const updated: Credentials = {
+      ...credentials,
+      token: newTokens.token,
+      refreshToken: newTokens.refreshToken,
+      savedAt: new Date().toISOString(),
+    };
+    saveCredentials(updated);
+    token = newTokens.token;
+    console.error("Session refreshed.");
+  }
+
+  const client = new ConvexClient(convexUrl);
+  client.setAuth(() => Promise.resolve(token));
+  return client;
+}

package/convex/_generated/api.js

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import { anyApi, componentsGeneric } from "convex/server";
+
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();

package/package.json

@@ -1,13 +1,33 @@
 {
   "name": "@terminal49/bridge-cli",
-  "version": "0.1.1",
-  "description": "Bridge CLI meeting search skill for LLMs",
+  "version": "0.1.3",
+  "description": "Bridge CLI and meeting search skill for LLMs",
   "license": "UNLICENSED",
+  "bin": {
+    "t49bridge": "bin/t49bridge.js"
+  },
   "publishConfig": {
     "access": "public"
   },
   "files": [
     "SKILL.md",
-    "README.md"
-  ]
+    "README.md",
+    "bin/**",
+    "cli/**",
+    "convex/**"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Terminal49/bridge.git",
+    "directory": "packages/bridge-cli"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "convex": "^1.25.4",
+    "dotenv": "^17.2.1",
+    "tsx": "^4.20.3"
+  }
 }