@hotmeshio/long-tail 0.1.0

package/build/services/mcp-runs/execution-builder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExecution = buildExecution;
+const db_1 = require("../db");
+const hotmesh_utils_1 = require("../hotmesh-utils");
+const enrichment_1 = require("./enrichment");
+const events_1 = require("./events");
+/**
+ * Build a complete execution export for a YAML engine workflow job.
+ *
+ * Pipeline:
+ *   1. Load job record and inflate symbolic attributes
+ *   2. Extract metadata and activity hierarchy
+ *   3. Enrich activities with input data from stream history
+ *   4. Construct chronological event timeline
+ *   5. Assemble final export with summary statistics
+ */
+async function buildExecution(jobId, appId, schema) {
+    // 1. Load and inflate
+    const ctx = await loadJobContext(jobId, appId, schema);
+    // 2. Enrich activity inputs
+    const inputByNameDim = await (0, enrichment_1.fetchActivityInputs)(jobId, appId);
+    // 3. Build event timeline
+    const events = (0, events_1.buildEvents)(ctx, inputByNameDim);
+    // 4. Fetch structured activity details (for cycle/dimension visualization)
+    const activities = inputByNameDim.size > 0
+        ? await (0, enrichment_1.fetchActivityDetails)(jobId, appId)
+        : undefined;
+    // 5. Assemble export
+    return assembleExport(ctx, events, activities);
+}
+// ── Job loading ──────────────────────────────────────────────────────────────
+async function loadJobContext(jobId, appId, schema) {
+    const jobKey = `hmsh:${appId}:j:${jobId}`;
+    const pool = (0, db_1.getPool)();
+    const [jobResult, symbolMap] = await Promise.all([
+        pool.query(`SELECT id, key, entity, status, created_at, updated_at, expired_at, is_live
+       FROM ${schema}.jobs WHERE key = $1 LIMIT 1`, [jobKey]),
+        (0, hotmesh_utils_1.loadSymbolMap)(schema, appId),
+    ]);
+    if (jobResult.rows.length === 0) {
+        const err = new Error(`No job found for id "${jobId}" in schema "${appId}"`);
+        err.status = 404;
+        throw err;
+    }
+    const job = jobResult.rows[0];
+    const attrRows = await pool.query(`SELECT field, value FROM ${schema}.jobs_attributes WHERE job_id = $1 ORDER BY field`, [job.id]);
+    const rawAttrs = {};
+    for (const row of attrRows.rows)
+        rawAttrs[row.field] = row.value;
+    const hierarchy = (0, hotmesh_utils_1.restoreHierarchy)((0, hotmesh_utils_1.inflateAttributes)(rawAttrs, symbolMap));
+    const meta = hierarchy['metadata'];
+    return {
+        jobId,
+        appId,
+        job,
+        startTime: meta?.['jc'] ? (0, hotmesh_utils_1.hmshTimestampToISO)(meta['jc']) : job.created_at?.toISOString(),
+        closeTime: meta?.['ju'] ? (0, hotmesh_utils_1.hmshTimestampToISO)(meta['ju']) : job.updated_at?.toISOString(),
+        traceId: meta?.['trc'] || null,
+        workflowTopic: meta?.['tpc'] || job.entity || null,
+        workflowName: meta?.['aid'] || meta?.['tpc'] || job.entity || null,
+        workflowResult: hierarchy['data'] || null,
+        metadata: meta,
+        activities: (0, hotmesh_utils_1.extractActivities)(hierarchy),
+    };
+}
+// ── Assembly ─────────────────────────────────────────────────────────────────
+function assembleExport(ctx, events, activities) {
+    const triggerCount = ctx.activities.filter((a) => a.type === 'trigger').length;
+    const workerCount = ctx.activities.filter((a) => a.type !== 'trigger').length;
+    const completed = events.filter((e) => e.event_type === 'activity_task_completed').length;
+    const failed = events.filter((e) => e.event_type === 'activity_task_failed').length;
+    let durationMs = null;
+    if (ctx.startTime && ctx.closeTime) {
+        const diff = new Date(ctx.closeTime).getTime() - new Date(ctx.startTime).getTime();
+        if (diff >= 0)
+            durationMs = diff;
+    }
+    return {
+        workflow_id: ctx.jobId,
+        workflow_type: ctx.workflowTopic,
+        workflow_name: ctx.workflowName,
+        task_queue: ctx.appId,
+        status: ctx.job.status > 0 ? 'running' : ctx.job.status === 0 ? 'completed' : 'failed',
+        start_time: ctx.startTime || null,
+        close_time: ctx.closeTime || null,
+        duration_ms: durationMs,
+        trace_id: ctx.traceId,
+        result: ctx.workflowResult,
+        events,
+        activities,
+        summary: {
+            total_events: events.length,
+            activities: { total: ctx.activities.length, completed, failed, system: triggerCount, user: workerCount },
+            child_workflows: { total: 0, completed: 0, failed: 0 },
+            timers: 0,
+            signals: 0,
+        },
+    };
+}

package/build/services/mcp-runs/index.d.ts

@@ -0,0 +1,4 @@
+export { buildExecution } from './execution-builder';
+export { listEntities, listJobs } from './queries';
+export type { ListJobsParams } from './queries';
+export type { ExecutionExport, ExecutionEvent, ActivityDetail, JobContext } from './types';

package/build/services/mcp-runs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listJobs = exports.listEntities = exports.buildExecution = void 0;
+var execution_builder_1 = require("./execution-builder");
+Object.defineProperty(exports, "buildExecution", { enumerable: true, get: function () { return execution_builder_1.buildExecution; } });
+var queries_1 = require("./queries");
+Object.defineProperty(exports, "listEntities", { enumerable: true, get: function () { return queries_1.listEntities; } });
+Object.defineProperty(exports, "listJobs", { enumerable: true, get: function () { return queries_1.listJobs; } });

package/build/services/mcp-runs/queries.d.ts

@@ -0,0 +1,28 @@
+export interface ListJobsParams {
+    rawAppId: string;
+    limit?: number;
+    offset?: number;
+    entity?: string;
+    search?: string;
+    status?: string;
+}
+interface JobRow {
+    workflow_id: string;
+    entity: string;
+    status: string;
+    is_live: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Return distinct entity names from job runs + yaml workflow graph_topics.
+ */
+export declare function listEntities(rawAppId: string): Promise<string[]>;
+/**
+ * List jobs with filtering, pagination, and status mapping.
+ */
+export declare function listJobs(params: ListJobsParams): Promise<{
+    jobs: JobRow[];
+    total: number;
+}>;
+export {};

package/build/services/mcp-runs/queries.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEntities = listEntities;
+exports.listJobs = listJobs;
+const db_1 = require("../db");
+const hotmesh_utils_1 = require("../hotmesh-utils");
+const sql_1 = require("./sql");
+/**
+ * Return distinct entity names from job runs + yaml workflow graph_topics.
+ */
+async function listEntities(rawAppId) {
+    const appId = (0, hotmesh_utils_1.sanitizeAppId)(rawAppId);
+    const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
+    const pool = (0, db_1.getPool)();
+    const [jobResult, yamlResult] = await Promise.all([
+        pool.query((0, sql_1.DISTINCT_ENTITIES)(schema)).catch(() => ({ rows: [] })),
+        pool.query(sql_1.ACTIVE_GRAPH_TOPICS, [rawAppId]).catch(() => ({ rows: [] })),
+    ]);
+    const entitySet = new Set();
+    for (const r of jobResult.rows)
+        entitySet.add(r.entity);
+    for (const r of yamlResult.rows)
+        entitySet.add(r.graph_topic);
+    return [...entitySet].sort();
+}
+/**
+ * List jobs with filtering, pagination, and status mapping.
+ */
+async function listJobs(params) {
+    const { rawAppId } = params;
+    const appId = (0, hotmesh_utils_1.sanitizeAppId)(rawAppId);
+    const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
+    const limit = Math.min(params.limit ?? 20, 100);
+    const offset = params.offset ?? 0;
+    const pool = (0, db_1.getPool)();
+    const conditions = [];
+    const values = [];
+    let idx = 1;
+    if (params.entity) {
+        conditions.push(`j.entity = $${idx++}`);
+        values.push(params.entity);
+    }
+    if (params.search) {
+        conditions.push(`j.key ILIKE $${idx++}`);
+        values.push(`%${params.search}%`);
+    }
+    if (params.status === 'running') {
+        conditions.push('j.status > 0');
+    }
+    else if (params.status === 'completed') {
+        conditions.push('j.status = 0');
+    }
+    else if (params.status === 'failed') {
+        conditions.push('j.status < 0');
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const keyPrefix = `hmsh:${appId}:j:`;
+    const [countResult, dataResult] = await Promise.all([
+        pool.query((0, sql_1.COUNT_JOBS)(schema, where), values),
+        pool.query((0, sql_1.LIST_JOBS)(schema, where, idx++, idx++), [...values, limit, offset]),
+    ]);
+    const jobs = dataResult.rows.map((row) => ({
+        workflow_id: row.key.startsWith(keyPrefix) ? row.key.slice(keyPrefix.length) : row.key,
+        entity: row.entity,
+        status: row.status > 0 ? 'running' : row.status === 0 ? 'completed' : 'failed',
+        is_live: row.is_live,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    }));
+    return { jobs, total: parseInt(countResult.rows[0].count, 10) };
+}

package/build/services/mcp-runs/sql.d.ts

@@ -0,0 +1,4 @@
+export declare const DISTINCT_ENTITIES: (schema: string) => string;
+export declare const ACTIVE_GRAPH_TOPICS = "SELECT DISTINCT graph_topic FROM lt_yaml_workflows WHERE app_id = $1 AND status IN ('active', 'deployed')";
+export declare const COUNT_JOBS: (schema: string, where: string) => string;
+export declare const LIST_JOBS: (schema: string, where: string, limitIdx: number, offsetIdx: number) => string;

package/build/services/mcp-runs/sql.js

@@ -0,0 +1,17 @@
+"use strict";
+// SQL templates for mcp-runs queries.
+// Schema placeholders (${schema}) are interpolated at call time
+// because Postgres does not support parameterized schema names.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_JOBS = exports.COUNT_JOBS = exports.ACTIVE_GRAPH_TOPICS = exports.DISTINCT_ENTITIES = void 0;
+const DISTINCT_ENTITIES = (schema) => `SELECT DISTINCT entity FROM ${schema}.jobs WHERE entity IS NOT NULL AND entity != '' ORDER BY entity`;
+exports.DISTINCT_ENTITIES = DISTINCT_ENTITIES;
+exports.ACTIVE_GRAPH_TOPICS = `SELECT DISTINCT graph_topic FROM lt_yaml_workflows WHERE app_id = $1 AND status IN ('active', 'deployed')`;
+const COUNT_JOBS = (schema, where) => `SELECT COUNT(*) FROM ${schema}.jobs j ${where}`;
+exports.COUNT_JOBS = COUNT_JOBS;
+const LIST_JOBS = (schema, where, limitIdx, offsetIdx) => `SELECT j.key, j.entity, j.status, j.is_live, j.created_at, j.updated_at
+   FROM ${schema}.jobs j
+   ${where}
+   ORDER BY (CASE WHEN j.status > 0 THEN 0 ELSE 1 END), j.created_at DESC
+   LIMIT $${limitIdx} OFFSET $${offsetIdx}`;
+exports.LIST_JOBS = LIST_JOBS;

package/build/services/mcp-runs/types.d.ts

@@ -0,0 +1,65 @@
+export interface ExecutionEvent {
+    event_id: number;
+    event_type: string;
+    category: string;
+    event_time: string;
+    duration_ms: number | null;
+    is_system: boolean;
+    attributes: Record<string, unknown>;
+}
+export interface ActivityDetail {
+    name: string;
+    type: string;
+    dimension: string;
+    input?: Record<string, any>;
+    output?: Record<string, any>;
+    started_at?: string;
+    completed_at?: string;
+    duration_ms?: number;
+    cycle_iteration?: number;
+    error?: string | null;
+}
+export interface JobContext {
+    jobId: string;
+    appId: string;
+    job: any;
+    startTime: string | undefined;
+    closeTime: string | undefined;
+    traceId: string | null;
+    workflowTopic: string | null;
+    workflowName: string | null;
+    workflowResult: unknown;
+    metadata: Record<string, unknown> | undefined;
+    activities: any[];
+}
+export interface ExecutionExport {
+    workflow_id: string;
+    workflow_type: string | null;
+    workflow_name: string | null;
+    task_queue: string;
+    status: string;
+    start_time: string | null;
+    close_time: string | null;
+    duration_ms: number | null;
+    trace_id: string | null;
+    result: unknown;
+    events: ExecutionEvent[];
+    activities?: ActivityDetail[];
+    summary: {
+        total_events: number;
+        activities: {
+            total: number;
+            completed: number;
+            failed: number;
+            system: number;
+            user: number;
+        };
+        child_workflows: {
+            total: number;
+            completed: number;
+            failed: number;
+        };
+        timers: number;
+        signals: number;
+    };
+}

package/build/services/mcp-runs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/services/namespace/index.d.ts

@@ -0,0 +1,17 @@
+import type { LTNamespace } from './types';
+/**
+ * List all registered namespaces, ordered by default-first then name.
+ */
+export declare function listNamespaces(): Promise<LTNamespace[]>;
+/**
+ * Get the default namespace.
+ */
+export declare function getDefaultNamespace(): Promise<LTNamespace | null>;
+/**
+ * Get a namespace by name.
+ */
+export declare function getNamespace(name: string): Promise<LTNamespace | null>;
+/**
+ * Register (upsert) a namespace. Used by YAML deployer to auto-register.
+ */
+export declare function registerNamespace(name: string, description?: string, metadata?: Record<string, unknown>): Promise<LTNamespace>;

package/build/services/namespace/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listNamespaces = listNamespaces;
+exports.getDefaultNamespace = getDefaultNamespace;
+exports.getNamespace = getNamespace;
+exports.registerNamespace = registerNamespace;
+const db_1 = require("../db");
+const sql_1 = require("./sql");
+/**
+ * List all registered namespaces, ordered by default-first then name.
+ */
+async function listNamespaces() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.LIST_NAMESPACES);
+    return rows;
+}
+/**
+ * Get the default namespace.
+ */
+async function getDefaultNamespace() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_DEFAULT_NAMESPACE);
+    return rows[0] ?? null;
+}
+/**
+ * Get a namespace by name.
+ */
+async function getNamespace(name) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_NAMESPACE_BY_NAME, [name]);
+    return rows[0] ?? null;
+}
+/**
+ * Register (upsert) a namespace. Used by YAML deployer to auto-register.
+ */
+async function registerNamespace(name, description, metadata) {
+    const pool = (0, db_1.getPool)();
+    const schemaName = name; // HotMesh appId === Postgres schema name
+    const { rows } = await pool.query(sql_1.UPSERT_NAMESPACE, [name, schemaName, description ?? null, metadata ? JSON.stringify(metadata) : null]);
+    return rows[0];
+}

package/build/services/namespace/sql.d.ts

@@ -0,0 +1,4 @@
+export declare const LIST_NAMESPACES = "\n  SELECT * FROM lt_namespaces\n  ORDER BY is_default DESC, name ASC";
+export declare const GET_DEFAULT_NAMESPACE = "\n  SELECT * FROM lt_namespaces\n  WHERE is_default = true\n  LIMIT 1";
+export declare const GET_NAMESPACE_BY_NAME = "\n  SELECT * FROM lt_namespaces\n  WHERE name = $1\n  LIMIT 1";
+export declare const UPSERT_NAMESPACE = "\n  INSERT INTO lt_namespaces (name, schema_name, description, metadata)\n  VALUES ($1, $2, $3, $4)\n  ON CONFLICT (name) DO UPDATE SET\n    description = COALESCE(EXCLUDED.description, lt_namespaces.description),\n    metadata = COALESCE(EXCLUDED.metadata, lt_namespaces.metadata),\n    updated_at = NOW()\n  RETURNING *";

package/build/services/namespace/sql.js

@@ -0,0 +1,23 @@
+"use strict";
+// ─── Namespace queries ──────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPSERT_NAMESPACE = exports.GET_NAMESPACE_BY_NAME = exports.GET_DEFAULT_NAMESPACE = exports.LIST_NAMESPACES = void 0;
+exports.LIST_NAMESPACES = `
+  SELECT * FROM lt_namespaces
+  ORDER BY is_default DESC, name ASC`;
+exports.GET_DEFAULT_NAMESPACE = `
+  SELECT * FROM lt_namespaces
+  WHERE is_default = true
+  LIMIT 1`;
+exports.GET_NAMESPACE_BY_NAME = `
+  SELECT * FROM lt_namespaces
+  WHERE name = $1
+  LIMIT 1`;
+exports.UPSERT_NAMESPACE = `
+  INSERT INTO lt_namespaces (name, schema_name, description, metadata)
+  VALUES ($1, $2, $3, $4)
+  ON CONFLICT (name) DO UPDATE SET
+    description = COALESCE(EXCLUDED.description, lt_namespaces.description),
+    metadata = COALESCE(EXCLUDED.metadata, lt_namespaces.metadata),
+    updated_at = NOW()
+  RETURNING *`;

package/build/services/namespace/types.d.ts

@@ -0,0 +1,11 @@
+/** Type definitions for the namespace service. */
+export interface LTNamespace {
+    id: string;
+    name: string;
+    description: string | null;
+    schema_name: string;
+    is_default: boolean;
+    metadata: Record<string, unknown> | null;
+    created_at: string;
+    updated_at: string;
+}

package/build/services/namespace/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Type definitions for the namespace service. */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/services/oauth/crypto.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Set the encryption key for OAuth token storage.
+ * Called during OAuth initialization from start.ts.
+ */
+export declare function setEncryptionKey(keyHex: string): void;
+/**
+ * Get the encryption key. Reads from explicit config first,
+ * then falls back to OAUTH_ENCRYPTION_KEY env var.
+ */
+export declare function getEncryptionKey(): Buffer;
+/**
+ * Encrypt a plaintext string with AES-256-GCM.
+ * Returns base64-encoded string: iv:ciphertext:tag
+ */
+export declare function encrypt(plaintext: string): string;
+/**
+ * Decrypt a base64-encoded AES-256-GCM ciphertext.
+ */
+export declare function decrypt(encoded: string): string;

package/build/services/oauth/crypto.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEncryptionKey = setEncryptionKey;
+exports.getEncryptionKey = getEncryptionKey;
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto = __importStar(require("crypto"));
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 12;
+const TAG_LENGTH = 16;
+let _encryptionKey = null;
+/**
+ * Set the encryption key for OAuth token storage.
+ * Called during OAuth initialization from start.ts.
+ */
+function setEncryptionKey(keyHex) {
+    const buf = Buffer.from(keyHex, 'hex');
+    if (buf.length !== 32) {
+        throw new Error(`OAUTH_ENCRYPTION_KEY must be 32 bytes (64 hex chars), got ${buf.length}`);
+    }
+    _encryptionKey = buf;
+}
+/**
+ * Get the encryption key. Reads from explicit config first,
+ * then falls back to OAUTH_ENCRYPTION_KEY env var.
+ */
+function getEncryptionKey() {
+    if (_encryptionKey)
+        return _encryptionKey;
+    const envKey = process.env.OAUTH_ENCRYPTION_KEY;
+    if (envKey) {
+        setEncryptionKey(envKey);
+        return _encryptionKey;
+    }
+    throw new Error('OAuth encryption key not configured. Set OAUTH_ENCRYPTION_KEY or pass auth.oauth.encryptionKey in startup config.');
+}
+/**
+ * Encrypt a plaintext string with AES-256-GCM.
+ * Returns base64-encoded string: iv:ciphertext:tag
+ */
+function encrypt(plaintext) {
+    const key = getEncryptionKey();
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // Pack as: iv + ciphertext + tag, then base64
+    return Buffer.concat([iv, encrypted, tag]).toString('base64');
+}
+/**
+ * Decrypt a base64-encoded AES-256-GCM ciphertext.
+ */
+function decrypt(encoded) {
+    const key = getEncryptionKey();
+    const buf = Buffer.from(encoded, 'base64');
+    const iv = buf.subarray(0, IV_LENGTH);
+    const tag = buf.subarray(buf.length - TAG_LENGTH);
+    const ciphertext = buf.subarray(IV_LENGTH, buf.length - TAG_LENGTH);
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    return decipher.update(ciphertext) + decipher.final('utf8');
+}

package/build/services/oauth/db.d.ts

@@ -0,0 +1,20 @@
+import { type OAuthTokens } from './providers';
+import type { LTDecryptedToken } from '../../types/oauth';
+import type { LTUserRecord } from '../../types/user';
+export declare function upsertOAuthToken(userId: string, provider: string, tokens: OAuthTokens, scopes: string[], providerUserId: string, providerEmail: string | null, metadata?: Record<string, any>, label?: string): Promise<string>;
+export declare function getOAuthToken(userId: string, provider: string, label?: string): Promise<LTDecryptedToken | null>;
+/**
+ * Get a fresh access token, refreshing if expired.
+ * Returns the access token string ready for use in API calls.
+ */
+export declare function getFreshAccessToken(userId: string, provider: string, label?: string): Promise<LTDecryptedToken>;
+export declare function listOAuthConnections(userId: string): Promise<Array<{
+    provider: string;
+    label: string;
+    email: string | null;
+    scopes: string[];
+    expires_at: string | null;
+    credential_type: string | null;
+}>>;
+export declare function deleteOAuthConnection(userId: string, provider: string, label?: string): Promise<boolean>;
+export declare function getUserByOAuthProvider(provider: string, providerUserId: string): Promise<LTUserRecord | null>;