@hotmeshio/long-tail 0.1.6 → 0.1.8

package/README.md

@@ -177,41 +177,83 @@ const lt = await start({
 });
 ```
 
+## Use as a Package (No HTTP Server)
+
+Long Tail can run as an embedded package inside your existing application — no Express server, no socket.io, no extra ports. The same API surface is available as direct function calls.
+
+```typescript
+import { start, createClient } from '@hotmeshio/long-tail';
+
+await start({
+  database: { connectionString: process.env.DATABASE_URL },
+  server: { enabled: false },
+  workers: [{ taskQueue: 'default', workflow: reviewContent.reviewContent }],
+});
+
+const lt = createClient({ auth: { userId: 'system' } });
+
+// Same operations as the REST API — no HTTP overhead
+const tasks = await lt.tasks.list({ status: 'completed', limit: 10 });
+const result = await lt.escalations.claim({ id: 'esc_123', durationMinutes: 30 });
+```
+
+Subscribe to events with callbacks instead of socket.io:
+
+```typescript
+lt.events.on('task.completed', (event) => {
+  console.log('done:', event.workflowId);
+});
+
+lt.events.on('escalation.*', (event) => {
+  notifyTeam(event);
+});
+```
+
+Every SDK call returns an `LTApiResult` — same status codes, same validation, same RBAC. The transport is the only thing that changes. See the [SDK guide](docs/sdk.md) for the full API reference.
+
 ## Deployment
 
-Two container types from the same codebase:
+Three modes from the same codebase:
 
 ```typescript
-// api.ts — dashboard + REST API
+// 1. Standalone — dashboard + REST API + workers
 await start({ database: { connectionString: process.env.DATABASE_URL } });
 
-// worker.ts — workflow execution, no HTTP server
+// 2. Worker-only — workflow execution, no HTTP server
 await start({
   database: { connectionString: process.env.DATABASE_URL },
   server: { enabled: false },
   workers: [{ taskQueue: 'default', workflow: reviewContent.reviewContent }],
 });
+
+// 3. Embedded — inside your NestJS/Next.js/Express app, SDK calls only
+await start({ database: { connectionString: process.env.DATABASE_URL }, server: { enabled: false } });
+const lt = createClient({ auth: { userId: 'service' } });
 ```
 
-Both share PostgreSQL and scale independently. See [Cloud Deployment](docs/cloud.md).
+All modes share PostgreSQL and scale independently. See [Cloud Deployment](docs/cloud.md).
 
 ## Docs
 
 | Guide | What it covers |
 |-------|---------------|
+| [The Long Tail Story](docs/story.md) | Why this exists, what accumulates over time, what you own |
 | [Workflows](docs/workflows.md) | Activities, interceptor, escalation lifecycle, composition |
 | [IAM](docs/iam.md) | Identity propagation, service accounts, credential exchange |
 | [Dashboard](docs/dashboard.md) | Navigation, key pages, event feed |
 | [MCP](docs/mcp.md) | Server registration, tool calls, human queue |
 | [Compilation](docs/compilation.md) | Dynamic → deterministic pipeline wizard |
 | [Escalation Strategies](docs/escalation-strategies.md) | Default, MCP triage, custom handlers |
+| [SDK](docs/sdk.md) | Embedded usage, `createClient`, event subscriptions |
 | [Architecture](docs/architecture.md) | Project structure, conventions, discovery |
 | [Cloud](docs/cloud.md) | AWS ECS, GCP Cloud Run, Docker |
 | [Data Model](docs/data.md) | Database schema |
 
 **Adapters:** [Auth](docs/auth.md) · [Events](docs/events.md) · [Telemetry](docs/telemetry.md) · [Logging](docs/logging.md) · [Maintenance](docs/maintenance.md) · [OAuth](docs/oauth-and-delegation.md)
 
-**API:** [Workflows](docs/api/workflows.md) · [Tasks](docs/api/tasks.md) · [Escalations](docs/api/escalations.md) · [YAML Workflows](docs/api/yaml-workflows.md) · [Users](docs/api/users.md) · [Roles](docs/api/roles.md) · [Service Accounts](docs/api/service-accounts.md) · [MCP Servers](docs/api/mcp-servers.md) · [MCP Runs](docs/api/mcp-runs.md) · [Exports](docs/api/exports.md)
+**HTTP API:** [Workflows](docs/api/http/workflows.md) · [Tasks](docs/api/http/tasks.md) · [Escalations](docs/api/http/escalations.md) · [YAML Workflows](docs/api/http/yaml-workflows.md) · [Users](docs/api/http/users.md) · [Roles](docs/api/http/roles.md) · [Service Accounts](docs/api/http/service-accounts.md) · [MCP Servers](docs/api/http/mcp-servers.md) · [MCP Runs](docs/api/http/mcp-runs.md) · [Exports](docs/api/http/exports.md)
+
+**SDK:** [Overview](docs/sdk.md) · [Workflows](docs/api/sdk/workflows.md) · [Tasks](docs/api/sdk/tasks.md) · [Escalations](docs/api/sdk/escalations.md) · [YAML Workflows](docs/api/sdk/yaml-workflows.md) · [MCP](docs/api/sdk/mcp.md) · [Events](docs/api/sdk/events.md)
 
 ## Contributing
 

package/build/api/auth.d.ts

@@ -0,0 +1,16 @@
+import type { LTApiResult } from '../types/sdk';
+/**
+ * Authenticate a user by username and password.
+ *
+ * Verifies credentials against the user store and returns a signed JWT
+ * with the user's roles and highest privilege level. The token is valid
+ * for 24 hours.
+ *
+ * @param input.username — login identifier (external_id)
+ * @param input.password — plaintext password
+ * @returns `{ status: 200, data: { token, user: { id, external_id, display_name, roles } } }`
+ */
+export declare function login(input: {
+    username: string;
+    password: string;
+}): Promise<LTApiResult>;

package/build/api/auth.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const user_1 = require("../services/user");
+const auth_1 = require("../modules/auth");
+/**
+ * Authenticate a user by username and password.
+ *
+ * Verifies credentials against the user store and returns a signed JWT
+ * with the user's roles and highest privilege level. The token is valid
+ * for 24 hours.
+ *
+ * @param input.username — login identifier (external_id)
+ * @param input.password — plaintext password
+ * @returns `{ status: 200, data: { token, user: { id, external_id, display_name, roles } } }`
+ */
+async function login(input) {
+    try {
+        const { username, password } = input;
+        if (!username || !password) {
+            return { status: 400, error: 'username and password are required' };
+        }
+        const user = await (0, user_1.verifyPassword)(username, password);
+        if (!user) {
+            return { status: 401, error: 'Invalid credentials' };
+        }
+        const highestType = user.roles.some((r) => r.type === 'superadmin')
+            ? 'superadmin'
+            : user.roles.some((r) => r.type === 'admin')
+                ? 'admin'
+                : 'member';
+        const token = (0, auth_1.signToken)({
+            userId: user.id,
+            role: highestType,
+            roles: user.roles.map((r) => ({ role: r.role, type: r.type })),
+        }, '24h');
+        return {
+            status: 200,
+            data: {
+                token,
+                user: {
+                    id: user.id,
+                    external_id: user.external_id,
+                    display_name: user.display_name,
+                    roles: user.roles,
+                },
+            },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/bot-accounts.d.ts

@@ -0,0 +1,137 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+/**
+ * List all bot accounts with pagination.
+ *
+ * @param input.limit — maximum number of bots to return (default 50)
+ * @param input.offset — number of bots to skip for pagination (default 0)
+ * @returns `{ status: 200, data: Bot[] }` paginated list of bots
+ */
+export declare function listBots(input: {
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+/**
+ * Retrieve a single bot account by ID.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: Bot }` the bot record, or 404 if not found
+ */
+export declare function getBot(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Create a new bot account with optional roles.
+ *
+ * Validates that each provided role has a valid type (superadmin, admin, member).
+ * Returns 409 if a bot with the same name already exists.
+ *
+ * @param input.name — unique bot name (required)
+ * @param input.description — optional text description of the bot
+ * @param input.display_name — optional human-friendly display name
+ * @param input.roles — optional list of roles to assign at creation, each with a role name and type
+ * @param auth — authenticated user context; userId is recorded as the bot creator
+ * @returns `{ status: 201, data: Bot }` the newly created bot record
+ */
+export declare function createBot(input: {
+    name: string;
+    description?: string;
+    display_name?: string;
+    roles?: {
+        role: string;
+        type: string;
+    }[];
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Update mutable fields on an existing bot account.
+ *
+ * @param input.id — unique identifier of the bot to update
+ * @param input.display_name — new display name
+ * @param input.description — new description
+ * @param input.status — new status value
+ * @returns `{ status: 200, data: Bot }` the updated bot record, or 404 if not found
+ */
+export declare function updateBot(input: {
+    id: string;
+    display_name?: string;
+    description?: string;
+    status?: string;
+}): Promise<LTApiResult>;
+/**
+ * Delete a bot account by ID.
+ *
+ * @param input.id — unique identifier of the bot to delete
+ * @returns `{ status: 200, data: { deleted: true } }` on success, or 404 if not found
+ */
+export declare function deleteBot(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * List all roles assigned to a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: { roles: Role[] } }` the bot's roles, or 404 if bot not found
+ */
+export declare function getBotRoles(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Assign a role to a bot account.
+ *
+ * Validates that the role type is one of superadmin, admin, or member.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.role — role name to assign
+ * @param input.type — role type (superadmin, admin, or member)
+ * @returns `{ status: 201, data: Role }` the newly assigned role, or 404 if bot not found
+ */
+export declare function addBotRole(input: {
+    id: string;
+    role: string;
+    type: string;
+}): Promise<LTApiResult>;
+/**
+ * Remove a role from a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.role — role name to remove
+ * @returns `{ status: 200, data: { removed: true } }` on success, or 404 if role not found
+ */
+export declare function removeBotRole(input: {
+    id: string;
+    role: string;
+}): Promise<LTApiResult>;
+/**
+ * List all API keys for a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: { keys: ApiKey[] } }` the bot's API keys, or 404 if bot not found
+ */
+export declare function listBotKeys(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * Create a new API key for a bot account.
+ *
+ * Returns 409 if an API key with the same name already exists for this bot.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.name — human-readable name for the API key (required)
+ * @param input.scopes — optional list of permission scopes to restrict the key
+ * @param input.expires_at — optional ISO 8601 expiration timestamp
+ * @returns `{ status: 201, data: ApiKey }` the newly created API key (includes the secret)
+ */
+export declare function createBotKey(input: {
+    id: string;
+    name: string;
+    scopes?: string[];
+    expires_at?: string;
+}): Promise<LTApiResult>;
+/**
+ * Revoke an existing bot API key.
+ *
+ * @param input.keyId — unique identifier of the API key to revoke
+ * @returns `{ status: 200, data: { revoked: true } }` on success, or 404 if key not found
+ */
+export declare function revokeBotKey(input: {
+    keyId: string;
+}): Promise<LTApiResult>;

package/build/api/bot-accounts.js

@@ -0,0 +1,302 @@
+"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.listBots = listBots;
+exports.getBot = getBot;
+exports.createBot = createBot;
+exports.updateBot = updateBot;
+exports.deleteBot = deleteBot;
+exports.getBotRoles = getBotRoles;
+exports.addBotRole = addBotRole;
+exports.removeBotRole = removeBotRole;
+exports.listBotKeys = listBotKeys;
+exports.createBotKey = createBotKey;
+exports.revokeBotKey = revokeBotKey;
+const iam = __importStar(require("../services/iam"));
+const user_1 = require("../services/user");
+/**
+ * List all bot accounts with pagination.
+ *
+ * @param input.limit — maximum number of bots to return (default 50)
+ * @param input.offset — number of bots to skip for pagination (default 0)
+ * @returns `{ status: 200, data: Bot[] }` paginated list of bots
+ */
+async function listBots(input) {
+    try {
+        const limit = input.limit ?? 50;
+        const offset = input.offset ?? 0;
+        const result = await iam.listBots(limit, offset);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Retrieve a single bot account by ID.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: Bot }` the bot record, or 404 if not found
+ */
+async function getBot(input) {
+    try {
+        const bot = await iam.getBot(input.id);
+        if (!bot) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        return { status: 200, data: bot };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Create a new bot account with optional roles.
+ *
+ * Validates that each provided role has a valid type (superadmin, admin, member).
+ * Returns 409 if a bot with the same name already exists.
+ *
+ * @param input.name — unique bot name (required)
+ * @param input.description — optional text description of the bot
+ * @param input.display_name — optional human-friendly display name
+ * @param input.roles — optional list of roles to assign at creation, each with a role name and type
+ * @param auth — authenticated user context; userId is recorded as the bot creator
+ * @returns `{ status: 201, data: Bot }` the newly created bot record
+ */
+async function createBot(input, auth) {
+    try {
+        if (!input.name) {
+            return { status: 400, error: 'name is required' };
+        }
+        if (input.roles) {
+            for (const r of input.roles) {
+                if (!r.role || !r.type || !(0, user_1.isValidRoleType)(r.type)) {
+                    return {
+                        status: 400,
+                        error: 'Each role must have a role name and type (superadmin, admin, member)',
+                    };
+                }
+            }
+        }
+        const bot = await iam.createBot({
+            name: input.name,
+            description: input.description,
+            display_name: input.display_name,
+            roles: input.roles,
+            created_by: auth?.userId,
+        });
+        return { status: 201, data: bot };
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            return { status: 409, error: 'Bot with this name already exists' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Update mutable fields on an existing bot account.
+ *
+ * @param input.id — unique identifier of the bot to update
+ * @param input.display_name — new display name
+ * @param input.description — new description
+ * @param input.status — new status value
+ * @returns `{ status: 200, data: Bot }` the updated bot record, or 404 if not found
+ */
+async function updateBot(input) {
+    try {
+        const { id, ...fields } = input;
+        const bot = await iam.updateBot(id, fields);
+        if (!bot) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        return { status: 200, data: bot };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Delete a bot account by ID.
+ *
+ * @param input.id — unique identifier of the bot to delete
+ * @returns `{ status: 200, data: { deleted: true } }` on success, or 404 if not found
+ */
+async function deleteBot(input) {
+    try {
+        const deleted = await iam.deleteBot(input.id);
+        if (!deleted) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        return { status: 200, data: { deleted: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List all roles assigned to a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: { roles: Role[] } }` the bot's roles, or 404 if bot not found
+ */
+async function getBotRoles(input) {
+    try {
+        const bot = await iam.getBot(input.id);
+        if (!bot) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        const roles = await iam.getBotRoles(input.id);
+        return { status: 200, data: { roles } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Assign a role to a bot account.
+ *
+ * Validates that the role type is one of superadmin, admin, or member.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.role — role name to assign
+ * @param input.type — role type (superadmin, admin, or member)
+ * @returns `{ status: 201, data: Role }` the newly assigned role, or 404 if bot not found
+ */
+async function addBotRole(input) {
+    try {
+        if (!input.role || !input.type) {
+            return { status: 400, error: 'role and type are required' };
+        }
+        if (!(0, user_1.isValidRoleType)(input.type)) {
+            return { status: 400, error: 'type must be superadmin, admin, or member' };
+        }
+        const bot = await iam.getBot(input.id);
+        if (!bot) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        const result = await iam.addBotRole(input.id, input.role, input.type);
+        return { status: 201, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Remove a role from a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.role — role name to remove
+ * @returns `{ status: 200, data: { removed: true } }` on success, or 404 if role not found
+ */
+async function removeBotRole(input) {
+    try {
+        const removed = await iam.removeBotRole(input.id, input.role);
+        if (!removed) {
+            return { status: 404, error: 'Role not found' };
+        }
+        return { status: 200, data: { removed: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List all API keys for a bot account.
+ *
+ * @param input.id — unique identifier of the bot
+ * @returns `{ status: 200, data: { keys: ApiKey[] } }` the bot's API keys, or 404 if bot not found
+ */
+async function listBotKeys(input) {
+    try {
+        const bot = await iam.getBot(input.id);
+        if (!bot) {
+            return { status: 404, error: 'Bot not found' };
+        }
+        const keys = await iam.listBotKeys(input.id);
+        return { status: 200, data: { keys } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Create a new API key for a bot account.
+ *
+ * Returns 409 if an API key with the same name already exists for this bot.
+ *
+ * @param input.id — unique identifier of the bot
+ * @param input.name — human-readable name for the API key (required)
+ * @param input.scopes — optional list of permission scopes to restrict the key
+ * @param input.expires_at — optional ISO 8601 expiration timestamp
+ * @returns `{ status: 201, data: ApiKey }` the newly created API key (includes the secret)
+ */
+async function createBotKey(input) {
+    try {
+        if (!input.name) {
+            return { status: 400, error: 'name is required' };
+        }
+        const expiresAt = input.expires_at ? new Date(input.expires_at) : undefined;
+        const result = await iam.createBotKey(input.id, input.name, input.scopes || [], expiresAt);
+        return { status: 201, data: result };
+    }
+    catch (err) {
+        if (err.message === 'Bot not found') {
+            return { status: 404, error: err.message };
+        }
+        if (err.code === '23505') {
+            return { status: 409, error: 'API key with this name already exists for this bot' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Revoke an existing bot API key.
+ *
+ * @param input.keyId — unique identifier of the API key to revoke
+ * @returns `{ status: 200, data: { revoked: true } }` on success, or 404 if key not found
+ */
+async function revokeBotKey(input) {
+    try {
+        const revoked = await iam.revokeBotKey(input.keyId);
+        if (!revoked) {
+            return { status: 404, error: 'API key not found' };
+        }
+        return { status: 200, data: { revoked: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/controlplane.d.ts

@@ -0,0 +1,68 @@
+import type { LTApiResult } from '../types/sdk';
+/**
+ * List all registered application namespaces.
+ *
+ * @returns `{ status: 200, data: { apps } }` array of known app identifiers
+ */
+export declare function listApps(): Promise<LTApiResult>;
+/**
+ * Query active worker profiles for an application.
+ *
+ * Sends a roll-call request to the mesh and collects responses from
+ * all running workers within the optional delay window.
+ *
+ * @param input.appId — application namespace to query (defaults to 'durable')
+ * @param input.delay — milliseconds to wait for worker responses before returning
+ * @returns `{ status: 200, data: { profiles } }` array of worker profile objects
+ */
+export declare function rollCall(input: {
+    appId?: string;
+    delay?: number;
+}): Promise<LTApiResult>;
+/**
+ * Apply a throttle rate to workflow execution.
+ *
+ * Sets the throttle value for a specific topic or workflow within an app
+ * namespace. Also publishes a synthetic `mesh.throttle` event so the
+ * dashboard event stream reflects the change.
+ *
+ * @param input.appId — application namespace (defaults to 'durable')
+ * @param input.throttle — throttle value to apply (required, must be a number)
+ * @param input.topic — optional topic to scope the throttle to
+ * @param input.guid — optional workflow GUID to scope the throttle to
+ * @returns `{ status: 200, data: { success } }` boolean indicating the throttle was applied
+ */
+export declare function applyThrottle(input: {
+    appId?: string;
+    throttle: number;
+    topic?: string;
+    guid?: string;
+}): Promise<LTApiResult>;
+/**
+ * Retrieve stream statistics for an application.
+ *
+ * Returns throughput and backlog metrics for Redis streams backing the
+ * given app namespace over the specified time window.
+ *
+ * @param input.app_id — application namespace (defaults to 'durable')
+ * @param input.duration — time window for stats aggregation, e.g. '1h', '30m' (defaults to '1h')
+ * @param input.stream — optional specific stream name to filter results
+ * @returns `{ status: 200, data: { ... } }` stream statistics object
+ */
+export declare function getStreamStats(input: {
+    app_id?: string;
+    duration?: string;
+    stream?: string;
+}): Promise<LTApiResult>;
+/**
+ * Subscribe to mesh events for an application.
+ *
+ * Establishes a subscription to the event stream of the given app
+ * namespace so that mesh events are captured and forwarded.
+ *
+ * @param input.appId — application namespace to subscribe to (defaults to 'durable')
+ * @returns `{ status: 200, data: { subscribed, appId } }` confirmation with the subscribed app ID
+ */
+export declare function subscribeMesh(input: {
+    appId?: string;
+}): Promise<LTApiResult>;