diff --git a/apps/mobile/src/components/ComposerAttachmentButton.tsx b/apps/mobile/src/components/ComposerAttachmentButton.tsx index b7d0b1eaf99cb..28fe93d63f58a 100644 --- a/apps/mobile/src/components/ComposerAttachmentButton.tsx +++ b/apps/mobile/src/components/ComposerAttachmentButton.tsx @@ -14,6 +14,7 @@ const GITHUB_ISSUE_ACTION: MenuAction = { image: "smallcircle.filled.circle", }; const NOTION_ACTION: MenuAction = { id: "notion", title: "Notion page", image: "doc.text" }; +const GRANOLA_ACTION: MenuAction = { id: "granola", title: "Granola note", image: "waveform" }; const SLACK_ACTION: MenuAction = { id: "slack", title: "Slack message", image: "number" }; const REPOSITORY_ACTION: MenuAction = { id: "repository", @@ -32,6 +33,8 @@ export function ComposerAttachmentButton(props: { readonly onPickGitHubIssue?: () => void; /** Omit to hide the Notion action. See `useNotionPagePicker`. */ readonly onPickNotionPage?: () => void; + /** Omit to hide the Granola action. See `useGranolaNotePicker`. */ + readonly onPickGranolaNote?: () => void; /** Omit to hide the Slack action. See `useSlackMessagePicker`. */ readonly onPickSlackMessage?: () => void; /** Omit to hide the repository action. See `useRepositoryPicker`. */ @@ -44,6 +47,7 @@ export function ComposerAttachmentButton(props: { ...(props.onPickLinearIssue ? [LINEAR_ACTION] : []), ...(props.onPickGitHubIssue ? [GITHUB_ISSUE_ACTION] : []), ...(props.onPickNotionPage ? [NOTION_ACTION] : []), + ...(props.onPickGranolaNote ? [GRANOLA_ACTION] : []), ...(props.onPickSlackMessage ? [SLACK_ACTION] : []), ...(props.onPickRepository ? [REPOSITORY_ACTION] : []), ]; @@ -88,6 +92,8 @@ export function ComposerAttachmentButton(props: { props.onPickGitHubIssue?.(); } else if (nativeEvent.event === "notion") { props.onPickNotionPage?.(); + } else if (nativeEvent.event === "granola") { + props.onPickGranolaNote?.(); } else if (nativeEvent.event === "slack") { props.onPickSlackMessage?.(); } else if (nativeEvent.event === "repository") { diff --git a/apps/mobile/src/components/ComposerContextSheet.tsx b/apps/mobile/src/components/ComposerContextSheet.tsx index dbc75f1fbe778..007156f81c448 100644 --- a/apps/mobile/src/components/ComposerContextSheet.tsx +++ b/apps/mobile/src/components/ComposerContextSheet.tsx @@ -27,6 +27,7 @@ import { } from "@t3tools/client-runtime/context-repositories"; import { FilePreviewModal } from "./FilePreviewModal"; import { VideoPreviewModal } from "./VideoPreviewModal"; +import { granolaNoteDetail } from "./GranolaNotePickerSheet"; import { ComposerContextAttachment } from "./ComposerContextAttachment"; import { AppText as Text } from "./AppText"; import { AppSheet } from "./AppSheet"; @@ -375,6 +376,37 @@ export function ComposerContextSheet(props: { ) : null} + {record.kind === "granola-note" ? ( + + + + {record.title} + + {record.meetingAt || record.participants ? ( + + {granolaNoteDetail(record)} + + ) : null} + + {/^https?:\/\//i.test(record.url) ? ( + { + void tryOpenExternalUrl(record.url, "markdown-link").then((opened) => { + if (!opened) Alert.alert("Could not open Granola", "Try again later."); + }); + }} + className="rounded-xl bg-subtle p-4" + > + Open in Granola + + ) : null} + {/* Plain text like the other captured context here: exactly what the agent received. */} + + {record.markdown} + + + ) : null} {record.kind === "slack-thread" ? ( diff --git a/apps/mobile/src/components/GranolaNotePickerSheet.tsx b/apps/mobile/src/components/GranolaNotePickerSheet.tsx new file mode 100644 index 0000000000000..a2b92841b30f0 --- /dev/null +++ b/apps/mobile/src/components/GranolaNotePickerSheet.tsx @@ -0,0 +1,311 @@ +import type { EnvironmentId, GranolaNoteSummary, ThreadId } from "@t3tools/contracts"; +import { useAtomValue } from "@effect/atom-react"; +import { granolaNoteContextRecord } from "@t3tools/client-runtime/state/granola"; +import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime"; +import { formatComposerContextReference } from "@t3tools/shared/composerContextReferences"; +import * as Cause from "effect/Cause"; +import * as Option from "effect/Option"; +import { AsyncResult } from "effect/reactivity"; +import { useState, type ReactNode } from "react"; +import { ActivityIndicator, Alert, FlatList, Pressable, View } from "react-native"; +import { useSafeAreaInsets } from "react-native-safe-area-context"; + +import { useEnvironmentServerConfig } from "../state/entities"; +import { granolaEnvironment } from "../state/granola"; +import { useDebouncedValue } from "../state/queries"; +import { useEnvironmentQuery } from "../state/query"; +import { useAtomCommand } from "../state/use-atom-command"; +import { + captureComposerDraftInsertion, + insertComposerDraftContext, + type ComposerDraftInsertion, +} from "../state/use-composer-drafts"; +import { AppText as Text, AppTextInput } from "./AppText"; +import { PickerSheet } from "./PickerSheet"; + +/** The server filters a cached list of recent meetings, so typing can settle quickly. */ +const SEARCH_DEBOUNCE_MS = 250; + +const MEETING_DATE_FORMATTER = new Intl.DateTimeFormat(undefined, { + month: "short", + day: "numeric", + hour: "numeric", + minute: "2-digit", +}); + +/** A note's meeting date and participants, as the secondary line under its title. */ +export function granolaNoteDetail(note: { + readonly meetingAt: string | null; + /** Names from a note summary, or the joined names an attached record keeps. */ + readonly participants: string | ReadonlyArray; +}): string { + const meetingAt = note.meetingAt ? new Date(note.meetingAt) : null; + return [ + meetingAt && !Number.isNaN(meetingAt.getTime()) + ? MEETING_DATE_FORMATTER.format(meetingAt) + : null, + (typeof note.participants === "string" + ? note.participants + : note.participants.join(", ") + ).trim() || null, + ] + .filter((part) => part !== null) + .join(" · "); +} + +/** Granola's failures carry a reason; a rate limit deserves a clearer hint than its detail. */ +function granolaErrorMessage(error: unknown, fallback: string): string { + if (typeof error === "object" && error !== null && "reason" in error) { + if (error.reason === "rate-limited") return "Granola is busy. Try again shortly."; + if (error.reason === "not-connected" || error.reason === "revoked") { + return "Granola is not connected. Connect it from Settings > Integrations on desktop or web."; + } + } + return error instanceof Error && error.message.trim() ? error.message : fallback; +} + +/** Attach inserts the note into a composer draft; link links it to the thread's tab group. */ +export type GranolaNotePickerTarget = + | { readonly mode?: "attach"; readonly environmentId: EnvironmentId; readonly draftKey: string } + | { readonly mode: "link"; readonly environmentId: EnvironmentId; readonly threadId: ThreadId }; + +type OpenedGranolaNotePicker = + | { + readonly mode: "attach"; + readonly environmentId: EnvironmentId; + readonly draftKey: string; + readonly insertion: ComposerDraftInsertion; + } + | { readonly mode: "link"; readonly environmentId: EnvironmentId; readonly threadId: ThreadId }; + +/** + * A Granola note picker. The owner renders `sheet` somewhere that outlives composer focus: + * opening the sheet blurs the editor, which can unmount a focus-dependent toolbar. + */ +export function useGranolaNotePicker(target: GranolaNotePickerTarget | null): { + readonly open: (() => void) | undefined; + readonly sheet: ReactNode; +} { + const [opened, setOpened] = useState(null); + const serverConfig = useEnvironmentServerConfig(target?.environmentId ?? null); + const enabled = serverConfig?.settings.enableGranolaIntegration === true; + const openedServerConfig = useEnvironmentServerConfig(opened?.environmentId ?? null); + return { + open: + target && enabled + ? () => + setOpened( + target.mode === "link" + ? target + : { + ...target, + mode: "attach", + insertion: captureComposerDraftInsertion(target.draftKey), + }, + ) + : undefined, + sheet: + opened && openedServerConfig?.settings.enableGranolaIntegration ? ( + setOpened(null)} /> + ) : null, + }; +} + +/** + * Attaches a Granola note at the caret the composer had when the sheet opened, or links it to the + * thread's tab group. Mobile has no Granola settings, so an unconnected environment points at + * desktop or web. + */ +function GranolaNotePickerSheet(props: OpenedGranolaNotePicker & { readonly onClose: () => void }) { + const connection = useEnvironmentQuery( + granolaEnvironment.connection({ environmentId: props.environmentId, input: {} }), + ); + const phase = connection.data?.phase; + return ( + + {phase === "connected" ? ( + + ) : ( + + {phase === undefined && !connection.error ? ( + + ) : ( + + {connection.error ?? + "Granola is not connected on this environment. Connect it from Settings > Integrations on desktop or web."} + + )} + + )} + + ); +} + +function GranolaNoteSearch(props: OpenedGranolaNotePicker & { readonly onClose: () => void }) { + const [query, setQuery] = useState(""); + const trimmed = query.trim(); + const settled = useDebouncedValue(trimmed, SEARCH_DEBOUNCE_MS); + const getNote = useAtomCommand(granolaEnvironment.getNote, { + label: "granola note fetch", + reportFailure: false, + }); + const linkThread = useAtomCommand(granolaEnvironment.linkThread, { + label: "granola thread link", + reportFailure: false, + }); + const [attaching, setAttaching] = useState(null); + + const link = async (threadId: ThreadId, note: GranolaNoteSummary) => { + const result = await linkThread({ + environmentId: props.environmentId, + input: { threadId, noteId: note.id }, + }); + if (result._tag === "Failure") { + Alert.alert( + "Could not link Granola note", + granolaErrorMessage(squashAtomCommandFailure(result), "Try again."), + ); + return; + } + props.onClose(); + }; + + const attach = async (note: GranolaNoteSummary) => { + if (attaching) return; + setAttaching(note.id); + try { + if (props.mode === "link") { + await link(props.threadId, note); + return; + } + const fetched = await getNote({ + environmentId: props.environmentId, + input: { id: note.id }, + }); + if (fetched._tag === "Failure") { + Alert.alert( + "Could not attach Granola note", + granolaErrorMessage(squashAtomCommandFailure(fetched), "Try again."), + ); + return; + } + const record = granolaNoteContextRecord(fetched.value); + if ( + !insertComposerDraftContext( + props.draftKey, + { + text: formatComposerContextReference(record), + context: { version: 1, records: [record] }, + }, + props.insertion, + ) + ) { + Alert.alert("Too many context items", "Remove some context from the draft and try again."); + return; + } + props.onClose(); + } finally { + setAttaching(null); + } + }; + + return ( + + + + + void attach(note)} + /> + + ); +} + +/** An empty query lists the last 30 days of meetings; text filters them by title or people. */ +function GranolaNoteResults(props: { + readonly environmentId: EnvironmentId; + readonly query: string; + readonly pendingInput: boolean; + readonly attaching: string | null; + readonly onPick: (note: GranolaNoteSummary) => void; +}) { + const insets = useSafeAreaInsets(); + const result = useAtomValue( + granolaEnvironment.notes({ + environmentId: props.environmentId, + input: { query: props.query }, + }), + ); + const notes = Option.getOrNull(AsyncResult.value(result))?.notes ?? []; + const pending = props.pendingInput || result.waiting; + const error = + result._tag === "Failure" + ? granolaErrorMessage(Cause.squash(result.cause), "Could not search Granola.") + : null; + return ( + note.id} + keyboardShouldPersistTaps="handled" + contentContainerStyle={{ paddingBottom: Math.max(insets.bottom, 16) }} + ListEmptyComponent={ + + {pending ? ( + + ) : ( + + {error ?? + (props.query ? "No matching meetings." : "No meetings in the last 30 days.")} + + )} + + } + renderItem={({ item }) => { + const detail = granolaNoteDetail(item); + return ( + props.onPick(item)} + className="flex-row items-center gap-3 px-4 py-3 active:bg-subtle disabled:opacity-60" + > + + + {item.title} + + {detail ? ( + + {detail} + + ) : null} + + {props.attaching === item.id ? : null} + + ); + }} + /> + ); +} diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx index 23ba8eb02a32c..07b18715699fe 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx @@ -61,6 +61,7 @@ import { takeStartFromGitHubIssue, useGitHubIssuePicker, } from "../../components/GitHubIssuePickerSheet"; +import { useGranolaNotePicker } from "../../components/GranolaNotePickerSheet"; import { useNotionPagePicker } from "../../components/NotionPagePickerSheet"; import { useSlackMessagePicker } from "../../components/SlackMessagePickerSheet"; import { useRepositoryPicker } from "../../components/RepositoryPickerSheet"; @@ -1049,6 +1050,11 @@ export function NewTaskDraftScreen(props: { ? { environmentId: flow.selectedEnvironmentId, draftKey: flow.draftKey } : null, ); + const granolaNotePicker = useGranolaNotePicker( + flow.draftKey && flow.selectedEnvironmentId + ? { environmentId: flow.selectedEnvironmentId, draftKey: flow.draftKey } + : null, + ); const slackMessagePicker = useSlackMessagePicker( flow.draftKey && flow.selectedEnvironmentId ? { environmentId: flow.selectedEnvironmentId, draftKey: flow.draftKey } @@ -1938,6 +1944,11 @@ export function NewTaskDraftScreen(props: { ? notionPagePicker.open : undefined } + onPickGranolaNote={ + flow.draftKey && flow.selectedEnvironmentId + ? granolaNotePicker.open + : undefined + } onPickSlackMessage={ flow.draftKey && flow.selectedEnvironmentId ? slackMessagePicker.open @@ -2032,6 +2043,7 @@ export function NewTaskDraftScreen(props: { {startFromGitHubIssuePicker.sheet} {slackMessagePicker.sheet} {notionPagePicker.sheet} + {granolaNotePicker.sheet} {startFromPullRequestPicker.sheet} {repositoryPicker.sheet} diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx index 1ede52f1530ab..17dcdb4f8b805 100644 --- a/apps/mobile/src/features/threads/ThreadComposer.tsx +++ b/apps/mobile/src/features/threads/ThreadComposer.tsx @@ -75,6 +75,7 @@ import { AppText as Text } from "../../components/AppText"; import { ComposerAttachmentButton } from "../../components/ComposerAttachmentButton"; import { useLinearIssuePicker } from "../../components/LinearIssuePickerSheet"; import { useGitHubIssuePicker } from "../../components/GitHubIssuePickerSheet"; +import { useGranolaNotePicker } from "../../components/GranolaNotePickerSheet"; import { useNotionPagePicker } from "../../components/NotionPagePickerSheet"; import { useSlackMessagePicker } from "../../components/SlackMessagePickerSheet"; import { useRepositoryPicker } from "../../components/RepositoryPickerSheet"; @@ -475,6 +476,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer environmentId: props.environmentId, draftKey: composerDraftKey, }); + const granolaNotePicker = useGranolaNotePicker({ + environmentId: props.environmentId, + draftKey: composerDraftKey, + }); const slackMessagePicker = useSlackMessagePicker({ environmentId: props.environmentId, draftKey: composerDraftKey, @@ -921,6 +926,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer onPickLinearIssue={linearIssuePicker.open} onPickGitHubIssue={workspaceCwd ? gitHubIssuePicker.open : undefined} onPickNotionPage={notionPagePicker.open} + onPickGranolaNote={granolaNotePicker.open} onPickSlackMessage={slackMessagePicker.open} onPickRepository={repositoryPicker.open} /> @@ -1204,6 +1210,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer onPickLinearIssue={linearIssuePicker.open} onPickGitHubIssue={workspaceCwd ? gitHubIssuePicker.open : undefined} onPickNotionPage={notionPagePicker.open} + onPickGranolaNote={granolaNotePicker.open} onPickSlackMessage={slackMessagePicker.open} onPickRepository={repositoryPicker.open} /> @@ -1269,6 +1276,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer {gitHubIssuePicker.sheet} {slackMessagePicker.sheet} {notionPagePicker.sheet} + {granolaNotePicker.sheet} {repositoryPicker.sheet} ); diff --git a/apps/mobile/src/features/threads/ThreadSlackNotionLinks.tsx b/apps/mobile/src/features/threads/ThreadSlackNotionLinks.tsx index 4b4a204428066..3e66fff12fa82 100644 --- a/apps/mobile/src/features/threads/ThreadSlackNotionLinks.tsx +++ b/apps/mobile/src/features/threads/ThreadSlackNotionLinks.tsx @@ -1,4 +1,5 @@ import { useAtomValue } from "@effect/atom-react"; +import { granolaLinkForThread } from "@t3tools/client-runtime/state/granola"; import { notionLinkForThread } from "@t3tools/client-runtime/state/notion"; import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime"; import { slackLinkForThread } from "@t3tools/client-runtime/state/slack"; @@ -6,9 +7,11 @@ import type { EnvironmentId, ThreadId } from "@t3tools/contracts"; import { Alert, Pressable, Text } from "react-native"; import { ControlPillMenu } from "../../components/ControlPillMenu"; +import { useGranolaNotePicker } from "../../components/GranolaNotePickerSheet"; import { useNotionPagePicker } from "../../components/NotionPagePickerSheet"; import { useSlackMessagePicker } from "../../components/SlackMessagePickerSheet"; import { tryOpenExternalUrl, type ExternalUrlTarget } from "../../lib/openExternalUrl"; +import { granolaEnvironment } from "../../state/granola"; import { notionEnvironment } from "../../state/notion"; import { useEnvironmentQuery } from "../../state/query"; import { slackEnvironment } from "../../state/slack"; @@ -19,9 +22,10 @@ const CHANGE_ACTION = "link:change"; const UNLINK_ACTION = "link:unlink"; export const LINK_SLACK_ACTION = "tab:link-slack"; export const LINK_NOTION_ACTION = "tab:link-notion"; +export const LINK_GRANOLA_ACTION = "tab:link-granola"; /** - * The Slack thread and Notion page linked to the thread's tab group, with their link pickers. + * The Slack thread, Notion page, and Granola note linked to the thread's tab group, with their link pickers. * Linking needs the integration on, a server that answers with links (older servers have none), * and the orchestration grant; the server still authorizes every change. */ @@ -32,24 +36,34 @@ export function useThreadSlackNotionLinks(environmentId: EnvironmentId, threadId const notionLinks = useEnvironmentQuery( notionEnvironment.threadLinks({ environmentId, input: {} }), ).data; + const granolaLinks = useEnvironmentQuery( + granolaEnvironment.threadLinks({ environmentId, input: {} }), + ).data; const canEditSlack = useAtomValue(slackEnvironment.linkThread.permissionAtom(environmentId)); const canEditNotion = useAtomValue(notionEnvironment.linkThread.permissionAtom(environmentId)); + const canEditGranola = useAtomValue(granolaEnvironment.linkThread.permissionAtom(environmentId)); const slackPicker = useSlackMessagePicker({ mode: "link", environmentId, threadId }); const notionPicker = useNotionPagePicker({ mode: "link", environmentId, threadId }); + const granolaPicker = useGranolaNotePicker({ mode: "link", environmentId, threadId }); const slackLink = slackLinkForThread(slackLinks, threadId); const notionLink = notionLinkForThread(notionLinks, threadId); + const granolaLink = granolaLinkForThread(granolaLinks, threadId); const openSlackPicker = canEditSlack && slackLinks != null ? slackPicker.open : undefined; const openNotionPicker = canEditNotion && notionLinks != null ? notionPicker.open : undefined; + const openGranolaPicker = canEditGranola && granolaLinks != null ? granolaPicker.open : undefined; return { environmentId, threadId, slackLink, notionLink, + granolaLink, canEditSlack, canEditNotion, + canEditGranola, /** Opens the Slack link picker; undefined when linking is unavailable. */ openSlackPicker, openNotionPicker, + openGranolaPicker, /** Tab-menu items for links the group does not have yet; the chips change existing ones. */ menuActions: [ ...(slackLink === null && openSlackPicker @@ -58,11 +72,15 @@ export function useThreadSlackNotionLinks(environmentId: EnvironmentId, threadId ...(notionLink === null && openNotionPicker ? [{ id: LINK_NOTION_ACTION, title: "Link Notion page", image: "link" }] : []), + ...(granolaLink === null && openGranolaPicker + ? [{ id: LINK_GRANOLA_ACTION, title: "Link Granola note", image: "link" }] + : []), ], sheets: ( <> {slackPicker.sheet} {notionPicker.sheet} + {granolaPicker.sheet} ), }; @@ -74,13 +92,14 @@ export type ThreadSlackNotionLinks = ReturnType { + const unlinkGranola = useAtomCommand(granolaEnvironment.unlinkThread, { + label: "granola thread unlink", + reportFailure: false, + }); + const unlink = async ( + command: typeof unlinkSlack | typeof unlinkNotion | typeof unlinkGranola, + title: string, + ) => { const result = await command({ environmentId, input: { threadId } }); if (result._tag !== "Failure") return; const error = squashAtomCommandFailure(result); @@ -135,6 +161,23 @@ export function ThreadSlackNotionLinkChips(props: { readonly links: ThreadSlackN } /> ) : null} + {granolaLink ? ( + void unlink(unlinkGranola, "Could not unlink note") + : undefined + } + /> + ) : null} ); } diff --git a/apps/mobile/src/lib/openExternalUrl.ts b/apps/mobile/src/lib/openExternalUrl.ts index 9282c42530d3f..b487b166c6bf8 100644 --- a/apps/mobile/src/lib/openExternalUrl.ts +++ b/apps/mobile/src/lib/openExternalUrl.ts @@ -10,6 +10,7 @@ const ExternalUrlTarget = Schema.Literals([ "github-issue", "slack", "notion", + "granola", "html-render", "mcp-app", ]); diff --git a/apps/mobile/src/state/granola.ts b/apps/mobile/src/state/granola.ts new file mode 100644 index 0000000000000..533099ccfe5db --- /dev/null +++ b/apps/mobile/src/state/granola.ts @@ -0,0 +1,3 @@ +import { createGranolaEnvironmentAtoms } from "@t3tools/client-runtime/state/granola"; +import { connectionAtomRuntime } from "../connection/runtime"; +export const granolaEnvironment = createGranolaEnvironmentAtoms(connectionAtomRuntime); diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts index 0ffbd8cd0334d..aec50804ea8e4 100644 --- a/apps/server/src/auth/RpcAuthorization.ts +++ b/apps/server/src/auth/RpcAuthorization.ts @@ -180,6 +180,16 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.notionSubscribeThreadLinks]: AuthOrchestrationReadScope, [WS_METHODS.notionLinkThread]: AuthOrchestrationOperateScope, [WS_METHODS.notionUnlinkThread]: AuthOrchestrationOperateScope, + [WS_METHODS.granolaSubscribeState]: AuthOrchestrationReadScope, + [WS_METHODS.granolaStartLogin]: AuthOrchestrationOperateScope, + [WS_METHODS.granolaCancelLogin]: AuthOrchestrationOperateScope, + [WS_METHODS.granolaDisconnect]: AuthOrchestrationOperateScope, + [WS_METHODS.granolaSearchNotes]: AuthOrchestrationReadScope, + [WS_METHODS.granolaGetNote]: AuthOrchestrationReadScope, + [WS_METHODS.granolaGetNoteSummary]: AuthOrchestrationReadScope, + [WS_METHODS.granolaSubscribeThreadLinks]: AuthOrchestrationReadScope, + [WS_METHODS.granolaLinkThread]: AuthOrchestrationOperateScope, + [WS_METHODS.granolaUnlinkThread]: AuthOrchestrationOperateScope, [WS_METHODS.slackSubscribeState]: AuthOrchestrationReadScope, [WS_METHODS.slackSearchMessages]: AuthOrchestrationReadScope, [WS_METHODS.slackGetThread]: AuthOrchestrationReadScope, diff --git a/apps/server/src/granola/GranolaApi.ts b/apps/server/src/granola/GranolaApi.ts new file mode 100644 index 0000000000000..d87b6354700bb --- /dev/null +++ b/apps/server/src/granola/GranolaApi.ts @@ -0,0 +1,161 @@ +import { + GranolaError, + parseGranolaNoteId, + type GranolaGetNoteInput, + type GranolaNoteContext, + type GranolaNoteSummary, + type GranolaSearchNotesInput, + type GranolaSearchNotesResult, +} from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as Clock from "effect/Clock"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import * as HttpClient from "effect/http/HttpClient"; + +import { GranolaAuth } from "./GranolaAuth.ts"; +import { callGranolaTool, granolaNoteContext, parseGranolaMeetings } from "./granolaMcp.ts"; + +const RECENT_TTL_MS = 60_000; +const SUMMARY_CACHE_LIMIT = 500; + +export class GranolaApi extends Context.Service< + GranolaApi, + { + /** The last 30 days of meetings, filtered by title and participants. */ + readonly searchNotes: ( + input: GranolaSearchNotesInput, + ) => Effect.Effect; + readonly getNote: ( + input: GranolaGetNoteInput, + ) => Effect.Effect; + /** The note's title and meeting without its content, read once per note while running. */ + readonly getNoteSummary: ( + input: GranolaGetNoteInput, + ) => Effect.Effect; + } +>()("t3/granola/GranolaApi") {} + +const toSummary = (note: GranolaNoteSummary): GranolaNoteSummary => ({ + id: note.id, + title: note.title, + url: note.url, + meetingAt: note.meetingAt, + participants: note.participants, + creator: note.creator, +}); + +/** @public Canonical Effect service construction. */ +export const make = Effect.gen(function* () { + const auth = yield* GranolaAuth; + const client = yield* HttpClient.HttpClient; + + const callTool = Effect.fn("granola.api.call_tool")(function* ( + name: string, + args: Record, + ) { + const call = (token: string) => + callGranolaTool(client, token, name, args).pipe( + Effect.mapError( + () => new GranolaError({ reason: "api", detail: "Could not reach Granola." }), + ), + ); + const token = yield* auth.accessToken; + let result = yield* call(token); + if (result._tag === "Status" && result.status === 401) + result = yield* call(yield* auth.refreshAccessToken(token)); + if (result._tag === "Ok") return result.text; + if (result._tag === "ToolError") + return yield* new GranolaError({ reason: "api", detail: result.message }); + if (result.status === 401) { + yield* auth.markRevoked; + return yield* new GranolaError({ + reason: "revoked", + detail: "Reconnect Granola in Settings → Integrations.", + }); + } + if (result.status === 429) + return yield* new GranolaError({ + reason: "rate-limited", + detail: "Granola's rate limit was reached. Try again shortly.", + }); + return yield* new GranolaError({ + reason: "api", + detail: `Granola returned HTTP ${result.status}.`, + }); + }); + + // The picker filters as the user types; one listing per account serves every keystroke for a + // minute. Failures are not kept, so connecting takes effect at once. + const recentCache = yield* Ref.make<{ + readonly token: string; + readonly at: number; + readonly notes: ReadonlyArray; + } | null>(null); + const recent = Effect.gen(function* () { + const token = yield* auth.accessToken; + const now = yield* Clock.currentTimeMillis; + const cached = yield* Ref.get(recentCache); + if (cached !== null && cached.token === token && now - cached.at < RECENT_TTL_MS) + return cached.notes; + const notes = parseGranolaMeetings( + yield* callTool("list_meetings", { time_range: "last_30_days" }), + ) + .map(toSummary) + .toSorted((a, b) => (b.meetingAt ?? "").localeCompare(a.meetingAt ?? "")); + yield* Ref.set(recentCache, { token, at: now, notes }); + return notes; + }); + + const getNote = Effect.fn("granola.get_note")(function* (input: GranolaGetNoteInput) { + const id = parseGranolaNoteId(input.id); + if (id === null) + return yield* new GranolaError({ + reason: "not-found", + detail: "Use a Granola note link or meeting ID.", + }); + const meeting = parseGranolaMeetings(yield* callTool("get_meetings", { meeting_ids: [id] })).at( + 0, + ); + if (meeting === undefined) + return yield* new GranolaError({ + reason: "not-found", + detail: + "Granola cannot read this note from the connected account. It may belong to another workspace.", + }); + return granolaNoteContext(meeting); + }); + + // Bare note links in messages are named from this, so one read serves every render of a link. + const summaries = new Map(); + const getNoteSummary = Effect.fn("granola.get_note_summary")(function* ( + input: GranolaGetNoteInput, + ) { + const id = parseGranolaNoteId(input.id); + const cached = id === null ? undefined : summaries.get(id); + if (cached !== undefined) return cached; + const summary = toSummary(yield* getNote(input)); + if (summaries.size >= SUMMARY_CACHE_LIMIT) summaries.delete(summaries.keys().next().value!); + if (id !== null) summaries.set(id, summary); + return summary; + }); + + const searchNotes = Effect.fn("granola.search_notes")(function* (input: GranolaSearchNotesInput) { + const query = input.query.trim(); + if (parseGranolaNoteId(query) !== null) + return { notes: [toSummary(yield* getNote({ id: query }))] }; + const terms = query.toLowerCase().split(/\s+/u).filter(Boolean); + const notes = yield* recent; + return { + notes: notes.filter((note) => { + const haystack = `${note.title} ${note.participants.join(" ")}`.toLowerCase(); + return terms.every((term) => haystack.includes(term)); + }), + }; + }); + + return GranolaApi.of({ searchNotes, getNote, getNoteSummary }); +}); + +export const layer = Layer.effect(GranolaApi, make); diff --git a/apps/server/src/granola/GranolaAuth.test.ts b/apps/server/src/granola/GranolaAuth.test.ts new file mode 100644 index 0000000000000..aae14a78822a7 --- /dev/null +++ b/apps/server/src/granola/GranolaAuth.test.ts @@ -0,0 +1,152 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; +import * as Stream from "effect/Stream"; +import * as HttpClient from "effect/http/HttpClient"; +import * as HttpClientResponse from "effect/http/HttpClientResponse"; +import * as TestClock from "effect/testing/TestClock"; + +import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; +import * as GranolaAuth from "./GranolaAuth.ts"; + +const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown)); + +function makeHarness(input: { readonly pendingPolls: number; readonly denied?: boolean }) { + const secrets = new Map(); + const requests: Array<{ url: string; body: string; authorization: string | undefined }> = []; + let polls = 0; + const client = HttpClient.make((request) => + Effect.sync(() => { + const body = + request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : ""; + requests.push({ url: request.url, body, authorization: request.headers.authorization }); + const reply = (status: number, value: unknown, contentType = "application/json") => + HttpClientResponse.fromWeb( + request, + new Response(typeof value === "string" ? value : encodeJson(value), { + status, + headers: { "content-type": contentType, "mcp-session-id": "session-1" }, + }), + ); + if (request.url.endsWith("/oauth2/register")) return reply(201, { client_id: "client-1" }); + if (request.url.endsWith("/oauth2/device_authorization")) + return reply(200, { + device_code: "device-1", + user_code: "ABCD-EFGH", + verification_uri: "https://mcp-auth.granola.ai/device", + verification_uri_complete: "https://mcp-auth.granola.ai/device?user_code=ABCD-EFGH", + expires_in: 300, + interval: 5, + }); + if (request.url.endsWith("/oauth2/token")) { + polls++; + if (input.denied) return reply(400, { error: "access_denied" }); + if (polls <= input.pendingPolls) return reply(400, { error: "authorization_pending" }); + return reply(200, { access_token: "access-1", refresh_token: "refresh-1" }); + } + // Granola's MCP server: initialize, the initialized notification, then the tool call. + if (body.includes('"tools/call"')) + return reply( + 200, + `event: message\ndata: ${encodeJson({ + jsonrpc: "2.0", + id: 2, + result: { + content: [ + { + type: "text", + text: encodeJson({ + email: "ada@acme.com", + active_workspace: { display_name: "Acme" }, + }), + }, + ], + }, + })}\n\n`, + "text/event-stream", + ); + if (body.includes('"initialize"')) + return reply(200, { jsonrpc: "2.0", id: 1, result: { capabilities: {} } }); + return reply(202, ""); + }), + ); + const layer = GranolaAuth.layer.pipe( + Layer.provide(Layer.succeed(HttpClient.HttpClient, client)), + Layer.provide( + Layer.mock(ServerSecretStore.ServerSecretStore)({ + get: (name) => Effect.sync(() => Option.fromNullishOr(secrets.get(name))), + set: (name, value) => Effect.sync(() => void secrets.set(name, value)), + remove: (name) => Effect.sync(() => void secrets.delete(name)), + }), + ), + Layer.provide(NodeServices.layer), + ); + return { layer, requests, secrets }; +} + +const firstStateWhere = (auth: GranolaAuth.GranolaAuth["Service"], phase: "connected" | "failed") => + auth.state.pipe( + Stream.filter((state) => state.phase === phase), + Stream.runHead, + ); + +it.effect("signs in with a device code and labels the account", () => { + const harness = makeHarness({ pendingPolls: 1 }); + return Effect.gen(function* () { + const auth = yield* GranolaAuth.GranolaAuth; + const waiting = yield* auth.startLogin; + assert.strictEqual(waiting.phase, "waiting"); + assert.strictEqual(waiting.userCode, "ABCD-EFGH"); + assert.strictEqual( + waiting.verificationUrl, + "https://mcp-auth.granola.ai/device?user_code=ABCD-EFGH", + ); + yield* TestClock.adjust("5 seconds"); + yield* TestClock.adjust("5 seconds"); + const connected = yield* firstStateWhere(auth, "connected"); + assert.deepStrictEqual( + Option.map(connected, (state) => state.account), + Option.some({ email: "ada@acme.com", workspaceName: "Acme" }), + ); + assert.strictEqual(yield* auth.accessToken, "access-1"); + // The device request names the MCP server the token is for. + const device = harness.requests.find((request) => + request.url.endsWith("/device_authorization"), + ); + assert.include(device?.body ?? "", "resource=https%3A%2F%2Fmcp.granola.ai%2Fmcp"); + assert.strictEqual( + new TextDecoder().decode(harness.secrets.get("granola-oauth-client")), + "client-1", + ); + }).pipe(Effect.provide(harness.layer)); +}); + +it.effect("reports a denied sign-in", () => { + const harness = makeHarness({ pendingPolls: 0, denied: true }); + return Effect.gen(function* () { + const auth = yield* GranolaAuth.GranolaAuth; + yield* auth.startLogin; + yield* TestClock.adjust("5 seconds"); + const failed = yield* firstStateWhere(auth, "failed"); + assert.deepStrictEqual( + Option.map(failed, (state) => state.message), + Option.some("Granola sign-in was cancelled."), + ); + assert.isFalse(harness.secrets.has("granola-oauth-token")); + }).pipe(Effect.provide(harness.layer)); +}); + +it.effect("cancelling restores the previous state and stops polling", () => { + const harness = makeHarness({ pendingPolls: 0 }); + return Effect.gen(function* () { + const auth = yield* GranolaAuth.GranolaAuth; + const waiting = yield* auth.startLogin; + const restored = yield* auth.cancelLogin({ flowId: waiting.flowId ?? "" }); + assert.strictEqual(restored.phase, "disconnected"); + yield* TestClock.adjust("10 seconds"); + assert.isFalse(harness.requests.some((request) => request.url.endsWith("/oauth2/token"))); + }).pipe(Effect.provide(harness.layer)); +}); diff --git a/apps/server/src/granola/GranolaAuth.ts b/apps/server/src/granola/GranolaAuth.ts new file mode 100644 index 0000000000000..32567ec4045a9 --- /dev/null +++ b/apps/server/src/granola/GranolaAuth.ts @@ -0,0 +1,405 @@ +import { + GranolaAccount, + type GranolaCancelLoginInput, + type GranolaConnectionState, + GranolaError, +} from "@t3tools/contracts"; +import * as Clock from "effect/Clock"; +import * as Context from "effect/Context"; +import * as Crypto from "effect/Crypto"; +import * as DateTime from "effect/DateTime"; +import * as Duration from "effect/Duration"; +import * as Effect from "effect/Effect"; +import * as FiberHandle from "effect/FiberHandle"; +import * as Layer from "effect/Layer"; +import * as Option from "effect/Option"; +import * as Ref from "effect/Ref"; +import * as Schema from "effect/Schema"; +import * as Semaphore from "effect/Semaphore"; +import * as Stream from "effect/Stream"; +import * as SubscriptionRef from "effect/SubscriptionRef"; +import * as HttpClient from "effect/http/HttpClient"; +import * as HttpClientRequest from "effect/http/HttpClientRequest"; + +import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; +import { callGranolaTool, GRANOLA_MCP_URL } from "./granolaMcp.ts"; + +const AUTH_SERVER = "https://mcp-auth.granola.ai"; +const REGISTER_URL = `${AUTH_SERVER}/oauth2/register`; +const DEVICE_URL = `${AUTH_SERVER}/oauth2/device_authorization`; +const TOKEN_URL = `${AUTH_SERVER}/oauth2/token`; +const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code"; +const SCOPE = "openid email profile offline_access"; +const TOKEN_SECRET = "granola-oauth-token"; +const CLIENT_SECRET = "granola-oauth-client"; +const NOT_CONNECTED = "Connect Granola in Settings → Integrations."; + +const PersistedToken = Schema.Struct({ + accessToken: Schema.String, + refreshToken: Schema.NullOr(Schema.String), + account: GranolaAccount, +}); +type PersistedToken = typeof PersistedToken.Type; +const PersistedTokenJson = Schema.fromJsonString(PersistedToken); +const decodeToken = Schema.decodeUnknownEffect(PersistedTokenJson); +const encodeToken = Schema.encodeEffect(PersistedTokenJson); + +const Registration = Schema.Struct({ client_id: Schema.String }); +const DeviceAuthorization = Schema.Struct({ + device_code: Schema.String, + user_code: Schema.String, + verification_uri: Schema.String, + verification_uri_complete: Schema.optional(Schema.String), + expires_in: Schema.Number, + interval: Schema.optional(Schema.Number), +}); +const TokenResponse = Schema.Struct({ + access_token: Schema.String, + refresh_token: Schema.optional(Schema.NullOr(Schema.String)), +}); +const OAuthError = Schema.Struct({ error: Schema.String }); + +const AccountInfo = Schema.Struct({ + email: Schema.String, + active_workspace: Schema.optional( + Schema.NullOr(Schema.Struct({ display_name: Schema.optional(Schema.String) })), + ), +}); + +const decodeOAuthError = Schema.decodeUnknownEffect(OAuthError); +const decodeTokenResponse = Schema.decodeUnknownEffect(TokenResponse); +const decodeDeviceAuthorization = Schema.decodeUnknownEffect(DeviceAuthorization); +const decodeRegistration = Schema.decodeUnknownEffect(Registration); +const decodeAccountInfo = Schema.decodeUnknownEffect(Schema.fromJsonString(AccountInfo)); + +const emptyState: GranolaConnectionState = { + phase: "disconnected", + account: null, + flowId: null, + verificationUrl: null, + userCode: null, + expiresAt: null, + message: null, +}; + +const loginError = (detail: string) => new GranolaError({ reason: "login", detail }); + +interface ActiveFlow { + readonly flowId: string; + /** What to show again if the flow is cancelled. */ + readonly previous: GranolaConnectionState; +} + +export class GranolaAuth extends Context.Service< + GranolaAuth, + { + readonly state: Stream.Stream; + /** Starts a device sign-in; the state carries the code to approve and where. */ + readonly startLogin: Effect.Effect; + readonly cancelLogin: ( + input: GranolaCancelLoginInput, + ) => Effect.Effect; + readonly disconnect: Effect.Effect; + /** The stored access token. Rejected tokens are refreshed by the API boundary. */ + readonly accessToken: Effect.Effect; + /** Rotates a rejected token once across concurrent requests. */ + readonly refreshAccessToken: (rejectedToken: string) => Effect.Effect; + /** Drops the credential when refreshing cannot recover access. */ + readonly markRevoked: Effect.Effect; + } +>()("t3/granola/GranolaAuth") {} + +/** @public Service construction is part of the canonical Effect module API. */ +export const make = Effect.gen(function* () { + const crypto = yield* Crypto.Crypto; + const httpClient = yield* HttpClient.HttpClient; + const secrets = yield* ServerSecretStore.ServerSecretStore; + // Refreshing may rotate the refresh token, so concurrent refreshes would spend the same one. + const tokenLock = yield* Semaphore.make(1); + const flowHandle = yield* FiberHandle.make(); + const activeFlow = yield* Ref.make(null); + + const readSecret = (name: string) => + secrets + .get(name) + .pipe(Effect.map((bytes) => Option.map(bytes, (value) => new TextDecoder().decode(value)))); + const readToken = readSecret(TOKEN_SECRET).pipe( + Effect.flatMap((text) => + Option.isNone(text) ? Effect.succeedNone : decodeToken(text.value).pipe(Effect.asSome), + ), + ); + const persistToken = (token: PersistedToken) => + encodeToken(token).pipe( + Effect.flatMap((encoded) => secrets.set(TOKEN_SECRET, new TextEncoder().encode(encoded))), + Effect.mapError(() => loginError("Could not save the Granola credential.")), + ); + const removeToken = secrets.remove(TOKEN_SECRET).pipe(Effect.ignore); + + const initial = yield* readToken.pipe( + Effect.map((token): GranolaConnectionState => + Option.isSome(token) + ? { ...emptyState, phase: "connected", account: token.value.account } + : emptyState, + ), + Effect.orElseSucceed(() => emptyState), + ); + const state = yield* SubscriptionRef.make(initial); + const fail = (message: string) => + SubscriptionRef.set(state, { ...emptyState, phase: "failed", message }); + + const postForm = (url: string, params: Record) => + Effect.gen(function* () { + const response = yield* HttpClientRequest.post(url).pipe( + HttpClientRequest.bodyUrlParams(params), + httpClient.execute, + ); + const body = yield* response.json; + if (response.status >= 200 && response.status < 300) return { _tag: "Ok", body } as const; + const error = yield* decodeOAuthError(body).pipe( + Effect.orElseSucceed(() => ({ error: `HTTP ${response.status}` })), + ); + return { _tag: "Rejected", error: error.error } as const; + }); + const postToken = (params: Record) => + Effect.gen(function* () { + const result = yield* postForm(TOKEN_URL, params); + if (result._tag === "Rejected") return result; + return { _tag: "Ok", token: yield* decodeTokenResponse(result.body) } as const; + }); + + /** + * Granola has no published client for third parties, so each environment registers its own + * public client once (dynamic client registration) and keeps its id. + */ + const registerClient = Effect.gen(function* () { + const response = yield* HttpClientRequest.post(REGISTER_URL).pipe( + HttpClientRequest.bodyJsonUnsafe({ + client_name: "T3 Code", + grant_types: ["authorization_code", DEVICE_GRANT, "refresh_token"], + response_types: ["code"], + token_endpoint_auth_method: "none", + // Registration requires one, though the device flow never redirects. + redirect_uris: ["http://127.0.0.1/callback"], + }), + httpClient.execute, + ); + const registration = yield* response.json.pipe(Effect.flatMap(decodeRegistration)); + yield* secrets.set(CLIENT_SECRET, new TextEncoder().encode(registration.client_id)); + return registration.client_id; + }).pipe(Effect.mapError(() => loginError("Could not register T3 Code with Granola."))); + const clientId = (renew: boolean) => + renew + ? registerClient + : readSecret(CLIENT_SECRET).pipe( + Effect.orElseSucceed(() => Option.none()), + Effect.flatMap((saved) => + Option.isSome(saved) ? Effect.succeed(saved.value) : registerClient, + ), + ); + + const readAccount = (accessToken: string) => + Effect.gen(function* () { + const result = yield* callGranolaTool(httpClient, accessToken, "get_account_info", {}); + if (result._tag !== "Ok") return null; + const info = yield* decodeAccountInfo(result.text); + return { + email: info.email, + workspaceName: info.active_workspace?.display_name ?? null, + } satisfies GranolaAccount; + }).pipe( + // The account only labels the connection; a reply in a new shape must not block it. + Effect.orElseSucceed(() => null), + Effect.map( + (account): GranolaAccount => account ?? { email: "Granola account", workspaceName: null }, + ), + ); + + /** Polls the token endpoint until the user approves, denies, or the code expires. */ + const pollForToken = (flow: ActiveFlow, id: string, device: typeof DeviceAuthorization.Type) => + Effect.gen(function* () { + let interval = Math.max(device.interval ?? 5, 1); + const deadline = (yield* Clock.currentTimeMillis) + device.expires_in * 1000; + while ((yield* Clock.currentTimeMillis) < deadline) { + yield* Effect.sleep(Duration.seconds(interval)); + const result = yield* postToken({ + grant_type: DEVICE_GRANT, + device_code: device.device_code, + client_id: id, + }).pipe(Effect.mapError(() => loginError("Could not reach Granola to finish sign-in."))); + if (result._tag === "Ok") { + const account = yield* readAccount(result.token.access_token); + yield* persistToken({ + accessToken: result.token.access_token, + refreshToken: result.token.refresh_token ?? null, + account, + }); + return account; + } + if (result.error === "authorization_pending") continue; + if (result.error === "slow_down") { + interval += 5; + continue; + } + return yield* loginError( + result.error === "access_denied" + ? "Granola sign-in was cancelled." + : result.error === "expired_token" + ? "The Granola code expired. Start again." + : `Granola refused the sign-in (${result.error}).`, + ); + } + return yield* loginError("The Granola code expired. Start again."); + }).pipe( + Effect.matchEffect({ + onSuccess: (account) => + SubscriptionRef.set(state, { ...emptyState, phase: "connected", account }), + onFailure: (error) => fail(error.detail), + }), + Effect.ensuring( + Ref.update(activeFlow, (current) => (current?.flowId === flow.flowId ? null : current)), + ), + ); + + const clearFlow = Effect.gen(function* () { + const flow = yield* Ref.getAndSet(activeFlow, null); + yield* FiberHandle.clear(flowHandle); + return flow; + }); + + const requestDeviceCode = (id: string) => + Effect.gen(function* () { + const result = yield* postForm(DEVICE_URL, { + client_id: id, + scope: SCOPE, + resource: GRANOLA_MCP_URL, + }); + if (result._tag === "Rejected") return result; + return { _tag: "Ok", value: yield* decodeDeviceAuthorization(result.body) } as const; + }).pipe(Effect.mapError(() => loginError("Could not reach Granola to start sign-in."))); + + const startLogin = Effect.gen(function* () { + const interrupted = yield* clearFlow; + const previous = interrupted?.previous ?? (yield* SubscriptionRef.get(state)); + let id = yield* clientId(false); + let device = yield* requestDeviceCode(id); + // A client Granola has since forgotten is registered again, once. + if (device._tag === "Rejected" && device.error === "invalid_client") { + id = yield* clientId(true); + device = yield* requestDeviceCode(id); + } + if (device._tag === "Rejected") + return yield* loginError(`Granola refused to start sign-in (${device.error}).`); + const flow: ActiveFlow = { + flowId: yield* crypto.randomUUIDv4.pipe( + Effect.mapError(() => loginError("Could not start Granola sign-in.")), + ), + previous, + }; + yield* Ref.set(activeFlow, flow); + yield* FiberHandle.run(flowHandle, pollForToken(flow, id, device.value)); + const now = yield* Clock.currentTimeMillis; + const waiting: GranolaConnectionState = { + ...previous, + phase: "waiting", + flowId: flow.flowId, + verificationUrl: device.value.verification_uri_complete ?? device.value.verification_uri, + userCode: device.value.user_code, + expiresAt: DateTime.formatIso(DateTime.makeUnsafe(now + device.value.expires_in * 1000)), + message: null, + }; + yield* SubscriptionRef.set(state, waiting); + return waiting; + }).pipe(Effect.withSpan("granola.auth.start_login")); + + const cancelLogin = Effect.fn("granola.auth.cancel_login")(function* ( + input: GranolaCancelLoginInput, + ) { + const flow = yield* Ref.get(activeFlow); + if (flow === null || flow.flowId !== input.flowId) + return yield* loginError("This Granola sign-in is no longer active. Start again."); + yield* clearFlow; + yield* SubscriptionRef.set(state, flow.previous); + return flow.previous; + }); + + const disconnect = tokenLock + .withPermits(1)( + Effect.gen(function* () { + yield* clearFlow; + const token = yield* readToken.pipe(Effect.orElseSucceed(() => Option.none())); + // Signing out revokes this client's grant; a failure must not keep the credential. + if (Option.isSome(token)) + yield* callGranolaTool(httpClient, token.value.accessToken, "sign_out", {}).pipe( + Effect.timeout(Duration.seconds(5)), + Effect.ignore, + ); + yield* removeToken; + yield* SubscriptionRef.set(state, emptyState); + return emptyState; + }), + ) + .pipe(Effect.withSpan("granola.auth.disconnect")); + + const markRevoked = tokenLock.withPermits(1)( + Effect.andThen( + removeToken, + fail("Granola access was revoked or has expired. Reconnect Granola."), + ), + ); + + const accessToken = readToken.pipe( + Effect.mapError( + () => new GranolaError({ reason: "api", detail: "Could not read the Granola credential." }), + ), + Effect.flatMap((stored) => + Option.isSome(stored) + ? Effect.succeed(stored.value.accessToken) + : Effect.fail(new GranolaError({ reason: "not-connected", detail: NOT_CONNECTED })), + ), + ); + + const revoked = new GranolaError({ + reason: "revoked", + detail: "Reconnect Granola in Settings → Integrations.", + }); + // Only one caller rotates a rejected token; others reuse the token it saved. + const refreshAccessToken = (rejectedToken: string) => + tokenLock + .withPermits(1)( + Effect.gen(function* () { + const stored = yield* readToken.pipe( + Effect.mapError(() => loginError("Could not read the Granola credential.")), + ); + if (Option.isNone(stored)) + return yield* new GranolaError({ reason: "not-connected", detail: NOT_CONNECTED }); + if (stored.value.accessToken !== rejectedToken) return stored.value.accessToken; + if (stored.value.refreshToken === null) return yield* revoked; + const id = yield* clientId(false); + const result = yield* postToken({ + grant_type: "refresh_token", + refresh_token: stored.value.refreshToken, + client_id: id, + }).pipe(Effect.mapError(() => loginError("Could not refresh Granola access."))); + if (result._tag === "Rejected") return yield* revoked; + yield* persistToken({ + ...stored.value, + accessToken: result.token.access_token, + refreshToken: result.token.refresh_token ?? stored.value.refreshToken, + }); + return result.token.access_token; + }), + ) + .pipe(Effect.tapError((error) => (error.reason === "revoked" ? markRevoked : Effect.void))); + + return GranolaAuth.of({ + state: SubscriptionRef.changes(state), + startLogin, + cancelLogin, + disconnect, + accessToken, + refreshAccessToken, + markRevoked, + }); +}); + +export const layer = Layer.effect(GranolaAuth, make); diff --git a/apps/server/src/granola/GranolaThreadLinks.test.ts b/apps/server/src/granola/GranolaThreadLinks.test.ts new file mode 100644 index 0000000000000..e8f392f108a9a --- /dev/null +++ b/apps/server/src/granola/GranolaThreadLinks.test.ts @@ -0,0 +1,91 @@ +import { GranolaError, ThreadId } from "@t3tools/contracts"; +import { assert, it } from "@effect/vitest"; +import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as SqlClient from "effect/sql/SqlClient"; + +import { runMigrations } from "../persistence/Migrations.ts"; +import { ensureThreadTabsSchema } from "../threadTabs/schema.ts"; +import { GranolaApi } from "./GranolaApi.ts"; +import * as GranolaThreadLinks from "./GranolaThreadLinks.ts"; +import { ensureGranolaThreadLinksSchema } from "./threadLinksSchema.ts"; + +const notes: Record = { "note-1": "Launch review", "note-2": "Weekly sync" }; + +const sqlLayer = NodeSqliteClient.layer({ filename: ":memory:" }); +const schemaLayer = Layer.effectDiscard( + Effect.gen(function* () { + yield* runMigrations(); + yield* ensureThreadTabsSchema(); + yield* ensureGranolaThreadLinksSchema(); + }), +); +const apiLayer = Layer.mock(GranolaApi)({ + getNoteSummary: ({ id }) => { + const title = notes[id]; + return title === undefined + ? Effect.fail(new GranolaError({ reason: "not-found", detail: "Note not found" })) + : Effect.succeed({ + id, + title, + url: `https://notes.granola.ai/d/${id}`, + meetingAt: "2026-09-30T09:00:00.000Z", + participants: ["Ada"], + creator: "Ada", + }); + }, +}); + +const testLayer = GranolaThreadLinks.layer.pipe( + Layer.provideMerge(apiLayer), + Layer.provideMerge(schemaLayer), + Layer.provideMerge(sqlLayer), +); + +const first = ThreadId.make("first"); +const second = ThreadId.make("second"); + +it.layer(testLayer)("GranolaThreadLinks", (it) => { + it.effect("links a tab group once, whichever tab links it", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + const links = yield* GranolaThreadLinks.GranolaThreadLinks; + yield* sql` + INSERT INTO fork_thread_tabs (thread_id, group_id, position, created_at) VALUES + ('first', 'first', 0, '2026-01-01T00:00:00.000Z'), + ('second', 'first', 1, '2026-01-01T00:00:01.000Z') + `; + yield* links.refresh; + + const linked = yield* links.link({ threadId: second, noteId: "note-1" }); + assert.strictEqual(linked.groupId, first); + assert.deepEqual(linked.threadIds, [first, second]); + assert.strictEqual(linked.title, "Launch review"); + + // Linking again from the other tab replaces the group's note. + const relinked = yield* links.link({ threadId: first, noteId: "note-2" }); + assert.strictEqual(relinked.title, "Weekly sync"); + const rows = yield* sql<{ readonly n: number }>` + SELECT COUNT(*) AS n FROM fork_granola_thread_links + `; + assert.strictEqual(rows[0]?.n, 1); + + yield* links.unlink({ threadId: second }); + const remaining = yield* sql<{ readonly n: number }>` + SELECT COUNT(*) AS n FROM fork_granola_thread_links + `; + assert.strictEqual(remaining[0]?.n, 0); + }), + ); + + it.effect("refuses a note Granola cannot read", () => + Effect.gen(function* () { + const links = yield* GranolaThreadLinks.GranolaThreadLinks; + const error = yield* links + .link({ threadId: ThreadId.make("solo"), noteId: "note-404" }) + .pipe(Effect.flip); + assert.strictEqual(error.reason, "not-found"); + }), + ); +}); diff --git a/apps/server/src/granola/GranolaThreadLinks.ts b/apps/server/src/granola/GranolaThreadLinks.ts new file mode 100644 index 0000000000000..f0c881ea0476b --- /dev/null +++ b/apps/server/src/granola/GranolaThreadLinks.ts @@ -0,0 +1,126 @@ +import { + GranolaError, + type GranolaLinkThreadInput, + type GranolaThreadLink, + type GranolaThreadLinks as GranolaThreadLinksList, + type GranolaUnlinkThreadInput, + ThreadId, +} from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as DateTime from "effect/DateTime"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import type * as Stream from "effect/Stream"; +import * as SubscriptionRef from "effect/SubscriptionRef"; +import * as SqlClient from "effect/sql/SqlClient"; + +import { GranolaApi } from "./GranolaApi.ts"; + +interface LinkRow { + readonly groupId: string; + readonly noteId: string; + readonly title: string; + readonly url: string; + readonly linkedAt: string; + readonly threadId: string | null; +} + +/** Folds the joined rows into one link per group; the group's own id is always a member. */ +export function groupLinkRows(rows: ReadonlyArray): GranolaThreadLinksList { + const links = new Map(); + for (const row of rows) { + let link = links.get(row.groupId); + if (link === undefined) { + link = { + groupId: ThreadId.make(row.groupId), + threadIds: [ThreadId.make(row.groupId)], + noteId: row.noteId, + title: row.title, + url: row.url, + linkedAt: row.linkedAt, + }; + links.set(row.groupId, link); + } + if (row.threadId !== null && !link.threadIds.includes(row.threadId as ThreadId)) { + link.threadIds.push(ThreadId.make(row.threadId)); + } + } + return [...links.values()]; +} + +const storageError = () => + new GranolaError({ reason: "api", detail: "Could not save the Granola note link." }); + +export class GranolaThreadLinks extends Context.Service< + GranolaThreadLinks, + { + /** Every link in the environment, re-emitted whenever a link or tab group changes. */ + readonly links: Stream.Stream; + readonly link: ( + input: GranolaLinkThreadInput, + ) => Effect.Effect; + readonly unlink: (input: GranolaUnlinkThreadInput) => Effect.Effect; + /** Re-reads group membership after a tab joins a group. */ + readonly refresh: Effect.Effect; + } +>()("t3/granola/GranolaThreadLinks") {} + +/** @public Service construction is part of the canonical Effect module API. */ +export const make = Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + const api = yield* GranolaApi; + + const read = sql` + SELECT l.group_id AS "groupId", l.note_id AS "noteId", l.title, l.url, + l.linked_at AS "linkedAt", t.thread_id AS "threadId" + FROM fork_granola_thread_links l + LEFT JOIN fork_thread_tabs t ON t.group_id = l.group_id + ORDER BY l.linked_at, t.position, t.created_at + `.pipe(Effect.map(groupLinkRows)); + + const state = yield* SubscriptionRef.make(yield* read.pipe(Effect.orDie)); + const refresh = read.pipe( + Effect.flatMap((links) => SubscriptionRef.set(state, links)), + Effect.catch((cause) => Effect.logWarning("Could not re-read Granola thread links", cause)), + ); + + const groupIdFor = (threadId: ThreadId) => + sql<{ readonly groupId: string }>` + SELECT group_id AS "groupId" FROM fork_thread_tabs WHERE thread_id = ${threadId} + `.pipe(Effect.map((rows) => rows[0]?.groupId ?? threadId)); + + const link = Effect.fn("granola.link_thread")(function* (input: GranolaLinkThreadInput) { + // Validates the note and copies what identifies it. + const note = yield* api.getNoteSummary({ id: input.noteId }); + const groupId = yield* groupIdFor(input.threadId).pipe(Effect.mapError(storageError)); + const linkedAt = DateTime.formatIso(yield* DateTime.now); + yield* sql` + INSERT INTO fork_granola_thread_links (group_id, note_id, title, url, linked_at) + VALUES (${groupId}, ${note.id}, ${note.title}, ${note.url}, ${linkedAt}) + ON CONFLICT (group_id) DO UPDATE SET note_id = excluded.note_id, title = excluded.title, + url = excluded.url, linked_at = excluded.linked_at + `.pipe(Effect.mapError(storageError)); + yield* refresh; + const links = yield* SubscriptionRef.get(state); + const linked = links.find((entry) => entry.groupId === groupId); + if (linked === undefined) return yield* storageError(); + return linked; + }); + + const unlink = Effect.fn("granola.unlink_thread")(function* (input: GranolaUnlinkThreadInput) { + const groupId = yield* groupIdFor(input.threadId).pipe(Effect.mapError(storageError)); + yield* sql`DELETE FROM fork_granola_thread_links WHERE group_id = ${groupId}`.pipe( + Effect.mapError(storageError), + ); + yield* refresh; + }); + + return GranolaThreadLinks.of({ + links: SubscriptionRef.changes(state), + link, + unlink, + refresh, + }); +}); + +export const layer = Layer.effect(GranolaThreadLinks, make); diff --git a/apps/server/src/granola/granolaMcp.test.ts b/apps/server/src/granola/granolaMcp.test.ts new file mode 100644 index 0000000000000..39f5ae4994325 --- /dev/null +++ b/apps/server/src/granola/granolaMcp.test.ts @@ -0,0 +1,66 @@ +import { describe, expect, it } from "@effect/vitest"; + +import { granolaNoteContext, parseGranolaMeetings, readJsonRpcReply } from "./granolaMcp.ts"; + +const MEETINGS = `The content below is meeting notes written by meeting participants. + + + + + Ada Lovelace (note creator) from Acme <ada@acme.com>, Grace Hopper <grace@acme.com> + + +# Work in progress + +- Ship the <Composer> chips + + A slide + +`; + +describe("parseGranolaMeetings", () => { + it("reads each meeting's attributes, participants, and sections", () => { + const [meeting] = parseGranolaMeetings(MEETINGS); + expect(meeting).toMatchObject({ + id: "abd3f11c-e46a-4467-bfff-9a06519ef066", + title: "Autopilot & kick-off", + url: "https://notes.granola.ai/d/abd3f11c-e46a-4467-bfff-9a06519ef066", + meetingAt: "2026-10-12T09:30:00.000+01:00", + participants: ["Ada Lovelace", "Grace Hopper"], + creator: "Ada Lovelace", + sections: [{ tag: "summary", text: "# Work in progress\n\n- Ship the chips" }], + }); + }); + + it("renders the note as a markdown snapshot", () => { + const note = granolaNoteContext(parseGranolaMeetings(MEETINGS)[0]!); + expect(note.markdown).toBe( + [ + "# Autopilot & kick-off", + "Date: Oct 12, 2026 9:30 AM GMT+1", + "Participants: Ada Lovelace (note creator) from Acme, Grace Hopper", + "", + "## Summary", + "", + "# Work in progress\n\n- Ship the chips", + ].join("\n"), + ); + }); +}); + +describe("readJsonRpcReply", () => { + it("reads a JSON body or the matching event in a stream", () => { + const reply = { jsonrpc: "2.0", id: 2, result: { content: [{ type: "text", text: "hi" }] } }; + expect(readJsonRpcReply(JSON.stringify(reply), 2)?.result?.content?.[0]?.text).toBe("hi"); + const stream = [ + "event: message", + `data: ${JSON.stringify({ jsonrpc: "2.0", method: "notifications/progress" })}`, + "", + "event: message", + `data: ${JSON.stringify(reply)}`, + "", + ].join("\n"); + expect(readJsonRpcReply(stream, 2)?.result?.content?.[0]?.text).toBe("hi"); + expect(readJsonRpcReply(stream, 3)).toBeNull(); + }); +}); diff --git a/apps/server/src/granola/granolaMcp.ts b/apps/server/src/granola/granolaMcp.ts new file mode 100644 index 0000000000000..ea12f6e126dfd --- /dev/null +++ b/apps/server/src/granola/granolaMcp.ts @@ -0,0 +1,226 @@ +import { + GRANOLA_NOTE_MARKDOWN_MAX_CHARS, + type GranolaNoteContext, + type GranolaNoteSummary, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Schema from "effect/Schema"; +import * as HttpClient from "effect/http/HttpClient"; +import * as HttpClientRequest from "effect/http/HttpClientRequest"; + +/** + * Granola has no public API for every plan, so T3 Code reads notes through Granola's MCP server + * (the one Claude and ChatGPT connect to), over plain JSON-RPC on Streamable HTTP. + */ +export const GRANOLA_MCP_URL = "https://mcp.granola.ai/mcp"; +const PROTOCOL_VERSION = "2025-06-18"; + +const JsonRpcReply = Schema.Struct({ + id: Schema.optional(Schema.Union([Schema.Number, Schema.String, Schema.Null])), + result: Schema.optional( + Schema.Struct({ + content: Schema.optional( + Schema.Array(Schema.Struct({ type: Schema.String, text: Schema.optional(Schema.String) })), + ), + isError: Schema.optional(Schema.Boolean), + }), + ), + error: Schema.optional(Schema.Struct({ message: Schema.String })), +}); +type JsonRpcReply = typeof JsonRpcReply.Type; +const decodeReply = Schema.decodeUnknownOption(Schema.fromJsonString(JsonRpcReply)); + +/** The reply with `id`, from a JSON body or the `data:` lines of an event stream. */ +export function readJsonRpcReply(body: string, id: number): JsonRpcReply | null { + const candidates = body.trimStart().startsWith("{") + ? [body] + : body + .split(/\r?\n/u) + .filter((line) => line.startsWith("data:")) + .map((line) => line.slice(5).trim()); + for (const candidate of candidates) { + const reply = decodeReply(candidate); + if (reply._tag === "Some" && reply.value.id === id) return reply.value; + } + return null; +} + +export type GranolaToolResult = + | { readonly _tag: "Ok"; readonly text: string } + | { readonly _tag: "Status"; readonly status: number } + | { readonly _tag: "ToolError"; readonly message: string }; + +/** + * Opens a session, calls one tool, and returns its text. HTTP failures come back as their status + * so callers can refresh a rejected token and retry. + */ +export const callGranolaTool = Effect.fn("granola.mcp.call_tool")(function* ( + client: HttpClient.HttpClient, + token: string, + name: string, + args: Record, +) { + const post = (body: Record, sessionId: string | undefined) => + HttpClientRequest.post(GRANOLA_MCP_URL).pipe( + HttpClientRequest.bearerToken(token), + HttpClientRequest.setHeader("Accept", "application/json, text/event-stream"), + HttpClientRequest.setHeader("MCP-Protocol-Version", PROTOCOL_VERSION), + sessionId === undefined + ? (request) => request + : HttpClientRequest.setHeader("Mcp-Session-Id", sessionId), + HttpClientRequest.bodyJsonUnsafe({ jsonrpc: "2.0", ...body }), + client.execute, + ); + const initialized = yield* post( + { + id: 1, + method: "initialize", + params: { + protocolVersion: PROTOCOL_VERSION, + capabilities: {}, + clientInfo: { name: "T3 Code", version: "1.0.0" }, + }, + }, + undefined, + ); + if (initialized.status < 200 || initialized.status >= 300) + return { _tag: "Status", status: initialized.status } as GranolaToolResult; + const sessionId = initialized.headers["mcp-session-id"]; + // Drain the reply so the connection is released before the next request. + yield* initialized.text; + yield* post({ method: "notifications/initialized" }, sessionId).pipe( + Effect.flatMap((response) => response.text), + ); + const called = yield* post( + { id: 2, method: "tools/call", params: { name, arguments: args } }, + sessionId, + ); + if (called.status < 200 || called.status >= 300) + return { _tag: "Status", status: called.status } as GranolaToolResult; + const reply = readJsonRpcReply(yield* called.text, 2); + if (reply === null) return { _tag: "ToolError", message: "Granola returned no reply." } as const; + if (reply.error) return { _tag: "ToolError", message: reply.error.message } as const; + const text = (reply.result?.content ?? []) + .flatMap((part) => (part.type === "text" && part.text !== undefined ? [part.text] : [])) + .join("\n"); + return reply.result?.isError + ? ({ _tag: "ToolError", message: text || "Granola could not run the request." } as const) + : ({ _tag: "Ok", text } as const); +}); + +const ENTITIES: Record = { + amp: "&", + lt: "<", + gt: ">", + quot: '"', + apos: "'", +}; +function unescapeXml(value: string): string { + return value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/giu, (whole, entity: string) => { + if (entity.startsWith("#x")) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16)); + if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10)); + return ENTITIES[entity.toLowerCase()] ?? whole; + }); +} + +interface GranolaMeeting extends GranolaNoteSummary { + /** The meeting's sections other than participants, such as `summary` and `private_notes`. */ + readonly sections: ReadonlyArray<{ readonly tag: string; readonly text: string }>; + readonly date: string | null; + /** Participants as Granola describes them, with companies but without email addresses. */ + readonly participantsText: string; +} + +/** + * Granola lists participants as `Ada Lovelace (note creator) from Acme , …`. Names + * come without the role, company, and address; the description keeps the company for agents. + */ +export function readParticipants(value: string) { + const text = value + .replace(/\s*<[^>]*>/gu, "") + .replace(/\s+/gu, " ") + .trim(); + let creator: string | null = null; + const names = text.split(/\s*,\s*/u).flatMap((entry) => { + const name = entry + .replace(/\s*\(note creator\)/u, "") + .replace(/\s+from\s+.*$/u, "") + .trim(); + if (name && entry.includes("(note creator)")) creator = name; + return name ? [name] : []; + }); + return { text, names: [...new Set(names)], creator: creator as string | null }; +} + +/** The `` elements Granola's `list_meetings` and `get_meetings` tools reply with. */ +export function parseGranolaMeetings(text: string): ReadonlyArray { + const meetings: Array = []; + for (const match of text.matchAll(/]*)>([\s\S]*?)<\/meeting>/gu)) { + const attributes = new Map( + Array.from(match[1]!.matchAll(/([a-z_]+)="([^"]*)"/gu), (attribute) => [ + attribute[1]!, + unescapeXml(attribute[2]!), + ]), + ); + const id = attributes.get("id"); + if (!id) continue; + const sections: Array<{ tag: string; text: string }> = []; + let participants = readParticipants(""); + for (const section of match[2]!.matchAll(/<([a-z_]+)(?:\s[^>]*)?>([\s\S]*?)<\/\1>/gu)) { + const content = unescapeXml(section[2]!).trim(); + if (section[1] === "known_participants") participants = readParticipants(content); + else if (content && section[1] !== "attachments") + sections.push({ tag: section[1]!, text: content }); + } + meetings.push({ + id, + title: attributes.get("title")?.trim() || "Untitled meeting", + url: attributes.get("url") ?? `https://notes.granola.ai/d/${id}`, + meetingAt: attributes.get("meeting_at") ?? attributes.get("created_at") ?? null, + participants: participants.names, + creator: participants.creator, + participantsText: participants.text, + date: attributes.get("date") ?? null, + sections, + }); + } + return meetings; +} + +const SECTION_TITLES: Record = { + summary: "Summary", + private_notes: "Notes", + notes: "Notes", +}; +function sectionTitle(tag: string): string { + const words = tag.replaceAll("_", " "); + return SECTION_TITLES[tag] ?? words.charAt(0).toUpperCase() + words.slice(1); +} + +/** The note as the capped markdown snapshot attached to a message. */ +export function granolaNoteContext(meeting: GranolaMeeting): GranolaNoteContext { + const header = [ + `# ${meeting.title}`, + ...(meeting.date ? [`Date: ${meeting.date}`] : []), + ...(meeting.participantsText ? [`Participants: ${meeting.participantsText}`] : []), + ].join("\n"); + const body = meeting.sections.map( + (section) => `## ${sectionTitle(section.tag)}\n\n${section.text}`, + ); + const markdown = [header, ...(body.length > 0 ? body : ["_This note has no summary yet._"])].join( + "\n\n", + ); + const note = "\n\n[Granola note content is truncated.]"; + return { + id: meeting.id, + title: meeting.title, + url: meeting.url, + meetingAt: meeting.meetingAt, + participants: meeting.participants, + creator: meeting.creator, + markdown: + markdown.length > GRANOLA_NOTE_MARKDOWN_MAX_CHARS + ? markdown.slice(0, GRANOLA_NOTE_MARKDOWN_MAX_CHARS - note.length) + note + : markdown, + }; +} diff --git a/apps/server/src/granola/threadLinksSchema.ts b/apps/server/src/granola/threadLinksSchema.ts new file mode 100644 index 0000000000000..bdf925d23be40 --- /dev/null +++ b/apps/server/src/granola/threadLinksSchema.ts @@ -0,0 +1,19 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/sql/SqlClient"; + +/** One linked Granola note per chat-tab group. Runs after `ensureThreadTabsSchema`. */ +export const ensureGranolaThreadLinksSchema = Effect.fn("GranolaThreadLinks.ensureSchema")( + function* () { + const sql = yield* SqlClient.SqlClient; + yield* sql` + CREATE TABLE IF NOT EXISTS fork_granola_thread_links ( + group_id TEXT PRIMARY KEY, + note_id TEXT NOT NULL, + title TEXT NOT NULL, + url TEXT NOT NULL, + linked_at TEXT NOT NULL + ) + `; + yield* sql`INSERT OR IGNORE INTO fork_schema_migrations (feature, version) VALUES ('granola_thread_links', 1)`; + }, +); diff --git a/apps/server/src/mcp/McpContextLinks.test.ts b/apps/server/src/mcp/McpContextLinks.test.ts index 8b03c5e5be680..a04ede73297a5 100644 --- a/apps/server/src/mcp/McpContextLinks.test.ts +++ b/apps/server/src/mcp/McpContextLinks.test.ts @@ -11,6 +11,7 @@ import * as Layer from "effect/Layer"; import * as GitHubIssues from "../githubIssues/GitHubIssues.ts"; import * as LinearApi from "../linear/LinearApi.ts"; +import * as GranolaApi from "../granola/GranolaApi.ts"; import * as NotionApi from "../notion/NotionApi.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as SlackApi from "../slack/SlackApi.ts"; @@ -43,6 +44,9 @@ const slackThread = (input: SlackGetThreadInput): SlackThreadContext => ({ markdown: "Deploy is stuck\n\n> on it", }); +const GRANOLA_ID = "abd3f11c-e46a-4467-bfff-9a06519ef066"; +const GRANOLA_URL = `https://notes.granola.ai/d/${GRANOLA_ID}`; + let slackRequests: Array = []; const layer = (settings: Parameters[0] = {}) => @@ -62,6 +66,18 @@ const layer = (settings: Parameters[0] = {}) => getPage: () => Effect.fail(new NotionError({ reason: "not-found", detail: "Page not found." })), }), + Layer.mock(GranolaApi.GranolaApi, { + getNote: (input) => + Effect.succeed({ + id: input.id, + title: "Weekly sync", + url: GRANOLA_URL, + meetingAt: "2026-10-12T09:30:00.000+01:00", + participants: ["Ada", "Grace"], + creator: "Ada", + markdown: "# Weekly sync\n\n## Summary\n\nShipped it.", + }), + }), Layer.mock(GitHubIssues.GitHubIssues, {}), ServerSettings.layerTest(settings), ), @@ -122,6 +138,27 @@ it.effect("says how to share a Notion page the connection cannot read", () => }).pipe(Effect.provide(layer())), ); +it.effect("attaches a Granola note as its chip", () => + Effect.gen(function* () { + const result = yield* attach(`Notes: ${GRANOLA_URL}`, [GRANOLA_URL]); + assert.strictEqual( + result.text, + `Notes: [Weekly sync](t3-context://v1/granola-note/granola-note_${GRANOLA_ID})`, + ); + assert.deepStrictEqual( + result.context?.records.map((record) => record.kind), + ["granola-note"], + ); + }).pipe(Effect.provide(layer())), +); + +it.effect("refuses a Granola note while the integration is off", () => + Effect.gen(function* () { + const error = yield* Effect.flip(attach("", [GRANOLA_URL])); + assert.include(error.message, "Granola integration is turned off"); + }).pipe(Effect.provide(layer({ enableGranolaIntegration: false }))), +); + it.effect("passes on why an integration could not read a link", () => Effect.gen(function* () { const error = yield* Effect.flip(attach("", [SLACK_URL])); @@ -139,6 +176,7 @@ it.effect("passes on why an integration could not read a link", () => ), }), Layer.mock(NotionApi.NotionApi, {}), + Layer.mock(GranolaApi.GranolaApi, {}), Layer.mock(GitHubIssues.GitHubIssues, {}), ServerSettings.layerTest(), ), diff --git a/apps/server/src/mcp/McpContextLinks.ts b/apps/server/src/mcp/McpContextLinks.ts index d7b0a66df829d..88ed9e7d10a4d 100644 --- a/apps/server/src/mcp/McpContextLinks.ts +++ b/apps/server/src/mcp/McpContextLinks.ts @@ -1,6 +1,7 @@ import { type ComposerContextRecord, GitHubGetIssueInput, + GranolaGetNoteInput, LinearGetIssueInput, NotionGetPageInput, type OrchestrationMessageContext, @@ -15,6 +16,7 @@ import { } from "@t3tools/shared/composerObjectLinks"; import { gitHubIssueContextRecord, + granolaNoteContextRecord, linearIssueContextRecord, notionPageContextRecord, repositoryContextRecord, @@ -26,6 +28,7 @@ import * as Layer from "effect/Layer"; import * as Schema from "effect/Schema"; import * as GitHubIssues from "../githubIssues/GitHubIssues.ts"; +import * as GranolaApi from "../granola/GranolaApi.ts"; import * as LinearApi from "../linear/LinearApi.ts"; import * as NotionApi from "../notion/NotionApi.ts"; import * as ServerSettings from "../serverSettings.ts"; @@ -54,6 +57,7 @@ export class McpContextLinks extends Context.Service< const decodeLinearGetIssueInput = Schema.decodeUnknownEffect(LinearGetIssueInput); const decodeGitHubGetIssueInput = Schema.decodeUnknownEffect(GitHubGetIssueInput); const decodeNotionGetPageInput = Schema.decodeUnknownEffect(NotionGetPageInput); +const decodeGranolaGetNoteInput = Schema.decodeUnknownEffect(GranolaGetNoteInput); const decodeSlackGetThreadInput = Schema.decodeUnknownEffect(SlackGetThreadInput); const invalid = (message: string) => @@ -65,11 +69,14 @@ const unreadable = (url: string) => (error: { readonly message: string }) => export const make = Effect.gen(function* () { const linear = yield* LinearApi.LinearApi; const notion = yield* NotionApi.NotionApi; + const granola = yield* GranolaApi.GranolaApi; const slack = yield* SlackApi.SlackApi; const gitHubIssues = yield* GitHubIssues.GitHubIssues; const settings = yield* ServerSettings.ServerSettingsService; - const integrationEnabled = (key: "enableSlackIntegration" | "enableNotionIntegration") => + const integrationEnabled = ( + key: "enableSlackIntegration" | "enableNotionIntegration" | "enableGranolaIntegration", + ) => settings.getSettings.pipe( Effect.map((current) => current[key]), Effect.orElseSucceed(() => true), @@ -119,6 +126,18 @@ export const make = Effect.gen(function* () { ); return notionPageContextRecord(page); }); + case "granola-note": + return Effect.gen(function* () { + if (!(yield* integrationEnabled("enableGranolaIntegration"))) + return yield* invalid( + `Could not attach ${url}: the Granola integration is turned off in Settings → Integrations.`, + ); + const input = yield* decodeGranolaGetNoteInput({ id: link.noteId }).pipe( + Effect.mapError(malformed(url)), + ); + const note = yield* granola.getNote(input).pipe(Effect.mapError(unreadable(url))); + return granolaNoteContextRecord(note); + }); case "slack-message": return Effect.gen(function* () { if (!(yield* integrationEnabled("enableSlackIntegration"))) @@ -155,7 +174,7 @@ export const make = Effect.gen(function* () { return link === null ? Effect.fail( invalid( - `${url} is not a link T3 Code can attach. Use a Slack message, Notion page, Linear issue, GitHub issue, or GitHub repository link.`, + `${url} is not a link T3 Code can attach. Use a Slack message, Notion page, Granola note, Linear issue, GitHub issue, or GitHub repository link.`, ), ) : Effect.succeed(link); @@ -186,6 +205,7 @@ export const layer: Layer.Layer< never, | LinearApi.LinearApi | NotionApi.NotionApi + | GranolaApi.GranolaApi | SlackApi.SlackApi | GitHubIssues.GitHubIssues | ServerSettings.ServerSettingsService diff --git a/apps/server/src/mcp/toolkits/orchestrator/tools.ts b/apps/server/src/mcp/toolkits/orchestrator/tools.ts index 42a00b9d87e40..a65e0399c1c32 100644 --- a/apps/server/src/mcp/toolkits/orchestrator/tools.ts +++ b/apps/server/src/mcp/toolkits/orchestrator/tools.ts @@ -240,7 +240,7 @@ export const ThreadUpdateTool = Tool.make("t3_thread_update", { const ThreadSendTool = Tool.make("t3_thread_send", { description: - "Send a message to any T3 thread in this environment. The target cannot have broader permission modes than the caller. Use delegate_task with the full review context and a new clientRequestId for independent review rounds. For a follow-up that needs the same child's conversation, send to its childThreadId. After the original task completes, a requested follow-up creates a fresh task in that child thread and returns taskId; its completion notifies the parent, and the original result stays unchanged. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. Pass contextLinks to attach Slack threads, Notion pages, Linear issues, GitHub issues, or repositories as context chips, as a user would. clientRequestId makes retries idempotent.", + "Send a message to any T3 thread in this environment. The target cannot have broader permission modes than the caller. Use delegate_task with the full review context and a new clientRequestId for independent review rounds. For a follow-up that needs the same child's conversation, send to its childThreadId. After the original task completes, a requested follow-up creates a fresh task in that child thread and returns taskId; its completion notifies the parent, and the original result stays unchanged. mode='auto' starts an idle thread, steers a fully active turn, or queues behind a turn that is not yet steerable. Use queue for a separate follow-up turn, steer for an in-flight update, or restart to interrupt-and-restart the active turn. Pass contextLinks to attach Slack threads, Notion pages, Granola notes, Linear issues, GitHub issues, or repositories as context chips, as a user would. clientRequestId makes retries idempotent.", parameters: OrchestratorMcpThreadSendInput, success: OrchestratorMcpThreadSendResult, failure: OrchestratorMcpFailure, diff --git a/apps/server/src/mcp/toolkits/project/tools.ts b/apps/server/src/mcp/toolkits/project/tools.ts index dd6decf127f2b..6509277aaa630 100644 --- a/apps/server/src/mcp/toolkits/project/tools.ts +++ b/apps/server/src/mcp/toolkits/project/tools.ts @@ -106,7 +106,7 @@ const ProjectCloneTool = Tool.make("t3_project_clone", { const ThreadLaunchTool = Tool.make("t3_thread_launch", { ...shared, description: - 'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents, which takes the same worktree strategies. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings from the calling thread; a caller outside a T3 thread must pass projectId and gets the project\'s default model. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. To link a thread for the user, write `[title](t3-thread://v1/)` with the threadId exactly as returned, not URL-encoded; T3 Code shows the thread\'s current title. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. contextLinks attaches Slack threads, Notion pages, Linear issues, GitHub issues, or repositories to the first message as context chips, as a user would. The new thread may not run with broader runtime or interaction modes than the caller: the calling T3 thread\'s own modes, or the permission mode an outside agent was approved with.', + 'Create an ordinary TOP-LEVEL thread with an explicit workspace binding before its agent starts. Use this when the user requests independent work, a new thread, or a PR stack in its own worktree; use delegate_task for child subagents, which takes the same worktree strategies. Set workspaceStrategy to {type:"worktree",baseRef:"parent-branch",branch:"new-branch",startFromOrigin:false} for a new worktree based on local commits, or {type:"existing_worktree",worktreePath:"/absolute/path",branch:"existing-branch"} to use an existing checkout. For upstream commits, set startFromOrigin:true. Omitted workspaceStrategy means the project root, NOT the caller\'s worktree. Omit projectId/modelSelection/modes to inherit those settings from the calling thread; a caller outside a T3 thread must pass projectId and gets the project\'s default model. Set scratch:true instead of projectId for a thread without a project: it runs in a fresh folder of its own, outside any repository. Put the task in message. Do not ask the agent to create its own worktree via shell: that does not update the thread binding. Each call creates a new launch with no retry key; retain threadId and use t3_thread_read/t3_thread_wait to follow preparation. To link a thread for the user, write `[title](t3-thread://v1/)` with the threadId exactly as returned, not URL-encoded; T3 Code shows the thread\'s current title. After errors or lost responses, inspect t3_thread_list before retrying. Attachments must be pending uploads. contextLinks attaches Slack threads, Notion pages, Granola notes, Linear issues, GitHub issues, or repositories to the first message as context chips, as a user would. The new thread may not run with broader runtime or interaction modes than the caller: the calling T3 thread\'s own modes, or the permission mode an outside agent was approved with.', parameters: Schema.Struct({ projectId: Schema.optional(ProjectId), scratch: Schema.optional( diff --git a/apps/server/src/observability/RpcInstrumentation.ts b/apps/server/src/observability/RpcInstrumentation.ts index dafebec51920a..750ce90725e7f 100644 --- a/apps/server/src/observability/RpcInstrumentation.ts +++ b/apps/server/src/observability/RpcInstrumentation.ts @@ -42,6 +42,16 @@ const RPC_AGGREGATES = { [WS_METHODS.notionSubscribeThreadLinks]: "notion", [WS_METHODS.notionLinkThread]: "notion", [WS_METHODS.notionUnlinkThread]: "notion", + [WS_METHODS.granolaSubscribeState]: "granola", + [WS_METHODS.granolaStartLogin]: "granola", + [WS_METHODS.granolaCancelLogin]: "granola", + [WS_METHODS.granolaDisconnect]: "granola", + [WS_METHODS.granolaSearchNotes]: "granola", + [WS_METHODS.granolaGetNote]: "granola", + [WS_METHODS.granolaGetNoteSummary]: "granola", + [WS_METHODS.granolaSubscribeThreadLinks]: "granola", + [WS_METHODS.granolaLinkThread]: "granola", + [WS_METHODS.granolaUnlinkThread]: "granola", [WS_METHODS.slackSubscribeState]: "slack", [WS_METHODS.slackStartLogin]: "slack", [WS_METHODS.slackCompleteLogin]: "slack", diff --git a/apps/server/src/persistence/Sqlite.ts b/apps/server/src/persistence/Sqlite.ts index c78f2aa36ca12..e4dd9e86fdc6b 100644 --- a/apps/server/src/persistence/Sqlite.ts +++ b/apps/server/src/persistence/Sqlite.ts @@ -12,6 +12,7 @@ import { ensureLinearThreadLinksSchema } from "../linear/threadLinksSchema.ts"; import { ensureLinearAssignmentTriggerSchema } from "../linear/assignmentTriggerSchema.ts"; import { ensureGitHubIssueThreadLinksSchema } from "../githubIssues/threadLinksSchema.ts"; import { ensureNotionThreadLinksSchema } from "../notion/threadLinksSchema.ts"; +import { ensureGranolaThreadLinksSchema } from "../granola/threadLinksSchema.ts"; import { ensureSlackThreadLinksSchema } from "../slack/threadLinksSchema.ts"; import * as ServerConfig from "../config.ts"; @@ -36,6 +37,7 @@ const layerSetup = Layer.effectDiscard( yield* ensureGitHubIssueThreadLinksSchema(); yield* ensureSlackThreadLinksSchema(); yield* ensureNotionThreadLinksSchema(); + yield* ensureGranolaThreadLinksSchema(); }), ); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 25f95ad0fe433..44301857355de 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -52,6 +52,9 @@ import * as LinearApi from "./linear/LinearApi.ts"; import * as LinearAssignmentTriggers from "./linear/LinearAssignmentTriggers.ts"; import * as LinearAuth from "./linear/LinearAuth.ts"; import * as LinearThreadLinks from "./linear/LinearThreadLinks.ts"; +import * as GranolaApi from "./granola/GranolaApi.ts"; +import * as GranolaAuth from "./granola/GranolaAuth.ts"; +import * as GranolaThreadLinks from "./granola/GranolaThreadLinks.ts"; import * as NotionApi from "./notion/NotionApi.ts"; import * as NotionAuth from "./notion/NotionAuth.ts"; import * as NotionThreadLinks from "./notion/NotionThreadLinks.ts"; @@ -679,6 +682,12 @@ const layerRuntimeCoreDependenciesBase = Layer.mergeAll( Layer.provideMerge(NotionAuth.layer), ), ), + Layer.provideMerge( + GranolaThreadLinks.layer.pipe( + Layer.provideMerge(GranolaApi.layer), + Layer.provideMerge(GranolaAuth.layer), + ), + ), Layer.provideMerge( SlackThreadLinks.layer.pipe( Layer.provideMerge(SlackApi.layer), diff --git a/apps/server/src/threadTabs/ThreadTabs.test.ts b/apps/server/src/threadTabs/ThreadTabs.test.ts index d65511b7261e9..97b2d4554e578 100644 --- a/apps/server/src/threadTabs/ThreadTabs.test.ts +++ b/apps/server/src/threadTabs/ThreadTabs.test.ts @@ -20,6 +20,7 @@ import * as SqlClient from "effect/sql/SqlClient"; import { GitHubIssueThreadLinks } from "../githubIssues/GitHubIssueThreadLinks.ts"; import { LinearThreadLinks } from "../linear/LinearThreadLinks.ts"; import { NotionThreadLinks } from "../notion/NotionThreadLinks.ts"; +import { GranolaThreadLinks } from "../granola/GranolaThreadLinks.ts"; import { SlackThreadLinks } from "../slack/SlackThreadLinks.ts"; import { OrchestratorDispatchError } from "../orchestration-v2/Orchestrator.ts"; import { @@ -145,6 +146,7 @@ const makeHarness = (input: { Layer.mock(GitHubIssueThreadLinks)({ refresh: Effect.void }), Layer.mock(SlackThreadLinks)({ refresh: Effect.void }), Layer.mock(NotionThreadLinks)({ refresh: Effect.void }), + Layer.mock(GranolaThreadLinks)({ refresh: Effect.void }), NodeCrypto.layer, ), ), diff --git a/apps/server/src/threadTabs/ThreadTabs.ts b/apps/server/src/threadTabs/ThreadTabs.ts index 3c65a0dd9b19d..a39cf005fc37e 100644 --- a/apps/server/src/threadTabs/ThreadTabs.ts +++ b/apps/server/src/threadTabs/ThreadTabs.ts @@ -27,6 +27,7 @@ import { modelSelectionsEqual } from "@t3tools/shared/model"; import { GitHubIssueThreadLinks } from "../githubIssues/GitHubIssueThreadLinks.ts"; import { LinearThreadLinks } from "../linear/LinearThreadLinks.ts"; import { NotionThreadLinks } from "../notion/NotionThreadLinks.ts"; +import { GranolaThreadLinks } from "../granola/GranolaThreadLinks.ts"; import { SlackThreadLinks } from "../slack/SlackThreadLinks.ts"; import { ThreadManagementService } from "../orchestration-v2/ThreadManagementService.ts"; import { THREAD_HISTORY_SNAPSHOT_ROW_LIMIT } from "../orchestration-v2/threadHistoryPaging.ts"; @@ -131,6 +132,7 @@ export const make = Effect.gen(function* () { const githubIssueThreadLinks = yield* GitHubIssueThreadLinks; const slackThreadLinks = yield* SlackThreadLinks; const notionThreadLinks = yield* NotionThreadLinks; + const granolaThreadLinks = yield* GranolaThreadLinks; // Every link kind follows tab-group membership, so each re-reads after the group changes. const refreshLinks = Effect.all( [ @@ -138,6 +140,7 @@ export const make = Effect.gen(function* () { githubIssueThreadLinks.refresh, slackThreadLinks.refresh, notionThreadLinks.refresh, + granolaThreadLinks.refresh, ], { discard: true }, ); diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts index e54f782498b96..f2e35670beb40 100644 --- a/apps/server/src/ws.ts +++ b/apps/server/src/ws.ts @@ -174,6 +174,9 @@ import * as ProviderMaintenanceRunner from "./provider/providerMaintenanceRunner import { LinearApi } from "./linear/LinearApi.ts"; import { LinearAuth } from "./linear/LinearAuth.ts"; import { LinearThreadLinks } from "./linear/LinearThreadLinks.ts"; +import { GranolaApi } from "./granola/GranolaApi.ts"; +import { GranolaAuth } from "./granola/GranolaAuth.ts"; +import { GranolaThreadLinks } from "./granola/GranolaThreadLinks.ts"; import { NotionApi } from "./notion/NotionApi.ts"; import { NotionAuth } from "./notion/NotionAuth.ts"; import { SlackApi } from "./slack/SlackApi.ts"; @@ -1347,6 +1350,9 @@ const layerWsRpc = ( const notionApi = yield* NotionApi; const notionAuth = yield* NotionAuth; const notionThreadLinks = yield* NotionThreadLinks; + const granolaApi = yield* GranolaApi; + const granolaAuth = yield* GranolaAuth; + const granolaThreadLinks = yield* GranolaThreadLinks; const slackThreadLinks = yield* SlackThreadLinks; const githubIssues = yield* GitHubIssues; const githubIssueThreadLinks = yield* GitHubIssueThreadLinks; @@ -2751,6 +2757,17 @@ const layerWsRpc = ( [WS_METHODS.notionLinkThread]: (input) => notionThreadLinks.link(input), [WS_METHODS.notionUnlinkThread]: (input) => notionThreadLinks.unlink(input).pipe(Effect.as({})), + [WS_METHODS.granolaSubscribeState]: (_input) => granolaAuth.state, + [WS_METHODS.granolaStartLogin]: (_input) => granolaAuth.startLogin, + [WS_METHODS.granolaCancelLogin]: (input) => granolaAuth.cancelLogin(input), + [WS_METHODS.granolaDisconnect]: (_input) => granolaAuth.disconnect, + [WS_METHODS.granolaSearchNotes]: (input) => granolaApi.searchNotes(input), + [WS_METHODS.granolaGetNote]: (input) => granolaApi.getNote(input), + [WS_METHODS.granolaGetNoteSummary]: (input) => granolaApi.getNoteSummary(input), + [WS_METHODS.granolaSubscribeThreadLinks]: (_input) => granolaThreadLinks.links, + [WS_METHODS.granolaLinkThread]: (input) => granolaThreadLinks.link(input), + [WS_METHODS.granolaUnlinkThread]: (input) => + granolaThreadLinks.unlink(input).pipe(Effect.as({})), [WS_METHODS.slackSubscribeState]: (_input) => slackAuth.state, [WS_METHODS.slackStartLogin]: (input) => slackAuth.startLogin(input), [WS_METHODS.slackCompleteLogin]: (input) => slackAuth.completeLogin(input), diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx index 206fb73f039ed..8b5b4295577e9 100644 --- a/apps/web/src/components/ChatMarkdown.tsx +++ b/apps/web/src/components/ChatMarkdown.tsx @@ -188,6 +188,7 @@ import { useRightPanelStore } from "../rightPanelStore"; import { readThreadShell, useProjects } from "../state/entities"; import { serverEnvironment } from "../state/server"; import { slackEnvironment } from "../state/slack"; +import { granolaEnvironment } from "../state/granola"; import { useEnvironmentQuery } from "../state/query"; import { shellEnvironment } from "../state/shell"; import { assetEnvironment } from "../state/assets"; @@ -1918,6 +1919,57 @@ function SlackLinkText({ ); } +/** + * A bare Granola note link, named by its meeting's title once the connected account can read it. + * Until then, and whenever Granola is off or disconnected, it reads "Granola note". + */ +function GranolaLinkText({ + environmentId, + host, + url, +}: { + environmentId: EnvironmentId; + host: string; + url: string; +}) { + const link = parseComposerObjectLink(url); + const enabled = useEnvironmentSettings(environmentId, (s) => s.enableGranolaIntegration); + const connection = useEnvironmentQuery( + enabled ? granolaEnvironment.connection({ environmentId, input: {} }) : null, + ); + const note = useEnvironmentQuery( + link?.kind === "granola-note" && enabled && connection.data?.phase === "connected" + ? granolaEnvironment.noteSummary({ environmentId, input: { id: link.noteId } }) + : null, + ).data; + if (!note) { + return ( + + {url} + + ); + } + const date = note.meetingAt === null ? null : new Date(note.meetingAt); + const when = + date === null || Number.isNaN(date.getTime()) + ? null + : date.toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" }); + const detail = [when, note.participants.join(", ") || null].filter(Boolean).join(" · "); + const label = ( + + {url} + + ); + return detail ? ( + + }>{label} + {detail} + + ) : ( + label + ); +} + type HeadingHastNode = { type?: string; tagName?: string; @@ -3170,10 +3222,10 @@ const CHAT_MARKDOWN_COMPONENTS = { // Only a bare link is renamed: link text the writer chose stays as written. const objectLabel = href && !isPullRequestAutolink && linkText === href ? objectLinkLabel(href) : null; - const isBareSlackLink = - href !== undefined && - linkText === href && - parseComposerObjectLink(href)?.kind === "slack-message"; + const bareObjectKind = + href !== undefined && linkText === href ? parseComposerObjectLink(href)?.kind : undefined; + const isBareSlackLink = bareObjectKind === "slack-message"; + const isBareGranolaLink = bareObjectKind === "granola-note"; const confirmBeforeOpen = pullRequestAutolink === "reference"; const pullRequestCandidateUrl = confirmBeforeOpen && href ? pullRequestCandidateUrlFromReferenceAutolink(href) : href; @@ -3334,6 +3386,8 @@ const CHAT_MARKDOWN_COMPONENTS = { > {faviconHost && href && isBareSlackLink && environmentId !== null ? ( + ) : faviconHost && href && isBareGranolaLink && environmentId !== null ? ( + ) : faviconHost && hasText && !isPullRequestAutolink ? ( {linkChildren} diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx index 68c46714a7dac..d6135640ebc52 100644 --- a/apps/web/src/components/CommandPalette.tsx +++ b/apps/web/src/components/CommandPalette.tsx @@ -58,10 +58,12 @@ import { useLocation, useNavigate, useParams } from "@tanstack/react-router"; import { openGitHubIssuePicker } from "./chat/GitHubIssuePicker"; import { useThreadGitHubIssueLink, useUnlinkGitHubIssue } from "./chat/GitHubIssueThreadLink"; import { openNotionPagePicker } from "./chat/NotionPagePicker"; +import { openGranolaNotePicker } from "./chat/GranolaNotePicker"; import { openSlackMessagePicker } from "./chat/SlackMessagePicker"; import { openLinearIssuePicker } from "./chat/LinearIssuePicker"; import { useThreadLinearLink, useUnlinkLinearIssue } from "./chat/LinearThreadLink"; import { useThreadNotionLink, useUnlinkNotionPage } from "./chat/NotionThreadLink"; +import { useThreadGranolaLink, useUnlinkGranolaNote } from "./chat/GranolaThreadLink"; import { useThreadSlackLink, useUnlinkSlackThread } from "./chat/SlackThreadLink"; import { openThreadAttachPicker } from "./chat/ThreadAttachPicker"; import { openPullRequestAttachPicker } from "./chat/PullRequestAttachPicker"; @@ -98,7 +100,7 @@ import { SunIcon, TextSearchIcon, } from "lucide-react"; -import { GitHubIcon, LinearIcon, NotionIcon, SlackIcon } from "./Icons"; +import { GitHubIcon, GranolaIcon, LinearIcon, NotionIcon, SlackIcon } from "./Icons"; import { requestThreadFindOpen } from "./chat/threadFindActionBus"; import { useCallback, @@ -143,6 +145,7 @@ import { filesystemEnvironment, useFilesystemReadAccess } from "../state/filesys import { githubIssueEnvironment } from "../state/githubIssues"; import { linearEnvironment } from "../state/linear"; import { notionEnvironment } from "../state/notion"; +import { granolaEnvironment } from "../state/granola"; import { projectEnvironment } from "../state/projects"; import { slackEnvironment } from "../state/slack"; import { useEnvironmentQuery } from "../state/query"; @@ -748,6 +751,11 @@ function OpenCommandPaletteDialog(props: { const canLinkNotion = useAtomValue( notionEnvironment.linkThread.permissionAtom(activeLinkThreadRef?.environmentId ?? null), ); + const activeGranolaLink = useThreadGranolaLink(activeLinkThreadRef); + const unlinkGranolaNote = useUnlinkGranolaNote(); + const canLinkGranola = useAtomValue( + granolaEnvironment.linkThread.permissionAtom(activeLinkThreadRef?.environmentId ?? null), + ); const activeGitHubIssueLink = useThreadGitHubIssueLink(activeLinkThreadRef); const unlinkGitHubIssue = useUnlinkGitHubIssue(); const canLinkGitHubIssue = useAtomValue( @@ -2181,6 +2189,21 @@ function OpenCommandPaletteDialog(props: { }, }); } + if ( + serverConfigs.get(composerThreadRef.environmentId)?.settings.enableGranolaIntegration !== + false + ) { + actionItems.push({ + kind: "action", + value: "action:attach-granola-note", + searchTerms: ["granola", "meeting", "notes", "transcript", "call", "attach", "context"], + title: "Attach Granola note", + icon: , + run: async () => { + openGranolaNotePicker(composerThreadRef); + }, + }); + } if ( serverConfigs.get(composerThreadRef.environmentId)?.settings.enableSlackIntegration !== false ) { @@ -2324,6 +2347,35 @@ function OpenCommandPaletteDialog(props: { }, }); } + if ( + canLinkGranola && + serverConfigs.get(composerThreadRef.environmentId)?.settings.enableGranolaIntegration === true + ) { + actionItems.push({ + kind: "action", + value: "action:link-granola-note", + searchTerms: ["granola", "meeting", "notes", "link"], + title: activeGranolaLink + ? `Change linked Granola note (${activeGranolaLink.title})` + : "Link Granola note", + icon: , + run: async () => { + openGranolaNotePicker(composerThreadRef, "link"); + }, + }); + } + if (canLinkGranola && activeGranolaLink) { + actionItems.push({ + kind: "action", + value: "action:unlink-granola-note", + searchTerms: ["granola", "meeting", "notes", "unlink", "remove"], + title: `Unlink Granola note ${activeGranolaLink.title}`, + icon: , + run: async () => { + await unlinkGranolaNote(composerThreadRef); + }, + }); + } const composerEnvironment = environments.find( (environment) => environment.environmentId === composerThreadRef.environmentId, ); diff --git a/apps/web/src/components/ContextChip.tsx b/apps/web/src/components/ContextChip.tsx index 0cec022f0ca25..bac6ebd646184 100644 --- a/apps/web/src/components/ContextChip.tsx +++ b/apps/web/src/components/ContextChip.tsx @@ -50,6 +50,7 @@ const contextChipVariants = cva( "github-issue": "[--context-chip-accent:oklch(0.62_0.02_259)]", repository: "[--context-chip-accent:oklch(0.62_0.12_195)]", "notion-page": "[--context-chip-accent:oklch(0.62_0.02_259)]", + "granola-note": "[--context-chip-accent:oklch(0.62_0.14_125)]", "slack-thread": "[--context-chip-accent:oklch(0.62_0.16_345)]", subagent: "[--context-chip-accent:oklch(0.62_0.12_150)]", }, @@ -66,6 +67,7 @@ const contextChipVariants = cva( "github-issue", "repository", "notion-page", + "granola-note", "slack-thread", "pull-request", "pr-open", @@ -98,6 +100,7 @@ const contextChipVariants = cva( "github-issue", "repository", "notion-page", + "granola-note", "slack-thread", "subagent", ], diff --git a/apps/web/src/components/FilterPill.tsx b/apps/web/src/components/FilterPill.tsx new file mode 100644 index 0000000000000..9dc69f4d49eb9 --- /dev/null +++ b/apps/web/src/components/FilterPill.tsx @@ -0,0 +1,22 @@ +import { XIcon } from "lucide-react"; +import type { ReactNode } from "react"; + +/** One applied filter selection, removable with its ×. The sidebar's filter pill, for dialogs. */ +export function FilterPill(props: { icon: ReactNode; label: string; onRemove: () => void }) { + return ( + + + {props.icon} + + {props.label} + + + ); +} diff --git a/apps/web/src/components/LegacySidebar.tsx b/apps/web/src/components/LegacySidebar.tsx index 4ccf0594cd608..1d3c957d503dd 100644 --- a/apps/web/src/components/LegacySidebar.tsx +++ b/apps/web/src/components/LegacySidebar.tsx @@ -238,6 +238,7 @@ import { isGitHubProject } from "@t3tools/client-runtime/state/github-issues"; import { openGitHubIssuePicker } from "./chat/GitHubIssuePicker"; import { openLinearIssuePicker } from "./chat/LinearIssuePicker"; import { openNotionPagePicker } from "./chat/NotionPagePicker"; +import { openGranolaNotePicker } from "./chat/GranolaNotePicker"; import { openSlackMessagePicker } from "./chat/SlackMessagePicker"; const SIDEBAR_SORT_LABELS: Record = { updated_at: "Last user message", @@ -2405,6 +2406,15 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec ...(linkIntegrations.notion ? [{ id: "link-notion-page", label: "Link Notion page…", disabled: !canOperateThread }] : []), + ...(linkIntegrations.granola + ? [ + { + id: "link-granola-note", + label: "Link Granola note…", + disabled: !canOperateThread, + }, + ] + : []), { id: "project-settings", label: "Project settings" }, { id: "delete", @@ -2516,6 +2526,10 @@ const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjec openNotionPagePicker(threadRef, "link"); return; } + if (clicked === "link-granola-note") { + openGranolaNotePicker(threadRef, "link"); + return; + } if (clicked === "link-github-issue") { openGitHubIssuePicker(threadRef, "link"); return; diff --git a/apps/web/src/components/MenuChoiceLabel.tsx b/apps/web/src/components/MenuChoiceLabel.tsx new file mode 100644 index 0000000000000..c91a24628d20d --- /dev/null +++ b/apps/web/src/components/MenuChoiceLabel.tsx @@ -0,0 +1,33 @@ +import { HighlightedSearchText } from "./ui/highlighted-search-text"; + +/** "Only" on the highlighted row: narrow to just that choice. It follows the + * label on the same baseline and keeps its width while hidden, so the + * trailing count stays in one column on every row. */ +function OnlyButton(props: { onClick: () => void }) { + return ( + + ); +} + +/** A multi-select filter row's label, with "Only" beside it on hover. */ +export function MenuChoiceLabel(props: { label: string; query?: string; onOnly: () => void }) { + return ( + + + + + + + ); +} diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsx index c7703749f4230..778a9aae08957 100644 --- a/apps/web/src/components/Sidebar.tsx +++ b/apps/web/src/components/Sidebar.tsx @@ -231,6 +231,7 @@ import { isGitHubProject } from "@t3tools/client-runtime/state/github-issues"; import { openGitHubIssuePicker } from "./chat/GitHubIssuePicker"; import { openLinearIssuePicker } from "./chat/LinearIssuePicker"; import { openNotionPagePicker } from "./chat/NotionPagePicker"; +import { openGranolaNotePicker } from "./chat/GranolaNotePicker"; import { openSlackMessagePicker } from "./chat/SlackMessagePicker"; import { openTranscriptExportDialog } from "./TranscriptExportDialog"; import { StartedByHoverLine } from "./chat/StartedByChip"; @@ -6697,6 +6698,9 @@ export default function Sidebar() { case "link-notion-page": openNotionPagePicker(threadRef, "link"); return; + case "link-granola-note": + openGranolaNotePicker(threadRef, "link"); + return; case "link-github-issue": openGitHubIssuePicker(threadRef, "link"); return; diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx index a3185619e59ba..b5c881fd6424e 100644 --- a/apps/web/src/components/chat/ChatComposer.tsx +++ b/apps/web/src/components/chat/ChatComposer.tsx @@ -291,6 +291,8 @@ import { useComposerGitHubIssueItems } from "./useComposerGitHubIssueItems"; import { useComposerSlackItems } from "./useComposerSlackItems"; import { useAttachNotionPage } from "./NotionPagePicker"; import { useComposerNotionItems } from "./useComposerNotionItems"; +import { useAttachGranolaNote } from "./GranolaNotePicker"; +import { useComposerGranolaItems } from "./useComposerGranolaItems"; import { slackGetThreadInput, useAttachSlackMessage } from "./SlackMessagePicker"; import { useResolveComposerObjectLink } from "./useResolveComposerObjectLink"; import { useComposerRepositoryItems } from "./useComposerRepositoryItems"; @@ -399,6 +401,7 @@ const REFERENCE_MENU_TABS: ReadonlyArray<{ id: ComposerReferenceTab; label: stri { id: "linear-issues", label: "Linear issues" }, { id: "slack-messages", label: "Slack" }, { id: "notion-pages", label: "Notion" }, + { id: "granola-notes", label: "Granola" }, { id: "repositories", label: "Repositories" }, ]; @@ -2832,13 +2835,20 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) REFERENCE_MENU_TABS.flatMap((tab) => (tab.id === "linear-issues" && !referenceSources.linear) || (tab.id === "notion-pages" && !referenceSources.notion) || + (tab.id === "granola-notes" && !referenceSources.granola) || (tab.id === "slack-messages" && !referenceSources.slack) || (tab.id === "github-issues" && githubIssueCwd === null) ? [] : [tab.id], ), ), - [githubIssueCwd, referenceSources.linear, referenceSources.notion, referenceSources.slack], + [ + githubIssueCwd, + referenceSources.granola, + referenceSources.linear, + referenceSources.notion, + referenceSources.slack, + ], ); const referenceMenuTabs = REFERENCE_MENU_TABS.filter((tab) => availableReferenceTabs.has(tab.id)); const referenceTabPickedByHand = @@ -2870,6 +2880,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) active: referenceTab === "notion-pages", query: referenceQuery, }); + const granolaMenu = useComposerGranolaItems(environmentId, { + enabled: availableReferenceTabs.has("granola-notes"), + active: referenceTab === "granola-notes", + query: referenceQuery, + }); const slackMenu = useComposerSlackItems(environmentId, { enabled: availableReferenceTabs.has("slack-messages"), active: referenceTab === "slack-messages", @@ -2896,6 +2911,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) "linear-issues": linearIssueMenu.preloaded, "github-issues": githubIssueMenu.preloaded, "notion-pages": notionMenu.preloaded, + "granola-notes": granolaMenu.preloaded, }, }) : "pull-requests"; @@ -2905,6 +2921,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) } const showLinearIssues = referenceMenuOpen && referenceTab === "linear-issues"; const showNotionPages = referenceMenuOpen && referenceTab === "notion-pages"; + const showGranolaNotes = referenceMenuOpen && referenceTab === "granola-notes"; const showSlackMessages = referenceMenuOpen && referenceTab === "slack-messages"; const showGitHubIssues = referenceMenuOpen && referenceTab === "github-issues"; const showRepositories = referenceMenuOpen && referenceTab === "repositories"; @@ -2914,13 +2931,15 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) ? linearIssueMenu.items : showNotionPages ? notionMenu.items - : showSlackMessages - ? slackMenu.items - : showGitHubIssues - ? githubIssueMenu.items - : showRepositories - ? repositoryMenu.items - : pullRequestMenu.items; + : showGranolaNotes + ? granolaMenu.items + : showSlackMessages + ? slackMenu.items + : showGitHubIssues + ? githubIssueMenu.items + : showRepositories + ? repositoryMenu.items + : pullRequestMenu.items; const referenceTabRecents = useMemo( () => referenceRecents.filter((item) => composerReferenceTabForItem(item) === referenceTab), [referenceRecents, referenceTab], @@ -2939,6 +2958,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) ); const attachLinearIssue = useAttachLinearIssue(); const attachNotionPage = useAttachNotionPage(); + const attachGranolaNote = useAttachGranolaNote(); const attachSlackMessage = useAttachSlackMessage(); const attachGitHubIssue = useAttachGitHubIssue(); const resolveComposerObjectLink = useResolveComposerObjectLink({ @@ -3138,6 +3158,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) (showRepositories && repositoryMenu.isPending) || (showSlackMessages && slackMenu.isPending) || (showNotionPages && notionMenu.isPending) || + (showGranolaNotes && granolaMenu.isPending) || (referenceTab === "pull-requests" && pullRequestMenu.isPending); const composerMenuEmptyState = useMemo(() => { if (composerTriggerKind === "skill") { @@ -3161,6 +3182,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) } if (showNotionPages) return notionMenu.error ?? "No Notion pages found. Try searching by title."; + if (showGranolaNotes) + return ( + granolaMenu.error ?? + "No meetings in the last 30 days match. Paste a note link to attach an older one." + ); if (showSlackMessages) { if (slackMenu.error !== null) return slackMenu.error; return composerTrigger?.query @@ -3205,6 +3231,8 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) showSlackMessages, notionMenu.error, showNotionPages, + granolaMenu.error, + showGranolaNotes, slackMenu.error, pullRequestMenu.available, pullRequestMenu.failed, @@ -4294,6 +4322,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) if (item.type === "linear-issue") void attachLinearIssue(routeThreadRef, item.issueId); if (item.type === "github-issue") void attachGitHubIssue(routeThreadRef, item.url); if (item.type === "notion-page") void attachNotionPage(routeThreadRef, item.pageId); + if (item.type === "granola-note") void attachGranolaNote(routeThreadRef, item.noteId); if (item.type === "slack-message") { void attachSlackMessage(routeThreadRef, slackGetThreadInput(item.message, "thread")); } @@ -4309,6 +4338,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) addComposerDraftReviewComment, applyPromptReplacement, attachGitHubIssue, + attachGranolaNote, attachLinearIssue, attachNotionPage, attachSlackMessage, diff --git a/apps/web/src/components/chat/ChatHeader.tsx b/apps/web/src/components/chat/ChatHeader.tsx index cfa5a35ac8048..9122c7d3199ec 100644 --- a/apps/web/src/components/chat/ChatHeader.tsx +++ b/apps/web/src/components/chat/ChatHeader.tsx @@ -29,6 +29,7 @@ import { Button } from "../ui/button"; import { GitHubIssueThreadLinkChip } from "./GitHubIssueThreadLink"; import { LinearThreadLinkChip } from "./LinearThreadLink"; import { NotionThreadLinkChip } from "./NotionThreadLink"; +import { GranolaThreadLinkChip } from "./GranolaThreadLink"; import { SlackThreadLinkChip } from "./SlackThreadLink"; import { StartedByChip } from "./StartedByChip"; import { ThreadTabMenu } from "./ThreadTabs"; @@ -483,6 +484,7 @@ export const ChatHeader = memo(function ChatHeader({ + {splitPaneFocus !== null ? ( s.enableNotionIntegration, ); + const granolaEnabled = useEnvironmentSettings( + props.threadRef.environmentId, + (s) => s.enableGranolaIntegration, + ); return ( ) : null} + {granolaEnabled ? ( + openGranolaNotePicker(props.threadRef)}> + + Granola note + + ) : null} {slackEnabled ? ( openSlackMessagePicker(props.threadRef)}> diff --git a/apps/web/src/components/chat/ComposerCommandMenu.tsx b/apps/web/src/components/chat/ComposerCommandMenu.tsx index 2ff28d347d024..3ef278c79a266 100644 --- a/apps/web/src/components/chat/ComposerCommandMenu.tsx +++ b/apps/web/src/components/chat/ComposerCommandMenu.tsx @@ -23,7 +23,7 @@ import { UserRoundIcon, type LucideIcon, } from "lucide-react"; -import { GitHubIcon, LinearIcon, NotionIcon, SlackIcon } from "../Icons"; +import { GitHubIcon, GranolaIcon, LinearIcon, NotionIcon, SlackIcon } from "../Icons"; import { memo, useCallback, useLayoutEffect, useRef } from "react"; import type { AgentFleetEntry } from "@t3tools/client-runtime/state/agent-fleet"; @@ -49,6 +49,7 @@ import { formatRelativeTimeLabel } from "~/timestampFormat"; export type ComposerCommandItem = | { id: string; type: "notion-page"; pageId: string; label: string; description: string } + | { id: string; type: "granola-note"; noteId: string; label: string; description: string } | { id: string; type: "path"; @@ -411,6 +412,9 @@ const ComposerCommandMenuItem = memo(function ComposerCommandMenuItem(props: { {props.item.type === "notion-page" ? (