@vicinae/api 0.3.0

package/README.md

@@ -0,0 +1,37 @@
+This package lets you extend the [Vicinae](https://docs.vicinae.com/) launcher using React and TypeScript.
+
+# Getting started
+
+Install the package:
+
+```
+npm install @vicinae/api
+```
+
+# Versioning
+
+The `@vicinae/api` package follows the same versioning as the main `vicinae` binary, since the API is always embedded in the binary.
+
+# CLI usage
+
+The package exports the `vici` binary which is used to build and run extensions in development mode.
+
+While convenience scripts are already provided in the boilerplate, you can still call the binary manually:
+
+```bash
+npx vici --help
+
+# assuming vicinae is running
+npx vici develop 
+npx vici build -o my/output/path
+```
+
+# API developers
+
+If you are working on developing the API, it is recommended to point `@vicinae/api` to the local api directory:
+
+```
+npm install /path/to/vicinae/source/api
+```
+
+Note that you need to recompile the `api` package on every change you make to it.

package/bin/run.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { execute } = require("@oclif/core");
+
+const main = async () => {
+	await execute({ dir: __filename });
+}
+
+main();

package/dist/api/ai.d.ts

@@ -0,0 +1,110 @@
+import { ImageLike } from "./image";
+export declare namespace AI {
+    /**
+     * Returns a prompt completion.
+     *
+     * @param prompt - The prompt to ask the AI.
+     * @param options - Options to control which and how the AI model should behave.
+     *
+     * @example
+     * ```typescript
+     * import { Detail, AI, LaunchProps } from "@raycast/api";
+     * import { usePromise } from "@raycast/utils";
+     * import { useState } from "react";
+     *
+     * export default function Command(props: LaunchProps<{ arguments: { prompt: string } }>) {
+     *   const [data, setData] = useState("");
+     *   const { isLoading } = usePromise(
+     *     async (prompt) => {
+     *       const stream = AI.ask(prompt);
+     *       stream.on("data", (data) => {
+     *         setData((x) => x + data);
+     *       });
+     *       await stream;
+     *     },
+     *     [props.arguments.prompt]
+     *   );
+     *
+     *   return <Detail isLoading={isLoading} markdown={data} />;
+     * }
+     * ```
+     */
+    function ask(prompt: string, options?: AskOptions): Promise<string> & {
+        on(event: "data", listener: (chunk: string) => void): void;
+    };
+    type AskOptions = {
+        /**
+         * Concrete tasks, such as fixing grammar, require less creativity while open-ended questions, such as generating ideas, require more.
+         * If a number is passed, it needs to be in the range 0-2. For larger values, 2 will be used. For lower values, 0 will be used.
+         */
+        creativity?: Creativity;
+        /**
+         * The AI model to use to answer to the prompt.
+         */
+        model?: Model | string | __DeprecatedModelUnion;
+        /**
+         * Abort signal to cancel the request.
+         */
+        signal?: AbortSignal;
+    };
+    /**
+     * Concrete tasks, such as fixing grammar, require less creativity while open-ended questions, such as generating ideas, require more.
+     * If a number is passed, it needs to be in the range 0-2. For larger values, 2 will be used. For lower values, 0 will be used.
+     */
+    type Creativity = "none" | "low" | "medium" | "high" | "maximum" | number;
+    /**
+     * The AI model to use to answer to the prompt.
+     * @defaultValue `AI.Model["OpenAI_GPT4o-mini"]`
+     */
+    enum Model {
+        OpenAI_GPT4 = "openai-gpt-4",
+        "OpenAI_GPT4-turbo" = "openai-gpt-4-turbo",
+        OpenAI_GPT4o = "openai-gpt-4o",
+        "OpenAI_GPT4o-mini" = "openai-gpt-4o-mini",
+        Anthropic_Claude_Haiku = "anthropic-claude-haiku",
+        Anthropic_Claude_Opus = "anthropic-claude-opus",
+        Anthropic_Claude_Sonnet = "anthropic-claude-sonnet",
+        MixtraL_8x7B = "mixtral-8x7b",
+        "Mistral_Nemo" = "mistral-nemo",
+        "Mistral_Large2" = "mistral-large-2",
+        Llama3_70B = "llama3-70b",
+        "Llama3.1_70B" = "llama3.1-70b",
+        "Llama3.1_8B" = "llama3.1-8b",
+        "Llama3.1_405B" = "llama3.1-405b",
+        "Perplexity_Llama3.1_Sonar_Huge" = "perplexity-llama-3.1-sonar-huge-128k-online",
+        "Perplexity_Llama3.1_Sonar_Large" = "perplexity-llama-3.1-sonar-large-128k-online",
+        "Perplexity_Llama3.1_Sonar_Small" = "perplexity-llama-3.1-sonar-small-128k-online",
+        /** @deprecated Use `AI.Model["OpenAI_GPT4o-mini"]` instead */
+        "OpenAI_GPT3.5-turbo-instruct" = "openai-gpt-3.5-turbo-instruct",
+        /** @deprecated Use `AI.Model.Llama3_70B` instead */
+        Llama2_70B = "llama2-70b",
+        /** @deprecated Use `AI.Model.Perplexity_Llama3_Sonar_Large` instead */
+        Perplexity_Sonar_Medium_Online = "perplexity-sonar-medium-online",
+        /** @deprecated Use `AI.Model.Perplexity_Llama3_Sonar_Small` instead */
+        Perplexity_Sonar_Small_Online = "perplexity-sonar-small-online",
+        /** @deprecated Use `AI.Model.Llama3_70B` instead */
+        Codellama_70B_instruct = "codellama-70b-instruct",
+        /** @deprecated Use `AI.Model["Perplexity_Llama3.1_Sonar_Large"]` instead */
+        Perplexity_Llama3_Sonar_Large = "perplexity-llama-3-sonar-large-online",
+        /** @deprecated Use `AI.Model["Perplexity_Llama3.1_Sonar_Small"]` instead */
+        Perplexity_Llama3_Sonar_Small = "perplexity-llama-3-sonar-small-online",
+        /** @deprecated Use `AI.Model["OpenAI_GPT4o-mini"]` instead */
+        "OpenAI_GPT3.5-turbo" = "openai-gpt-3.5-turbo"
+    }
+    /** @deprecated Use the `AI.Model` enum instead */
+    type __DeprecatedModelUnion = "openai-gpt-3.5-turbo-instruct" | "openai-gpt-3.5-turbo" | "openai-gpt-4" | "openai-gpt-4-turbo" | "anthropic-claude-haiku" | "anthropic-claude-opus" | "anthropic-claude-sonnet" | "perplexity-sonar-medium-online" | "perplexity-sonar-small-online" | "llama2-70b" | "mixtral-8x7b" | "codellama-70b-instruct"
+    /** @deprecated */
+     | "gpt-3.5-turbo"
+    /** @deprecated */
+     | "gpt-3.5-turbo-instruct"
+    /** @deprecated */
+     | "gpt-4"
+    /** @deprecated */
+     | "text-davinci-003";
+    type ModelInfo = {
+        id: string;
+        name: string;
+        icon?: ImageLike;
+    };
+    const getModels: () => Promise<AI.ModelInfo[]>;
+}

package/dist/api/ai.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI = void 0;
+const stream_1 = require("stream");
+const bus_1 = require("./bus");
+const crypto_1 = require("crypto");
+var AI;
+(function (AI) {
+    /**
+     * Returns a prompt completion.
+     *
+     * @param prompt - The prompt to ask the AI.
+     * @param options - Options to control which and how the AI model should behave.
+     *
+     * @example
+     * ```typescript
+     * import { Detail, AI, LaunchProps } from "@raycast/api";
+     * import { usePromise } from "@raycast/utils";
+     * import { useState } from "react";
+     *
+     * export default function Command(props: LaunchProps<{ arguments: { prompt: string } }>) {
+     *   const [data, setData] = useState("");
+     *   const { isLoading } = usePromise(
+     *     async (prompt) => {
+     *       const stream = AI.ask(prompt);
+     *       stream.on("data", (data) => {
+     *         setData((x) => x + data);
+     *       });
+     *       await stream;
+     *     },
+     *     [props.arguments.prompt]
+     *   );
+     *
+     *   return <Detail isLoading={isLoading} markdown={data} />;
+     * }
+     * ```
+     */
+    function ask(prompt, options) {
+        const handlerId = (0, crypto_1.randomUUID)();
+        const emitter = new stream_1.EventEmitter;
+        const promise = new Promise((resolve, reject) => {
+            let answer = '';
+            bus_1.bus.request('ai.create-completion', {
+                prompt,
+                options,
+                callback: handlerId
+            })
+                .then(({ data }) => {
+                if (!data.started) {
+                    reject(new Error("Could not create completion"));
+                }
+                const { unsubscribe } = bus_1.bus.subscribe(handlerId, (...args) => {
+                    const data = args[0];
+                    answer += data.token;
+                    emitter.emit('data', data.token);
+                    if (data.done) {
+                        unsubscribe();
+                        resolve(answer);
+                    }
+                });
+                if (options?.signal) {
+                    options.signal.addEventListener('abort', () => {
+                        bus_1.bus.request('ai.abort-completion');
+                        unsubscribe();
+                        resolve(answer);
+                    });
+                }
+            })
+                .catch(err => reject(err));
+        });
+        return Object.assign(promise, {
+            on: emitter.on.bind(emitter)
+        });
+    }
+    AI.ask = ask;
+    /**
+     * The AI model to use to answer to the prompt.
+     * @defaultValue `AI.Model["OpenAI_GPT4o-mini"]`
+     */
+    let Model;
+    (function (Model) {
+        Model["OpenAI_GPT4"] = "openai-gpt-4";
+        Model["OpenAI_GPT4-turbo"] = "openai-gpt-4-turbo";
+        Model["OpenAI_GPT4o"] = "openai-gpt-4o";
+        Model["OpenAI_GPT4o-mini"] = "openai-gpt-4o-mini";
+        Model["Anthropic_Claude_Haiku"] = "anthropic-claude-haiku";
+        Model["Anthropic_Claude_Opus"] = "anthropic-claude-opus";
+        Model["Anthropic_Claude_Sonnet"] = "anthropic-claude-sonnet";
+        Model["MixtraL_8x7B"] = "mixtral-8x7b";
+        Model["Mistral_Nemo"] = "mistral-nemo";
+        Model["Mistral_Large2"] = "mistral-large-2";
+        Model["Llama3_70B"] = "llama3-70b";
+        Model["Llama3.1_70B"] = "llama3.1-70b";
+        Model["Llama3.1_8B"] = "llama3.1-8b";
+        Model["Llama3.1_405B"] = "llama3.1-405b";
+        Model["Perplexity_Llama3.1_Sonar_Huge"] = "perplexity-llama-3.1-sonar-huge-128k-online";
+        Model["Perplexity_Llama3.1_Sonar_Large"] = "perplexity-llama-3.1-sonar-large-128k-online";
+        Model["Perplexity_Llama3.1_Sonar_Small"] = "perplexity-llama-3.1-sonar-small-128k-online";
+        /** @deprecated Use `AI.Model["OpenAI_GPT4o-mini"]` instead */
+        Model["OpenAI_GPT3.5-turbo-instruct"] = "openai-gpt-3.5-turbo-instruct";
+        /** @deprecated Use `AI.Model.Llama3_70B` instead */
+        Model["Llama2_70B"] = "llama2-70b";
+        /** @deprecated Use `AI.Model.Perplexity_Llama3_Sonar_Large` instead */
+        Model["Perplexity_Sonar_Medium_Online"] = "perplexity-sonar-medium-online";
+        /** @deprecated Use `AI.Model.Perplexity_Llama3_Sonar_Small` instead */
+        Model["Perplexity_Sonar_Small_Online"] = "perplexity-sonar-small-online";
+        /** @deprecated Use `AI.Model.Llama3_70B` instead */
+        Model["Codellama_70B_instruct"] = "codellama-70b-instruct";
+        /** @deprecated Use `AI.Model["Perplexity_Llama3.1_Sonar_Large"]` instead */
+        Model["Perplexity_Llama3_Sonar_Large"] = "perplexity-llama-3-sonar-large-online";
+        /** @deprecated Use `AI.Model["Perplexity_Llama3.1_Sonar_Small"]` instead */
+        Model["Perplexity_Llama3_Sonar_Small"] = "perplexity-llama-3-sonar-small-online";
+        /** @deprecated Use `AI.Model["OpenAI_GPT4o-mini"]` instead */
+        Model["OpenAI_GPT3.5-turbo"] = "openai-gpt-3.5-turbo";
+    })(Model = AI.Model || (AI.Model = {}));
+    AI.getModels = async () => {
+        const res = await bus_1.bus.request('ai.get-models');
+        return res.data.models;
+    };
+})(AI || (exports.AI = AI = {}));

package/dist/api/alert.d.ts

@@ -0,0 +1,22 @@
+import { Image } from './image';
+export declare namespace Alert {
+    type Options = {
+        title: string;
+        dismissAction?: ActionOptions;
+        icon?: Image.ImageLike;
+        message?: string;
+        primaryAction?: ActionOptions;
+        rememberUserChoice?: boolean;
+    };
+    enum ActionStyle {
+        Default = "default",
+        Destructive = "destructive",
+        Cancel = "cancel"
+    }
+    type ActionOptions = {
+        title: string;
+        style?: ActionStyle;
+        onAction?: () => void;
+    };
+}
+export declare const confirmAlert: (options: Alert.Options) => Promise<boolean>;

package/dist/api/alert.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmAlert = exports.Alert = void 0;
+const node_crypto_1 = require("node:crypto");
+const bus_1 = require("./bus");
+const ui_1 = require("./proto/ui");
+var Alert;
+(function (Alert) {
+    let ActionStyle;
+    (function (ActionStyle) {
+        ActionStyle["Default"] = "default";
+        ActionStyle["Destructive"] = "destructive";
+        ActionStyle["Cancel"] = "cancel";
+    })(ActionStyle = Alert.ActionStyle || (Alert.ActionStyle = {}));
+})(Alert || (exports.Alert = Alert = {}));
+;
+const styleMap = {
+    [Alert.ActionStyle.Default]: ui_1.ConfirmAlertActionStyle.Default,
+    [Alert.ActionStyle.Destructive]: ui_1.ConfirmAlertActionStyle.Destructive,
+    [Alert.ActionStyle.Cancel]: ui_1.ConfirmAlertActionStyle.Cancel,
+};
+const confirmAlert = async (options) => {
+    return new Promise(async (resolve) => {
+        const handle = (0, node_crypto_1.randomUUID)();
+        let confirmCallback = () => { };
+        let cancelCallback = () => { };
+        const { unsubscribe } = bus_1.bus.subscribe(handle, (...args) => {
+            callback(!!args[0]);
+        });
+        const callback = (value) => {
+            if (value)
+                confirmCallback();
+            else
+                cancelCallback();
+            unsubscribe();
+            resolve(value);
+        };
+        const req = ui_1.ConfirmAlertRequest.create({
+            handle,
+            title: options.title,
+            description: options.message ?? "Are you sure?",
+            rememberUserChoice: false,
+            primaryAction: {
+                title: options.primaryAction?.title ?? 'Confirm',
+                style: styleMap[options.primaryAction?.style ?? Alert.ActionStyle.Default],
+            },
+            dismissAction: {
+                title: options.dismissAction?.title ?? 'Cancel',
+                style: styleMap[options.dismissAction?.style ?? Alert.ActionStyle.Cancel],
+            }
+        });
+        if (options.primaryAction?.onAction) {
+            confirmCallback = options.primaryAction.onAction;
+        }
+        if (options.dismissAction?.onAction) {
+            cancelCallback = options.dismissAction.onAction;
+        }
+        await bus_1.bus.turboRequest('ui.confirmAlert', req);
+    });
+};
+exports.confirmAlert = confirmAlert;

package/dist/api/bus.d.ts

@@ -0,0 +1,95 @@
+import { MessagePort } from "worker_threads";
+import * as ipc from './proto/ipc';
+import * as extension from './proto/extension';
+import { Result } from './lib/result';
+export type Message<T = Record<string, any>> = {
+    envelope: {
+        id: string;
+        type: 'request' | 'response' | 'event';
+        action: string;
+    };
+    error: {
+        message?: string;
+    } | null;
+    data: T;
+};
+declare namespace EventListener {
+    type ArgValue = string | number | Record<any, any> | boolean | null | undefined;
+    type Callback = (...args: EventListener.ArgValue[]) => void;
+}
+type EventListenerInfo = {
+    callback: EventListener.Callback;
+};
+type Requests = {
+    [K in keyof Required<extension.RequestData>]: {
+        [R in keyof Required<Required<extension.RequestData>[K]>]: {
+            data: NonNullable<Required<extension.RequestData>[K][R]>;
+        };
+    };
+};
+type Responses = {
+    [K in keyof Required<extension.ResponseData>]: {
+        [R in keyof Required<Required<extension.ResponseData>[K]>]: {
+            data: NonNullable<Required<extension.ResponseData>[K][R]>;
+        };
+    };
+};
+type EndpointMapping = {
+    "app.list": "app.list";
+    "app.open": "app.open";
+    'ui.render': 'ui.render';
+    'ui.showToast': 'ui.showToast';
+    'ui.hideToast': 'ui.hideToast';
+    'ui.updateToast': 'ui.updateToast';
+    'ui.pushView': 'ui.pushView';
+    'ui.popView': 'ui.popView';
+    'ui.closeMainWindow': 'ui.closeMainWindow';
+    'ui.showHud': 'ui.showHud';
+    'ui.setSearchText': 'ui.setSearchText';
+    'ui.confirmAlert': 'ui.confirmAlert';
+    'ui.getSelectedText': 'ui.getSelectedText';
+    'storage.get': 'storage.get';
+    'storage.set': 'storage.set';
+    'storage.remove': 'storage.remove';
+    'storage.clear': 'storage.clear';
+    'storage.list': 'storage.list';
+    'oauth.authorize': 'oauth.authorize';
+    'clipboard.copy': 'clipboard.copy';
+    'clipboard.paste': 'clipboard.paste';
+};
+type RequestEndpoint = keyof EndpointMapping;
+type ResponseEndpoint = EndpointMapping[RequestEndpoint];
+type ExtractRequestType<T extends RequestEndpoint> = T extends `${infer Category}.${infer Action}` ? Category extends keyof Requests ? Action extends keyof Requests[Category] ? Requests[Category][Action] : never : never : never;
+type ExtractResponseType<T extends ResponseEndpoint> = T extends `${infer Category}.${infer Action}` ? Category extends keyof Responses ? Action extends keyof Responses[Category] ? Responses[Category][Action] : never : never : never;
+type Map = {
+    [K in RequestEndpoint]: {
+        request: ExtractRequestType<K>['data'];
+        response: ExtractResponseType<EndpointMapping[K]>['data'];
+    };
+};
+declare class Bus {
+    private readonly port;
+    private requestMap;
+    private safeRequestMap;
+    private eventListeners;
+    turboRequest<T extends RequestEndpoint>(endpoint: T, data: Map[T]['request']): Promise<Result<Map[T]['response'], Error>>;
+    private handleSafeMessage;
+    emitCrash(errorText: string): void;
+    constructor(port: MessagePort);
+    listEventListeners(type: string): EventListenerInfo[];
+    subscribe(type: string, cb: EventListenerInfo['callback']): {
+        unsubscribe: () => void;
+    };
+    emit(action: string, data: Record<string, any>): void;
+    sendMessage(message: ipc.ExtensionMessage): void;
+    request2(data: extension.RequestData, options?: {
+        timeout?: number;
+    }): Promise<Result<extension.ResponseData, Error>>;
+    request<T = Record<string, any>>(action: string, data?: Record<string, any>, options?: {
+        timeout?: number;
+        rejectOnError?: boolean;
+    }): Promise<Message<T>>;
+}
+export declare const createHandler: (handler: (...args: any[]) => void) => string;
+export declare const bus: Bus;
+export {};

package/dist/api/bus.js

@@ -0,0 +1,211 @@
+"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.bus = exports.createHandler = void 0;
+const crypto_1 = require("crypto");
+const worker_threads_1 = require("worker_threads");
+const ipc = __importStar(require("./proto/ipc"));
+const extension = __importStar(require("./proto/extension"));
+const result_1 = require("./lib/result");
+;
+class Bus {
+    port;
+    requestMap = new Map();
+    safeRequestMap = new Map();
+    eventListeners = new Map();
+    async turboRequest(endpoint, data) {
+        const [category, requestId] = endpoint.split('.');
+        const request = extension.RequestData.create({ [category]: { [requestId]: data } });
+        const res = await this.request2(request);
+        if (!res.ok) {
+            return (0, result_1.Err)(res.error);
+        }
+        const resData = res.value[category]?.[requestId];
+        if (!resData)
+            return (0, result_1.Err)(Error(`Invalid response for request of type ${endpoint}: ${JSON.stringify(res, null, 2)}`));
+        //console.error(`Got valid response for ${endpoint}`);
+        return (0, result_1.Ok)(resData);
+    }
+    handleSafeMessage(message) {
+        if (message.response) {
+            //console.log('got response response', message.response.requestId);
+            const request = this.safeRequestMap.get(message.response.requestId);
+            if (!request) {
+                //console.error(`Received response for unknown request ${message.response.requestId}`);
+                return;
+            }
+            this.requestMap.delete(message.response.requestId);
+            request.resolve(message.response);
+            return;
+        }
+        if (message.event) {
+            const { id, generic } = message.event;
+            //console.error('got event with id', id);
+            if (generic) {
+                const listeners = this.listEventListeners(id);
+                const args = JSON.parse(generic.json);
+                for (const listener of listeners) {
+                    listener.callback(...(args ?? []));
+                }
+            }
+        }
+    }
+    emitCrash(errorText) {
+        this.sendMessage({
+            event: {
+                id: (0, crypto_1.randomUUID)(),
+                crash: { text: errorText }
+            }
+        });
+    }
+    constructor(port) {
+        this.port = port;
+        if (!port)
+            return;
+        port.on('message', (buf) => {
+            this.handleSafeMessage(ipc.ExtensionMessage.decode(buf));
+        });
+        port.on('messageerror', (error) => {
+            console.error(`Message error from manager`, error);
+        });
+        port.on('close', () => {
+            console.error(`Parent port closed prematurely`);
+        });
+    }
+    listEventListeners(type) {
+        return this.eventListeners.get(type) ?? [];
+    }
+    subscribe(type, cb) {
+        const item = { callback: cb };
+        let listeners = this.eventListeners.get(type);
+        if (!listeners) {
+            this.eventListeners.set(type, [item]);
+        }
+        else {
+            listeners.push(item);
+        }
+        return {
+            unsubscribe: () => {
+                const listeners = this.eventListeners.get(type) ?? [];
+                const index = listeners.indexOf(item);
+                if (index != -1) {
+                    listeners.splice(index, 1);
+                    if (listeners.length === 0) {
+                        this.eventListeners.delete(type);
+                    }
+                }
+            }
+        };
+    }
+    emit(action, data) {
+        const message = ipc.ExtensionMessage.create({
+            event: {
+                id: action,
+                generic: { json: JSON.stringify([data]) }
+            }
+        });
+        this.sendMessage(message);
+    }
+    sendMessage(message) {
+        this.port.postMessage(ipc.ExtensionMessage.encode(message).finish());
+    }
+    request2(data, options = {}) {
+        const req = extension.Request.create({ requestId: (0, crypto_1.randomUUID)(), data });
+        return new Promise((resolve, reject) => {
+            let timeout;
+            if (options.timeout) {
+                timeout = setTimeout(() => resolve((0, result_1.Err)(Error(`request timed out`))), options.timeout);
+            }
+            const resolver = (response) => {
+                clearTimeout(timeout);
+                if (response.error) {
+                    return resolve((0, result_1.Err)(new Error(response.error.errorText)));
+                }
+                if (!response.data) {
+                    return resolve((0, result_1.Err)(new Error("No error and no data")));
+                }
+                resolve((0, result_1.Ok)(response.data));
+            };
+            try {
+                this.safeRequestMap.set(req.requestId, { resolve: resolver });
+                this.sendMessage({ request: req });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    request(action, data = {}, options = {}) {
+        const id = (0, crypto_1.randomUUID)();
+        const { rejectOnError = true } = options;
+        return new Promise((resolve, reject) => {
+            let timeout;
+            if (options.timeout) {
+                timeout = setTimeout(() => reject(new Error(`request timed out`)), options.timeout);
+            }
+            const resolver = (message) => {
+                clearTimeout(timeout);
+                if (message.error && rejectOnError) {
+                    return reject(message.error.message ?? "Unknown error");
+                }
+                resolve(message);
+            };
+            try {
+                this.requestMap.set(id, { resolve: resolver });
+                const message = {
+                    envelope: {
+                        type: 'request',
+                        action,
+                        id
+                    },
+                    data,
+                    error: null
+                };
+                this.port.postMessage(message);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+;
+const createHandler = (handler) => {
+    const id = (0, crypto_1.randomUUID)();
+    exports.bus.subscribe(id, handler);
+    return id;
+};
+exports.createHandler = createHandler;
+exports.bus = new Bus(worker_threads_1.parentPort);