@meetopenbot/linear 0.0.1

package/dist/index.js

@@ -0,0 +1,318 @@
+import { agentOutput, definePlugin, shouldHandleInvoke, toolResult, uiWidget, webhookHttpResponse, } from "@meetopenbot/plugin-sdk";
+import { clearTokens, formatMissingCredentials, readLinearConfig, resolveLinearCredentials, resolveWebhookBaseUrl, saveTokens, } from "./config.js";
+import { runLinearAgent } from "./linear-agent.js";
+import { buildIssuesListWidget, isAssignedIssuesPrompt, isListIssuesPrompt, issuesListTitle, } from "./linear-issues.js";
+import { OAUTH_WEBHOOK_PROVIDER, buildOAuthRedirectUri, fetchViewer, handleWebhookOAuthCallback, startOAuthFlow, startWebhookOAuthFlow, } from "./oauth.js";
+/** Client-side action handled by openbot.one — opens `value.url` in the browser. */
+const OPEN_URL_ACTION_ID = "open_url";
+const CONNECT_TOOL = {
+    description: "Connect the workspace to Linear via OAuth. Returns an authorization link the user must open in their browser; after they approve, the token is stored automatically. Use this when Linear is not connected yet or credentials expired.",
+    inputSchema: { type: "object", properties: {} },
+};
+const DISCONNECT_TOOL = {
+    description: "Disconnect Linear: removes the stored OAuth tokens from the workspace.",
+    inputSchema: { type: "object", properties: {} },
+};
+const CONNECT_WAIT_MS = 120 * 1000;
+const CONNECT_WIDGET_ID = "linear-connect";
+const CONNECT_PROMPT_WIDGET_ID = "linear-connect-prompt";
+const toolDefinitions = {
+    linear_connect: CONNECT_TOOL,
+    linear_disconnect: DISCONNECT_TOOL,
+};
+function* emitConnectReply(mode, context, event, data) {
+    if (mode === "tool") {
+        yield toolResult("linear_connect", event, data);
+        return;
+    }
+    yield agentOutput({
+        agentId: context.agentId,
+        content: data.output,
+        threadId: event.meta?.threadId,
+        meta: event.meta,
+    });
+}
+function* yieldOAuthAuthorizeWidget(agentId, authorizeUrl, modeHint, options) {
+    yield uiWidget({
+        agentId,
+        threadId: options.threadId,
+        meta: options.meta,
+        widget: {
+            kind: "message",
+            widgetId: options.widgetId ?? CONNECT_WIDGET_ID,
+            title: "Connect Linear",
+            body: `Open Linear in your browser to authorize OpenBot. ${modeHint}`,
+            actions: [
+                {
+                    id: OPEN_URL_ACTION_ID,
+                    label: "Connect Linear",
+                    variant: "primary",
+                    value: { url: authorizeUrl, target: "_blank" },
+                },
+            ],
+        },
+    });
+}
+async function createOAuthHandle(context, publicBaseUrl) {
+    const config = readLinearConfig(context.config ?? {});
+    const webhookBaseUrl = resolveWebhookBaseUrl(config, publicBaseUrl);
+    if (config.apiKey || !config.clientId)
+        return null;
+    const scopes = config.scopes ?? "read,write,issues:create,comments:create";
+    const handle = webhookBaseUrl
+        ? await startWebhookOAuthFlow({
+            storage: context.storage,
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+            scopes,
+            webhookBaseUrl,
+        })
+        : startOAuthFlow({
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+            port: config.oauthPort ?? 4137,
+            scopes,
+            onSuccess: (tokens) => saveTokens(context.storage, tokens),
+        });
+    const modeHint = webhookBaseUrl
+        ? `After approval, Linear redirects to \`${handle.redirectUri}\`.`
+        : "After you approve access you'll be redirected back and can return here.";
+    return { handle, modeHint };
+}
+function notConnectedMessage(missing) {
+    const needsConnect = missing.includes("accessToken");
+    const needsOpenAi = missing.includes("openaiApiKey");
+    if (needsConnect && needsOpenAi) {
+        return "Linear isn't connected yet, and the OpenAI API key is missing. Connect Linear below, then add `openaiApiKey` to the plugin config.";
+    }
+    if (needsConnect) {
+        return "Linear isn't connected yet. Click **Connect Linear** below to open the authorization page.";
+    }
+    return formatMissingCredentials(missing);
+}
+async function* handleConnect(context, event, publicBaseUrl, replyMode = "tool") {
+    const config = readLinearConfig(context.config ?? {});
+    const threadId = event.meta?.threadId;
+    const webhookBaseUrl = resolveWebhookBaseUrl(config, publicBaseUrl);
+    if (config.apiKey) {
+        yield* emitConnectReply(replyMode, context, event, {
+            output: "Linear is already configured with an API key in the plugin config — no OAuth connection needed.",
+        });
+        return;
+    }
+    const oauth = await createOAuthHandle(context, publicBaseUrl);
+    if (!oauth) {
+        const webhookHint = webhookBaseUrl
+            ? `   set its callback URL to ${buildOAuthRedirectUri(webhookBaseUrl)},`
+            : `   set its callback URL to http://localhost:${config.oauthPort}/oauth/callback (local), or configure webhookBaseUrl for ${buildOAuthRedirectUri("https://<your-host>")},`;
+        yield* emitConnectReply(replyMode, context, event, {
+            output: [
+                "Linear OAuth is not configured. Ways to connect:",
+                "1. Recommended: open the OpenBot web app → Settings → Plugins and click Connect on the Linear plugin (install-time OAuth, no setup needed).",
+                "2. Self-hosted OAuth: create an OAuth application at https://linear.app/settings/api/applications,",
+                webhookHint,
+                "   then put its Client ID into this plugin's `clientId` config field and run linear_connect again.",
+                "3. API key: create a personal API key at https://linear.app/settings/api and put it into the `apiKey` config field (or a LINEAR_API_KEY secret variable).",
+            ].join("\n"),
+        });
+        return;
+    }
+    const { handle, modeHint } = oauth;
+    yield* yieldOAuthAuthorizeWidget(context.agentId, handle.authorizeUrl, modeHint, { threadId, meta: event.meta });
+    const outcome = await Promise.race([
+        handle.completion,
+        new Promise((resolve) => {
+            const t = setTimeout(() => resolve("pending"), CONNECT_WAIT_MS);
+            t.unref?.();
+        }),
+    ]);
+    if (outcome === "pending") {
+        yield* emitConnectReply(replyMode, context, event, {
+            authorizeUrl: handle.authorizeUrl,
+            redirectUri: handle.redirectUri,
+            output: "Authorization link sent. Waiting for the user to approve in the browser — the link stays valid for 10 minutes. Once they confirm, ask me to work with Linear again.",
+        });
+        return;
+    }
+    if (!outcome) {
+        yield* emitConnectReply(replyMode, context, event, {
+            error: "authorization_failed",
+            output: "Linear authorization did not complete (denied, failed, or the callback is unavailable). Run linear_connect to try again.",
+        });
+        return;
+    }
+    let who = "";
+    try {
+        const { viewer, organization } = await fetchViewer(outcome.accessToken);
+        who = ` as ${viewer.displayName ?? viewer.name} in workspace "${organization.name}"`;
+    }
+    catch {
+        // Connection succeeded even if the identity lookup failed.
+    }
+    yield uiWidget({
+        agentId: context.agentId,
+        threadId,
+        widget: {
+            kind: "message",
+            widgetId: CONNECT_WIDGET_ID,
+            title: "Linear connected",
+            body: `✅ Connected to Linear${who}.`,
+            state: "submitted",
+        },
+    });
+    yield* emitConnectReply(replyMode, context, event, {
+        connected: true,
+        output: `Successfully connected to Linear${who}. Tokens are stored securely and refresh automatically.`,
+    });
+}
+const linearPluginConfigSchema = {
+    type: "object",
+    properties: {
+        clientId: {
+            type: "string",
+            description: "Linear OAuth application Client ID (create one at linear.app/settings/api/applications)",
+        },
+        clientSecret: {
+            type: "string",
+            description: "Linear OAuth application Client Secret (optional — PKCE is used when omitted)",
+            format: "password",
+        },
+        apiKey: {
+            type: "string",
+            description: "Linear personal API key (alternative to OAuth)",
+            format: "password",
+        },
+        oauthPort: {
+            type: "number",
+            description: "Local port for the OAuth callback (must match the OAuth app callback URL)",
+            default: 4137,
+        },
+        scopes: {
+            type: "string",
+            description: "Comma-separated OAuth scopes",
+            default: "read,write,issues:create,comments:create",
+        },
+        webhookBaseUrl: {
+            type: "string",
+            description: "Public runtime base URL for OAuth callback via /api/webhooks/linear (e.g. https://my-host.com). Falls back to host publicBaseUrl when omitted.",
+            format: "url",
+        },
+        openaiApiKey: {
+            type: "string",
+            description: "OpenAI API key for direct Linear agent invocations",
+            format: "password",
+        },
+        model: {
+            type: "string",
+            description: "OpenAI model id for direct Linear agent invocations (default: gpt-4o-mini)",
+            default: "gpt-4o-mini",
+        },
+    },
+};
+export default definePlugin({
+    id: "linear",
+    name: "Linear",
+    description: "Linear OAuth connect flow and MCP-backed agent for issues, projects, and comments",
+    configSchema: linearPluginConfigSchema,
+    toolDefinitions,
+    factory: (pluginContext) => (builder) => {
+        const { agentId, config, storage } = pluginContext;
+        const linearConfig = readLinearConfig(config);
+        const publicBaseUrl = pluginContext.publicBaseUrl ?? "";
+        builder.on("action:webhook", async function* (event) {
+            const webhook = event;
+            if (webhook.data.provider !== OAUTH_WEBHOOK_PROVIDER)
+                return;
+            const result = await handleWebhookOAuthCallback({
+                storage,
+                query: webhook.data.query ?? {},
+                onSuccess: (tokens) => saveTokens(storage, tokens),
+            });
+            if (result.kind === "ignore")
+                return;
+            yield webhookHttpResponse({
+                status: result.status,
+                headers: { "Content-Type": "text/html; charset=utf-8" },
+                body: result.html,
+            });
+        });
+        builder.on("action:linear_connect", async function* (event) {
+            yield* handleConnect(pluginContext, event, publicBaseUrl);
+        });
+        builder.on("action:linear_disconnect", async function* (event) {
+            await clearTokens(storage);
+            yield toolResult("linear_disconnect", event, {
+                output: "Linear disconnected — stored OAuth tokens were removed.",
+            });
+        });
+        builder.on("agent:invoke", async function* (event, ctx) {
+            if (!shouldHandleInvoke(event, agentId))
+                return;
+            if (event.meta?.threadId) {
+                ctx.state.threadId = event.meta.threadId;
+            }
+            const threadId = event.meta?.threadId ?? ctx.state.threadId;
+            const userMessage = (event.data.content ?? "").trim();
+            if (!userMessage || !threadId)
+                return;
+            const auth = await resolveLinearCredentials(linearConfig, storage);
+            if (!auth.ok) {
+                yield agentOutput({
+                    agentId,
+                    content: notConnectedMessage(auth.missing),
+                    threadId,
+                    meta: event.meta,
+                });
+                if (auth.missing.includes("accessToken")) {
+                    const oauth = await createOAuthHandle(pluginContext, publicBaseUrl);
+                    if (oauth) {
+                        yield* yieldOAuthAuthorizeWidget(agentId, oauth.handle.authorizeUrl, oauth.modeHint, {
+                            threadId,
+                            meta: event.meta,
+                            widgetId: CONNECT_PROMPT_WIDGET_ID,
+                        });
+                    }
+                }
+                return;
+            }
+            try {
+                const reply = await runLinearAgent({
+                    prompt: userMessage,
+                    openaiApiKey: auth.credentials.openaiApiKey,
+                    accessToken: auth.credentials.accessToken,
+                    model: auth.credentials.model,
+                });
+                const issues = reply.issues;
+                const shouldListIssues = isListIssuesPrompt(userMessage) || isAssignedIssuesPrompt(userMessage);
+                if (shouldListIssues || issues.length > 0) {
+                    yield uiWidget({
+                        agentId,
+                        threadId,
+                        meta: event.meta,
+                        widget: buildIssuesListWidget(issues, {
+                            title: issuesListTitle(userMessage),
+                        }),
+                    });
+                }
+                const content = reply.toolErrors.length > 0 && !reply.usedTools
+                    ? `${reply.text}\n\nMCP note: ${reply.toolErrors.join("; ")}`
+                    : reply.text;
+                yield agentOutput({
+                    agentId,
+                    content,
+                    threadId,
+                    meta: event.meta,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                yield agentOutput({
+                    agentId,
+                    content: `Linear agent error: ${message}`,
+                    threadId,
+                    meta: event.meta,
+                });
+            }
+        });
+    },
+});

package/dist/linear-agent.d.ts

@@ -0,0 +1,14 @@
+import type { LinearIssue } from "./linear-issues.js";
+export type RunLinearAgentArgs = {
+    prompt: string;
+    openaiApiKey: string;
+    accessToken: string;
+    model?: string;
+};
+export type LinearAgentResult = {
+    text: string;
+    issues: LinearIssue[];
+    usedTools: boolean;
+    toolErrors: string[];
+};
+export declare function runLinearAgent(args: RunLinearAgentArgs): Promise<LinearAgentResult>;

package/dist/linear-agent.js

@@ -0,0 +1,72 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText, stepCountIs } from "ai";
+import { extractIssuesFromToolResults } from "./linear-issues.js";
+import { createLinearMcpClient } from "./linear-mcp.js";
+const SYSTEM_PROMPT = `You are the OpenBot Linear specialist agent.
+You MUST use the provided Linear MCP tools for every request about issues, projects, teams, or comments.
+Never guess or invent Linear data. If a tool returns no results, say so explicitly.
+For listing or searching issues, call linear_get_user first when the user asks for issues assigned to them, then call linear_search_issues with the correct filters.
+Summarize tool results clearly in plain text. Be concise and friendly.`;
+function extractToolErrors(toolResults) {
+    const errors = [];
+    for (const toolResult of toolResults) {
+        const output = toolResult.output;
+        if (!output || typeof output !== "object")
+            continue;
+        const record = output;
+        if (typeof record.error === "string") {
+            errors.push(`${toolResult.toolName}: ${record.error}`);
+            continue;
+        }
+        if (typeof record.isError === "boolean" && record.isError) {
+            const text = typeof record.text === "string"
+                ? record.text
+                : JSON.stringify(record).slice(0, 300);
+            errors.push(`${toolResult.toolName}: ${text}`);
+        }
+    }
+    return errors;
+}
+export async function runLinearAgent(args) {
+    const openai = createOpenAI({ apiKey: args.openaiApiKey });
+    const mcpClient = await createLinearMcpClient({
+        accessToken: args.accessToken,
+    });
+    try {
+        const tools = await mcpClient.tools();
+        if (Object.keys(tools).length === 0) {
+            throw new Error("Linear MCP server returned no tools. Check that mcp-server-linear is installed and reachable.");
+        }
+        const result = await generateText({
+            model: openai(args.model ?? "gpt-4o-mini"),
+            system: SYSTEM_PROMPT,
+            prompt: args.prompt,
+            tools,
+            stopWhen: stepCountIs(10),
+        });
+        const toolResults = result.steps.flatMap((step) => step.toolResults.map((toolResult) => ({
+            toolName: toolResult.toolName,
+            output: toolResult.output,
+        })));
+        const issues = extractIssuesFromToolResults(toolResults);
+        const toolErrors = extractToolErrors(toolResults);
+        const text = result.text.trim();
+        if (!text && toolErrors.length > 0) {
+            return {
+                text: `Linear tool error: ${toolErrors[0]}`,
+                issues,
+                usedTools: toolResults.length > 0,
+                toolErrors,
+            };
+        }
+        return {
+            text: text || (issues.length > 0 ? `Found ${issues.length} issue(s).` : "Done."),
+            issues,
+            usedTools: toolResults.length > 0,
+            toolErrors,
+        };
+    }
+    finally {
+        await mcpClient.close();
+    }
+}

package/dist/linear-issues.d.ts

@@ -0,0 +1,33 @@
+import type { RenderUIWidgetData } from "@meetopenbot/plugin-sdk";
+export type LinearIssue = {
+    id: string;
+    identifier: string;
+    title: string;
+    url: string;
+    state?: {
+        name: string;
+        type: string;
+    };
+    assignee?: {
+        name: string;
+    };
+    team?: {
+        name: string;
+        key: string;
+    };
+    project?: {
+        name: string;
+    };
+};
+export declare const ISSUES_LIST_WIDGET_ID = "linear-issues-list";
+export declare function buildIssuesListWidget(issues: LinearIssue[], options?: {
+    title?: string;
+    description?: string;
+}): RenderUIWidgetData;
+export declare function extractIssuesFromToolResults(toolResults: Array<{
+    toolName: string;
+    output: unknown;
+}>): LinearIssue[];
+export declare function isListIssuesPrompt(message: string): boolean;
+export declare function isAssignedIssuesPrompt(message: string): boolean;
+export declare function issuesListTitle(prompt: string): string;

package/dist/linear-issues.js

@@ -0,0 +1,136 @@
+const OPEN_URL_ACTION_ID = "open_url";
+export const ISSUES_LIST_WIDGET_ID = "linear-issues-list";
+function mapStateStatus(stateType) {
+    switch (stateType) {
+        case "started":
+            return "in_progress";
+        case "completed":
+            return "done";
+        case "canceled":
+            return "cancelled";
+        case "backlog":
+        case "unstarted":
+            return "pending";
+        default:
+            return undefined;
+    }
+}
+export function buildIssuesListWidget(issues, options) {
+    return {
+        kind: "list",
+        widgetId: ISSUES_LIST_WIDGET_ID,
+        title: options?.title ?? "Linear issues",
+        description: options?.description ??
+            (issues.length === 0
+                ? "No issues matched this query."
+                : `${issues.length} issue${issues.length === 1 ? "" : "s"}`),
+        items: issues.map((issue) => {
+            const details = [
+                issue.state?.name,
+                issue.assignee?.name ? `Assignee: ${issue.assignee.name}` : undefined,
+                issue.team?.name,
+                issue.project?.name,
+            ]
+                .filter(Boolean)
+                .join(" · ");
+            return {
+                id: issue.id,
+                label: `${issue.identifier}: ${issue.title}`,
+                description: details || undefined,
+                badge: issue.state?.name,
+                status: mapStateStatus(issue.state?.type),
+                actions: issue.url
+                    ? [
+                        {
+                            id: OPEN_URL_ACTION_ID,
+                            label: "Open",
+                            variant: "secondary",
+                            value: { url: issue.url, target: "_blank" },
+                        },
+                    ]
+                    : undefined,
+                metadata: {
+                    identifier: issue.identifier,
+                    url: issue.url,
+                },
+            };
+        }),
+    };
+}
+function extractTextPayload(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (typeof record.text === "string")
+        return record.text;
+    if (Array.isArray(record.content)) {
+        for (const part of record.content) {
+            if (part &&
+                typeof part === "object" &&
+                part.type === "text" &&
+                typeof part.text === "string") {
+                return part.text;
+            }
+        }
+    }
+    return undefined;
+}
+function parseIssuesPayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return [];
+    const root = payload;
+    const issuesNode = root.issues ??
+        root.data?.issues;
+    if (!issuesNode?.nodes || !Array.isArray(issuesNode.nodes))
+        return [];
+    return issuesNode.nodes
+        .filter((node) => {
+        if (!node || typeof node !== "object")
+            return false;
+        const issue = node;
+        return (typeof issue.id === "string" &&
+            typeof issue.identifier === "string" &&
+            typeof issue.title === "string");
+    })
+        .map((issue) => ({
+        ...issue,
+        url: typeof issue.url === "string" ? issue.url : "",
+    }));
+}
+export function extractIssuesFromToolResults(toolResults) {
+    const byId = new Map();
+    for (const toolResult of toolResults) {
+        if (!toolResult.toolName.includes("search_issues"))
+            continue;
+        const text = extractTextPayload(toolResult.output);
+        if (!text)
+            continue;
+        try {
+            for (const issue of parseIssuesPayload(JSON.parse(text))) {
+                byId.set(issue.id, issue);
+            }
+        }
+        catch {
+            // Ignore malformed tool payloads.
+        }
+    }
+    return [...byId.values()];
+}
+export function isListIssuesPrompt(message) {
+    const normalized = message.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return (/\b(list|show|get|fetch|what are|available)\b/.test(normalized) &&
+        /\bissues?\b/.test(normalized));
+}
+export function isAssignedIssuesPrompt(message) {
+    const normalized = message.trim().toLowerCase();
+    return (/\b(assigned to me|my issues|issues for me|issues assigned)\b/.test(normalized) || /\bissues?\s+assigned\b/.test(normalized));
+}
+export function issuesListTitle(prompt) {
+    return isAssignedIssuesPrompt(prompt)
+        ? "Issues assigned to you"
+        : "Linear issues";
+}

package/dist/linear-mcp.d.ts

@@ -0,0 +1,4 @@
+export type LinearMcpClientArgs = {
+    accessToken: string;
+};
+export declare function createLinearMcpClient(args: LinearMcpClientArgs): Promise<import("@ai-sdk/mcp").MCPClient>;

package/dist/linear-mcp.js

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+import { createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
+const require = createRequire(import.meta.url);
+function resolveMcpServerLinearLaunch() {
+    try {
+        const entry = require.resolve("mcp-server-linear");
+        return { command: process.execPath, args: [entry] };
+    }
+    catch {
+        return { command: "npx", args: ["-y", "mcp-server-linear"] };
+    }
+}
+export async function createLinearMcpClient(args) {
+    const launch = resolveMcpServerLinearLaunch();
+    return createMCPClient({
+        transport: new Experimental_StdioMCPTransport({
+            command: launch.command,
+            args: launch.args,
+            env: {
+                ...process.env,
+                LINEAR_ACCESS_TOKEN: args.accessToken,
+            },
+        }),
+    });
+}

package/dist/oauth-pending.d.ts

@@ -0,0 +1,13 @@
+import type { Storage } from "@meetopenbot/plugin-sdk";
+export declare const VAR_OAUTH_PENDING = "LINEAR_OAUTH_PENDING";
+export interface PendingOAuthSession {
+    state: string;
+    codeVerifier: string;
+    clientId: string;
+    clientSecret?: string;
+    redirectUri: string;
+    expiresAt: number;
+}
+export declare function savePendingOAuthSession(storage: Storage, session: PendingOAuthSession): Promise<void>;
+export declare function loadPendingOAuthSession(storage: Storage): Promise<PendingOAuthSession | null>;
+export declare function clearPendingOAuthSession(storage: Storage): Promise<void>;

package/dist/oauth-pending.js

@@ -0,0 +1,40 @@
+export const VAR_OAUTH_PENDING = "LINEAR_OAUTH_PENDING";
+function variableValue(variables, key) {
+    const entry = variables[key];
+    if (typeof entry === "string")
+        return entry || undefined;
+    return entry?.value || undefined;
+}
+export async function savePendingOAuthSession(storage, session) {
+    await storage.createVariable({
+        key: VAR_OAUTH_PENDING,
+        value: JSON.stringify(session),
+        secret: true,
+    });
+}
+export async function loadPendingOAuthSession(storage) {
+    const variables = (await storage.getVariables().catch(() => ({})));
+    const raw = variableValue(variables, VAR_OAUTH_PENDING) ??
+        process.env[VAR_OAUTH_PENDING];
+    if (!raw)
+        return null;
+    try {
+        const session = JSON.parse(raw);
+        if (typeof session.state !== "string" ||
+            typeof session.codeVerifier !== "string" ||
+            typeof session.clientId !== "string" ||
+            typeof session.redirectUri !== "string" ||
+            typeof session.expiresAt !== "number") {
+            return null;
+        }
+        if (Date.now() > session.expiresAt)
+            return null;
+        return session;
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearPendingOAuthSession(storage) {
+    await storage.deleteVariable({ key: VAR_OAUTH_PENDING }).catch(() => { });
+}