@indigoai-us/hq-cli 5.345.178 → 5.345.179

package/dist/lib/hot-channels/adapters/gmail.js

@@ -0,0 +1,413 @@
+/**
+ * Gmail hot channel (hot-signal-sync US-013), flag-gated.
+ *
+ * A poll adapter over the person's Google connection, routed through the HQ
+ * gateway. It watches INBOX with `users.watch`, renewed daily, and reads new
+ * mail with `history.list` from the stored `historyId`. The token stays in the
+ * gateway; this adapter never sees it.
+ *
+ * The adapter is always registered. It declares `gate.flag`, and the catalog
+ * lists gmail only when that flag is on for the company. With the flag off,
+ * `hq sources sync` reports gmail as `gated` and never calls this adapter.
+ *
+ * Gateway tools: the HQ google provider does not expose these four tools yet.
+ * They are named here as constants, and a follow-up hq-pro story adds them
+ * (all within `gmail.readonly`) before the flag turns on. The argument shapes
+ * are recorded in the project design note US-013-gmail-gateway-tools.md.
+ *
+ * The cursor is a JSON object `{ historyId, watchExpiresAt, watchedAt, pageToken }`:
+ * - `historyId`: Gmail history at or before it was already read.
+ * - `watchExpiresAt` / `watchedAt`: when the INBOX watch expires and when it
+ *   was last renewed. The watch is renewed when it was never set up, when it
+ *   is 24 hours old or older, or when it expires in under 24 hours.
+ * - `pageToken`: the `history.list` page token while a pass is in progress.
+ *   The pass keeps the old `historyId` until its last page, then advances to
+ *   the response's top-level `historyId`.
+ *
+ * A first run seeds `historyId` from the watch response (or `users.getProfile`)
+ * and lands nothing: Gmail history only exists after a known `historyId`.
+ * When Google answers 404 because the stored `historyId` is too old (about a
+ * week), the adapter re-seeds the same way and lands nothing.
+ *
+ * Each landed document is a pointer: subject, from, to, date and thread id
+ * from a metadata-only `messages.get`. The adapter never requests or copies a
+ * message body or snippet. The event key is `gmail:{messageId}:{historyId}`,
+ * with the history record id as the version.
+ *
+ * A revoked or expired token surfaces from the gateway call; run.ts turns it
+ * into a reconnect prompt in the run ledger and the cursor does not move.
+ */
+export const GMAIL_ADAPTER_ID = "gmail";
+export const GMAIL_CHANNEL = "gmail";
+export const GMAIL_PROVIDER = "google";
+export const GMAIL_READONLY_SCOPE = "https://www.googleapis.com/auth/gmail.readonly";
+/** The flag registered in hq-pro `src/flags/keys.ts`. */
+export const GMAIL_FLAG = "hq.hot-channel-gmail";
+export const GMAIL_MESSAGE_ADDED_EVENT = "gmail.message.added";
+export const GMAIL_LABEL_ADDED_EVENT = "gmail.label.added";
+export const GMAIL_WATCH_TOOL = "google.gmail.users.watch";
+export const GMAIL_HISTORY_LIST_TOOL = "google.gmail.history.list";
+export const GMAIL_GET_PROFILE_TOOL = "google.gmail.users.getProfile";
+export const GMAIL_GET_MESSAGE_TOOL = "google.gmail.messages.get";
+export const GMAIL_INBOX_LABEL = "INBOX";
+export const GMAIL_METADATA_HEADERS = ["Subject", "From", "To", "Date"];
+export const GMAIL_CATCH_UP_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+/** Renew the watch at least this often, and when it expires sooner than this. */
+export const GMAIL_WATCH_RENEW_MS = 24 * 60 * 60 * 1000;
+const SUGGESTION_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_PAGE_SIZE = 100;
+const MAX_PAGE_SIZE = 500;
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIsoTime(value) {
+    return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+/** Gmail ids and history ids arrive as decimal strings; accept numbers too. */
+function idOf(value) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+        return String(value);
+    const text = nonEmptyString(value);
+    return text !== undefined && /^[A-Za-z0-9_-]+$/.test(text) ? text : undefined;
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string" && v !== "") : [];
+}
+/** Epoch milliseconds (number or decimal string) as an ISO time. */
+function epochMsToIso(value) {
+    const ms = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : NaN;
+    return Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : null;
+}
+export function parseGmailCursor(cursor) {
+    if (!cursor)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(cursor);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed))
+        return null;
+    const historyId = idOf(parsed.historyId);
+    if (historyId === undefined)
+        return null;
+    return {
+        historyId,
+        watchExpiresAt: isIsoTime(parsed.watchExpiresAt) ? parsed.watchExpiresAt : null,
+        watchedAt: isIsoTime(parsed.watchedAt) ? parsed.watchedAt : null,
+        pageToken: nonEmptyString(parsed.pageToken) ?? null,
+    };
+}
+function serializeCursor(cursor) {
+    return JSON.stringify(cursor);
+}
+/** True when the INBOX watch must be set up or renewed now. */
+export function gmailWatchDue(cursor, now) {
+    if (!cursor?.watchedAt)
+        return true;
+    if (now.getTime() - Date.parse(cursor.watchedAt) >= GMAIL_WATCH_RENEW_MS)
+        return true;
+    if (!cursor.watchExpiresAt)
+        return true;
+    return Date.parse(cursor.watchExpiresAt) - now.getTime() < GMAIL_WATCH_RENEW_MS;
+}
+/** Unwrap a gateway result: a JSON string, an MCP `content[].text` block, or an object. */
+function unwrapResult(result) {
+    if (typeof result === "string") {
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return result;
+        }
+    }
+    if (isRecord(result) && Array.isArray(result.content)) {
+        const text = result.content
+            .map((block) => (isRecord(block) ? nonEmptyString(block.text) : undefined))
+            .find((value) => value !== undefined);
+        if (text !== undefined)
+            return unwrapResult(text);
+    }
+    return result;
+}
+function statusOf(err) {
+    const e = err;
+    if (typeof e?.status === "number")
+        return e.status;
+    return typeof e?.code === "number" ? e.code : undefined;
+}
+/** Google's answer when `startHistoryId` is older than the history it keeps. */
+export function isExpiredHistoryError(err) {
+    if (statusOf(err) === 404)
+        return true;
+    return err instanceof Error && /\b404\b|requested entity was not found/i.test(err.message);
+}
+const AUTH_PATTERN = /HOT_CHANNEL_RECONNECT_REQUIRED|invalid_grant|revoked|reconnect|unauthori[sz]ed|forbidden/i;
+/** Auth failures move nothing; they surface to run.ts as a reconnect. */
+function isAuthFailure(err) {
+    const status = statusOf(err);
+    if (status === 401 || status === 403)
+        return true;
+    const code = err?.code;
+    if (typeof code === "string" && AUTH_PATTERN.test(code))
+        return true;
+    return err instanceof Error && AUTH_PATTERN.test(err.message);
+}
+const RATE_LIMIT_PATTERN = /\b429\b|rateLimitExceeded|userRateLimitExceeded|too many requests/i;
+/** Gmail's 429 / rateLimitExceeded answer. */
+function isRateLimited(err) {
+    if (statusOf(err) === 429)
+        return true;
+    const reason = err?.reason;
+    if (typeof reason === "string" && RATE_LIMIT_PATTERN.test(reason))
+        return true;
+    return err instanceof Error && RATE_LIMIT_PATTERN.test(err.message);
+}
+function parseWatch(result, now) {
+    const body = unwrapResult(result);
+    if (!isRecord(body))
+        throw new Error("Gmail users.watch returned an unexpected response");
+    return {
+        historyId: idOf(body.historyId) ?? null,
+        watchExpiresAt: epochMsToIso(body.expiration),
+        watchedAt: now.toISOString(),
+    };
+}
+function parseProfileHistoryId(result) {
+    const body = unwrapResult(result);
+    const historyId = isRecord(body) ? idOf(body.historyId) : undefined;
+    if (historyId === undefined)
+        throw new Error("Gmail users.getProfile returned no historyId");
+    return historyId;
+}
+function messageOf(value) {
+    if (!isRecord(value) || !isRecord(value.message))
+        return undefined;
+    const messageId = idOf(value.message.id);
+    if (messageId === undefined)
+        return undefined;
+    const threadId = idOf(value.message.threadId);
+    return { messageId, ...(threadId ? { threadId } : {}), labelIds: stringList(value.message.labelIds) };
+}
+/** Parse one `history.list` page into INBOX message and label changes. */
+export function parseGmailHistoryPage(result) {
+    const body = unwrapResult(result);
+    if (!isRecord(body))
+        throw new Error("Gmail history.list returned an unexpected response");
+    const records = body.history === undefined ? [] : body.history;
+    if (!Array.isArray(records))
+        throw new Error("Gmail history.list returned no history list");
+    const changes = [];
+    for (const record of records) {
+        if (!isRecord(record))
+            continue;
+        const historyId = idOf(record.id);
+        if (historyId === undefined)
+            continue;
+        for (const added of Array.isArray(record.messagesAdded) ? record.messagesAdded : []) {
+            const message = messageOf(added);
+            // labelIds may be absent on a messagesAdded item; the INBOX label filter
+            // on the request already scoped it.
+            if (!message || (message.labelIds.length > 0 && !message.labelIds.includes(GMAIL_INBOX_LABEL)))
+                continue;
+            changes.push({ kind: GMAIL_MESSAGE_ADDED_EVENT, historyId, ...message });
+        }
+        for (const added of Array.isArray(record.labelsAdded) ? record.labelsAdded : []) {
+            const message = messageOf(added);
+            if (!message || !isRecord(added) || !stringList(added.labelIds).includes(GMAIL_INBOX_LABEL))
+                continue;
+            changes.push({ kind: GMAIL_LABEL_ADDED_EVENT, historyId, ...message });
+        }
+    }
+    return {
+        changes,
+        nextPageToken: nonEmptyString(body.nextPageToken) ?? null,
+        historyId: idOf(body.historyId) ?? null,
+    };
+}
+/** Headers from a metadata-format `messages.get`. Body, snippet and parts are ignored. */
+export function parseGmailMessageHeaders(result) {
+    const body = unwrapResult(result);
+    if (!isRecord(body))
+        return {};
+    const out = {};
+    const headers = isRecord(body.payload) && Array.isArray(body.payload.headers) ? body.payload.headers : [];
+    for (const header of headers) {
+        if (!isRecord(header))
+            continue;
+        const name = nonEmptyString(header.name)?.toLowerCase();
+        const value = nonEmptyString(header.value);
+        if (!value)
+            continue;
+        if (name === "subject" && out.subject === undefined)
+            out.subject = value;
+        else if (name === "from" && out.from === undefined)
+            out.from = value;
+        else if (name === "to" && out.to === undefined)
+            out.to = value;
+        else if (name === "date" && out.date === undefined)
+            out.date = value;
+    }
+    const internalDate = epochMsToIso(body.internalDate);
+    if (internalDate)
+        out.internalDate = internalDate;
+    return out;
+}
+function receivedAt(headers, now) {
+    if (headers.date && !Number.isNaN(Date.parse(headers.date)))
+        return new Date(headers.date).toISOString();
+    return headers.internalDate ?? now.toISOString();
+}
+function frontmatterFor(pointer, when) {
+    const fm = {
+        message_id: pointer.messageId,
+        history_id: pointer.historyId,
+        received_at: when,
+    };
+    if (pointer.threadId)
+        fm.thread_id = pointer.threadId;
+    if (pointer.headers.subject)
+        fm.subject = pointer.headers.subject;
+    if (pointer.headers.from)
+        fm.from = pointer.headers.from;
+    if (pointer.headers.to)
+        fm.to = pointer.headers.to;
+    if (pointer.labelIds.length > 0)
+        fm.labels = pointer.labelIds.join(", ");
+    return fm;
+}
+function bodyFor(kind, pointer, when) {
+    const action = kind === GMAIL_LABEL_ADDED_EVENT ? "moved to the inbox" : "arrived in the inbox";
+    const lines = [`Gmail message ${pointer.messageId} ${action} ${when}.`];
+    if (pointer.headers.from)
+        lines.push(`From: ${pointer.headers.from}`);
+    if (pointer.headers.to)
+        lines.push(`To: ${pointer.headers.to}`);
+    if (pointer.threadId)
+        lines.push(`Thread: ${pointer.threadId}`);
+    return lines.join("\n");
+}
+function toEvent(change, headers, personUid, now) {
+    const when = receivedAt(headers, now);
+    const pointer = {
+        messageId: change.messageId,
+        ...(change.threadId ? { threadId: change.threadId } : {}),
+        historyId: change.historyId,
+        labelIds: change.labelIds,
+        headers: {
+            ...(headers.subject ? { subject: headers.subject } : {}),
+            ...(headers.from ? { from: headers.from } : {}),
+            ...(headers.to ? { to: headers.to } : {}),
+            ...(headers.date ? { date: headers.date } : {}),
+        },
+    };
+    return {
+        providerId: change.messageId,
+        version: change.historyId,
+        who: headers.from ?? personUid,
+        what: change.kind,
+        where: GMAIL_INBOX_LABEL.toLowerCase(),
+        when,
+        audience: [personUid],
+        title: headers.subject ?? `Gmail message ${change.messageId}`,
+        body: bodyFor(change.kind, pointer, when),
+        raw: pointer,
+        frontmatter: frontmatterFor(pointer, when),
+    };
+}
+export function createGmailAdapter(options = {}) {
+    const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(options.pageSize ?? DEFAULT_PAGE_SIZE)));
+    const clock = options.now ?? (() => new Date());
+    async function fetch(cursor, ctx) {
+        const gateway = ctx.gateway;
+        if (!gateway)
+            throw new Error("Gmail hot channel needs a gateway connection");
+        const now = clock();
+        const state = parseGmailCursor(cursor);
+        let watch = null;
+        if (gmailWatchDue(state, now)) {
+            watch = parseWatch(await gateway.call(GMAIL_WATCH_TOOL, { labelIds: [GMAIL_INBOX_LABEL], labelFilterBehavior: "include" }), now);
+        }
+        const watchFields = {
+            watchExpiresAt: watch ? watch.watchExpiresAt : (state?.watchExpiresAt ?? null),
+            watchedAt: watch ? watch.watchedAt : (state?.watchedAt ?? null),
+        };
+        async function seed() {
+            const historyId = watch?.historyId ?? parseProfileHistoryId(await gateway.call(GMAIL_GET_PROFILE_TOOL, {}));
+            return { events: [], cursor: serializeCursor({ historyId, ...watchFields, pageToken: null }), hasMore: false };
+        }
+        if (state === null)
+            return seed();
+        const args = {
+            startHistoryId: state.historyId,
+            labelId: GMAIL_INBOX_LABEL,
+            historyTypes: ["messageAdded", "labelAdded"],
+            maxResults: pageSize,
+        };
+        if (state.pageToken)
+            args.pageToken = state.pageToken;
+        let page;
+        try {
+            page = parseGmailHistoryPage(await gateway.call(GMAIL_HISTORY_LIST_TOOL, args));
+        }
+        catch (err) {
+            if (!isAuthFailure(err) && isExpiredHistoryError(err))
+                return seed();
+            throw err;
+        }
+        const events = [];
+        const seen = new Set();
+        for (const change of page.changes) {
+            const key = `${change.messageId}:${change.historyId}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            let headers = {};
+            try {
+                headers = parseGmailMessageHeaders(await gateway.call(GMAIL_GET_MESSAGE_TOOL, {
+                    id: change.messageId,
+                    format: "metadata",
+                    metadataHeaders: [...GMAIL_METADATA_HEADERS],
+                }));
+            }
+            catch (err) {
+                // A failed header lookup still lands the pointer; auth failures stop the
+                // run, and a rate limit abandons the page (the cursor stays put) rather
+                // than spending hundreds more calls against an exhausted quota.
+                if (isAuthFailure(err) || isRateLimited(err))
+                    throw err;
+            }
+            events.push(toEvent(change, headers, ctx.personUid, now));
+        }
+        if (page.nextPageToken) {
+            return {
+                events,
+                cursor: serializeCursor({ historyId: state.historyId, ...watchFields, pageToken: page.nextPageToken }),
+                hasMore: true,
+            };
+        }
+        return {
+            events,
+            cursor: serializeCursor({ historyId: page.historyId ?? state.historyId, ...watchFields, pageToken: null }),
+            hasMore: false,
+        };
+    }
+    return {
+        id: GMAIL_ADAPTER_ID,
+        channel: GMAIL_CHANNEL,
+        transport: "poll",
+        hotEventTypes: [GMAIL_MESSAGE_ADDED_EVENT, GMAIL_LABEL_ADDED_EVENT],
+        catchUpWindow: { maxLookbackMs: GMAIL_CATCH_UP_WINDOW_MS },
+        tokenScope: { provider: GMAIL_PROVIDER, scopes: [GMAIL_READONLY_SCOPE] },
+        // Declared as data only. US-014 evaluates it.
+        suggestionRule: { kind: "recent-activity", withinMs: SUGGESTION_WINDOW_MS, minEvents: 2 },
+        gate: { flag: GMAIL_FLAG },
+        fetch,
+    };
+}
+//# sourceMappingURL=gmail.js.map

package/dist/lib/hot-channels/adapters/index.d.ts

@@ -0,0 +1,23 @@
+import { type HotChannelRegistry } from "../registry.js";
+export * from "./attio.js";
+export * from "./gmail.js";
+export * from "./linear.js";
+export * from "./meetings.js";
+export * from "./slack.js";
+export interface BuiltinHotChannelOptions {
+    /** Company vault root (`companies/{company}`). */
+    vaultRoot: string;
+    /** The signed-in person's identities besides the run's `personUid` (`prs_` uid, email). */
+    identities?: readonly string[];
+    /** The person's Slack account ids (`slk_...`), when known. */
+    slackAccountIds?: readonly string[];
+}
+/**
+ * Register the adapters HQ ships with: meetings, slack and attio (all read the
+ * vault), linear (gateway poll) and gmail (gateway poll, gated on the
+ * `hq.hot-channel-gmail` flag). Attio also uses the gateway to scope events
+ * to the person.
+ */
+export declare function registerBuiltinHotChannels(registry: HotChannelRegistry, options: BuiltinHotChannelOptions): HotChannelRegistry;
+export declare function createBuiltinHotChannelRegistry(options: BuiltinHotChannelOptions): HotChannelRegistry;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/hot-channels/adapters/index.js

@@ -0,0 +1,39 @@
+import { createHotChannelRegistry } from "../registry.js";
+import { createAttioAdapter } from "./attio.js";
+import { createGmailAdapter } from "./gmail.js";
+import { createLinearAdapter } from "./linear.js";
+import { createMeetingsAdapter } from "./meetings.js";
+import { createSlackAdapter } from "./slack.js";
+export * from "./attio.js";
+export * from "./gmail.js";
+export * from "./linear.js";
+export * from "./meetings.js";
+export * from "./slack.js";
+/**
+ * Register the adapters HQ ships with: meetings, slack and attio (all read the
+ * vault), linear (gateway poll) and gmail (gateway poll, gated on the
+ * `hq.hot-channel-gmail` flag). Attio also uses the gateway to scope events
+ * to the person.
+ */
+export function registerBuiltinHotChannels(registry, options) {
+    registry.register(createMeetingsAdapter({
+        vaultRoot: options.vaultRoot,
+        ...(options.identities ? { identities: options.identities } : {}),
+    }));
+    registry.register(createSlackAdapter({
+        vaultRoot: options.vaultRoot,
+        ...(options.identities ? { identities: options.identities } : {}),
+        ...(options.slackAccountIds ? { accountIds: options.slackAccountIds } : {}),
+    }));
+    registry.register(createLinearAdapter());
+    registry.register(createAttioAdapter({
+        vaultRoot: options.vaultRoot,
+        ...(options.identities ? { identities: options.identities } : {}),
+    }));
+    registry.register(createGmailAdapter());
+    return registry;
+}
+export function createBuiltinHotChannelRegistry(options) {
+    return registerBuiltinHotChannels(createHotChannelRegistry(), options);
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/hot-channels/adapters/linear.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Linear hot channel (hot-signal-sync US-007).
+ *
+ * A poll adapter over the gateway's `list_issues` tool on the person's own
+ * Linear connection. It replaces the hq-pro Linear cron's watermark logic:
+ * list the issues assigned to the person whose `updatedAt` is after the
+ * watermark, ordered by `updatedAt`, and page through them with the gateway's
+ * cursor. The token stays in the gateway; this adapter never sees it.
+ *
+ * Budget: Linear allows 2,500 API requests per hour per personal token. One
+ * fetch is one request, and the loop stops after 20 pages per adapter per run,
+ * so a run spends at most 20 requests (2,000 issues at 100 per page). Comments
+ * are not fetched per issue; doing that is what blew the cron's budget.
+ *
+ * The cursor is a JSON object `{ watermark, after, high }`:
+ * - `watermark`: issues with `updatedAt` at or before it were already seen.
+ *   On a first run it is the catch-up `since`, and every pass starts from
+ *   `max(watermark, since)` so a long absence never pages through issues the
+ *   loop would drop as stale.
+ * - `after`: the gateway cursor of the next page while a pass is in progress.
+ * - `high`: the newest `updatedAt` seen so far in the pass.
+ * The watermark advances to `high` only when a pass completes (no next page).
+ * A run cut short by the page cap resumes the same pass on the next run with
+ * the old watermark, so an issue on a later page is never skipped. A cursor
+ * that does not parse falls back to `since`.
+ *
+ * Each landed document is a pointer in the hq-pro Linear source shape: the
+ * frontmatter carries the issue's identifier, state, priority, assignee,
+ * team, labels and url, the body is a short header with no description, and
+ * the `.raw.json` sidecar (named by `payload_ref`) holds the issue metadata.
+ * The event key is `linear:{issueId}:{updatedAt}`, so each update of an issue
+ * lands once.
+ *
+ * A revoked or expired token (`invalid_grant`) surfaces from the gateway call;
+ * run.ts turns it into a reconnect prompt in the run ledger and the cursor
+ * does not move.
+ */
+import { type PollHotChannelAdapter } from "../contract.js";
+export declare const LINEAR_ADAPTER_ID = "linear";
+export declare const LINEAR_CHANNEL = "linear";
+export declare const LINEAR_PROVIDER = "linear";
+export declare const LINEAR_ISSUE_UPDATED_EVENT = "linear.issue.updated";
+export declare const LINEAR_LIST_ISSUES_TOOL = "list_issues";
+/** Linear's request budget for one personal token. */
+export declare const LINEAR_REQUESTS_PER_HOUR = 2500;
+export declare const LINEAR_CATCH_UP_WINDOW_MS: number;
+export declare const LINEAR_ISSUE_FIELDS: readonly ["id", "uuid", "title", "priority", "url", "createdAt", "updatedAt", "completedAt", "dueDate", "status", "statusType", "labels", "assignee", "project", "team"];
+export interface LinearAdapterOptions {
+    /** Issues per `list_issues` call. Clamped to 1..250. Default 100. */
+    pageSize?: number;
+}
+/** The adapter's cursor: see the file comment. */
+export interface LinearCursor {
+    watermark: string;
+    after: string | null;
+    high: string | null;
+}
+export interface LinearIssue {
+    uuid: string;
+    identifier: string;
+    title: string;
+    updatedAt: string;
+    createdAt?: string;
+    completedAt?: string;
+    dueDate?: string;
+    url?: string;
+    priority?: number;
+    state?: string;
+    stateType?: string;
+    assignee?: string;
+    team?: string;
+    project?: string;
+    labels: string[];
+}
+export declare function parseLinearCursor(cursor: string | null, since: string): LinearCursor;
+/** Normalize one `list_issues` item. Returns undefined when it has no id or `updatedAt`. */
+export declare function toLinearIssue(item: unknown): LinearIssue | undefined;
+export declare function createLinearAdapter(options?: LinearAdapterOptions): PollHotChannelAdapter;
+//# sourceMappingURL=linear.d.ts.map