@blastlauncher/runtime 1.0.5 → 3.0.0-alpha.1

package/dist/main.js

@@ -0,0 +1,339 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createLineDecoder, encodeMessage, parseHostMessage, PROTOCOL_VERSION, } from "@blastlauncher/protocol";
+import { createModelProvider } from "./provider.js";
+import { Console } from "node:console";
+import { registerHooks } from "node:module";
+import { Writable } from "node:stream";
+import { pathToFileURL } from "node:url";
+import { format } from "node:util";
+import { createElement, Suspense } from "react";
+import { setCapabilityRequester } from "./api/capability.js";
+import { setRuntimeLogSink } from "./api/diagnostics.js";
+import { setEnvironment } from "./api/environment.js";
+import { setFeedbackMount } from "./api/feedback.js";
+import { decodeFormValues, flushFormPersistence, setFormDraftValues } from "./api/form.js";
+import { LaunchType } from "./api/launch.js";
+import { NavigationProvider } from "./api/navigation.js";
+import { setPreferenceValues } from "./api/preferences.js";
+import { setRenderMount } from "./api/legacy.js";
+import { UnsupportedApiError } from "./api/unsupported.js";
+import { createSceneRoot } from "./reconciler/index.js";
+let provider;
+let providerLoad;
+let stopping = false;
+let initialized = false;
+let loaded = false;
+let nextRequest = 1;
+const pending = new Map();
+// Protocol output owns the real stdout stream. Extension code that writes to
+// `process.stdout` (or a library doing it for them) must not corrupt the NDJSON
+// framing, so those writes become log messages instead. The protocol keeps its
+// own reference to the original writer.
+process.stdout.on("error", (error) => {
+    if (error.code === "EPIPE")
+        process.exit(0);
+    throw error;
+});
+const writeToStdout = process.stdout.write.bind(process.stdout);
+process.stdout.write = ((chunk, encoding, callback) => {
+    const done = typeof encoding === "function" ? encoding : callback;
+    log("info", [String(chunk).replace(/\n$/, "")]);
+    if (typeof done === "function")
+        queueMicrotask(done);
+    return true;
+});
+function send(message) {
+    if (!stopping)
+        writeToStdout(encodeMessage(message));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function finish(code) {
+    if (stopping)
+        return;
+    stopping = true;
+    process.stdin.pause();
+    setCapabilityRequester(undefined);
+    pending.clear();
+    // Explicit exit also stops extension timers; wait for protocol output to drain.
+    process.stdout.end(() => process.exit(code));
+}
+function fatal(error, code = "RUNTIME_ERROR") {
+    send({
+        type: "error",
+        code: error instanceof UnsupportedApiError ? error.code : code,
+        message: errorMessage(error),
+        fatal: true,
+    });
+    finish(1);
+}
+function log(level, args) {
+    send({ type: "log", level, message: format(...args) });
+}
+function logStream(level) {
+    return new Writable({
+        write(chunk, _encoding, callback) {
+            log(level, [String(chunk).replace(/\n$/, "")]);
+            callback();
+        },
+    });
+}
+// Console's remaining methods (trace, table, time, assert, …) also stay off stdout.
+Object.assign(console, new Console({ stdout: logStream("info"), stderr: logStream("error") }));
+console.timeStamp = () => { };
+for (const [method, level] of [
+    ["log", "info"],
+    ["info", "info"],
+    ["debug", "debug"],
+    ["warn", "warn"],
+    ["error", "error"],
+]) {
+    console[method] = (...args) => log(level, args);
+}
+process.on("uncaughtException", (error) => fatal(error));
+process.on("unhandledRejection", (error) => fatal(error));
+process.stdout.on("error", () => process.exit(1));
+process.stdin.on("error", fatal);
+const modules = new Map([
+    ["@raycast/api", import.meta.resolve("@blastlauncher/runtime/api")],
+    ...["react", "react/jsx-runtime", "react/jsx-dev-runtime"].map((name) => [
+        name,
+        import.meta.resolve(name),
+    ]),
+]);
+registerHooks({
+    resolve(specifier, context, nextResolve) {
+        const url = modules.get(specifier);
+        return url ? { url, shortCircuit: true } : nextResolve(specifier, context);
+    },
+});
+const root = createSceneRoot({
+    publish: (scene) => send({ type: "scene", ...scene }),
+    onWarning: (message) => log("warn", [message]),
+    onError: fatal,
+});
+setCapabilityRequester((name, params, options = {}) => {
+    if (options.signal?.aborted)
+        return Promise.reject(new DOMException("The operation was aborted", "AbortError"));
+    const id = String(nextRequest++);
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            reject(new DOMException("The operation was aborted", "AbortError"));
+            send({ type: "capability.cancel", id });
+        };
+        pending.set(id, {
+            resolve,
+            reject,
+            progress: (value) => {
+                if (!options.signal?.aborted)
+                    options.onProgress?.(value);
+            },
+            cleanup: () => options.signal?.removeEventListener("abort", abort),
+        });
+        options.signal?.addEventListener("abort", abort, { once: true });
+        send({ type: "capability.request", id, name, params });
+    });
+});
+// `captureException` and `captureMemorySnapshot` report diagnostics through the
+// protocol's log channel; the runtime owns no other reporter.
+setRuntimeLogSink((level, message) => log(level, [message]));
+function loadingFallback(mode) {
+    return mode === "menu-bar"
+        ? createElement("MenuBarExtra", { isLoading: true })
+        : createElement("List", { isLoading: true });
+}
+function withSuspense(element, mode) {
+    return createElement(Suspense, { fallback: loadingFallback(mode) }, element);
+}
+/**
+ * Launch props for this command: the manifest arguments the host resolved and,
+ * when another command started it, the `launchCommand` context. Blast only
+ * launches user initiated commands (background launch is out of scope).
+ */
+function launchProps(command) {
+    return {
+        arguments: command.arguments ?? {},
+        launchType: LaunchType.UserInitiated,
+        ...(command.draftValues === undefined
+            ? {}
+            : { draftValues: decodeFormValues(command.draftValues) }),
+        ...(command.fallbackText === undefined ? {} : { fallbackText: command.fallbackText }),
+        ...(command.launchContext === undefined ? {} : { launchContext: command.launchContext }),
+    };
+}
+async function load(message) {
+    setEnvironment(message.environment, message.command);
+    setPreferenceValues(message.preferences);
+    const props = launchProps(message.command);
+    setFormDraftValues(props.draftValues);
+    // Legacy commands call `render(element)` while the module is being imported;
+    // that element becomes the command root instead of a default export.
+    let rendered = false;
+    setRenderMount((element) => {
+        if (rendered)
+            return;
+        rendered = true;
+        root.render(message.command.mode === "menu-bar"
+            ? withSuspense(element, message.command.mode)
+            : createElement(NavigationProvider, {
+                children: withSuspense(element, message.command.mode),
+            }));
+        loaded = true;
+    });
+    const command = await import(__rewriteRelativeImportExtension(pathToFileURL(message.command.entry).href));
+    setRenderMount(undefined);
+    if (stopping)
+        return;
+    if (rendered)
+        return;
+    if (message.command.mode === "model-provider") {
+        provider = createModelProvider(command, send);
+        return;
+    }
+    if (message.command.mode === "no-view") {
+        setFeedbackMount(() => {
+            if (!loaded) {
+                loaded = true;
+                root.render(createElement(NavigationProvider, { children: null }));
+            }
+        });
+        // A no-view command runs until it settles, with a scene only for feedback.
+        // A rejection is a fatal error through the caller's `.catch`.
+        await command.default(props);
+        if (stopping)
+            return;
+        finish(0);
+        return;
+    }
+    // Call inside React so ordinary view commands retain hooks and navigation.
+    // A thenable is a command body, never a suspending React component (0004).
+    let running = false;
+    function Command() {
+        if (running)
+            return null;
+        const result = command.default(props);
+        if (result !== null &&
+            (typeof result === "object" || typeof result === "function") &&
+            "then" in result &&
+            typeof result.then === "function") {
+            running = true;
+            void Promise.resolve(result).then(() => finish(0), fatal);
+            return null;
+        }
+        return result;
+    }
+    const wrap = message.command.mode === "view" &&
+        typeof command.default === "function" &&
+        !command.default.prototype?.isReactComponent;
+    const element = createElement(wrap ? Command : command.default, props);
+    const suspended = withSuspense(element, message.command.mode);
+    root.render(message.command.mode === "menu-bar"
+        ? suspended
+        : createElement(NavigationProvider, { children: suspended }));
+    loaded = true;
+}
+function shutdown() {
+    if (stopping)
+        return;
+    try {
+        root.unmount();
+        void flushFormPersistence().then(() => finish(0), fatal);
+    }
+    catch (error) {
+        fatal(error);
+    }
+}
+function handle(value) {
+    if (stopping)
+        return;
+    const parsed = parseHostMessage(value);
+    if (!parsed.ok)
+        return fatal(parsed.error, "PROTOCOL_ERROR");
+    const message = parsed.message;
+    if (!initialized) {
+        if (message.type !== "init" || message.protocol !== PROTOCOL_VERSION) {
+            return fatal(`Expected init with protocol ${PROTOCOL_VERSION}`, "PROTOCOL_ERROR");
+        }
+        initialized = true;
+        send({ type: "ready", protocol: PROTOCOL_VERSION });
+        providerLoad = load(message);
+        void providerLoad.catch(fatal);
+        return;
+    }
+    switch (message.type) {
+        case "provider.getModels":
+        case "provider.stream":
+        case "provider.abort":
+            void providerLoad
+                ?.then(() => {
+                if (!provider)
+                    return fatal("Provider request in command session", "PROTOCOL_ERROR");
+                provider.handle(message);
+            })
+                .catch(fatal);
+            return;
+        case "init":
+            return fatal("Duplicate init", "PROTOCOL_ERROR");
+        case "shutdown":
+            return shutdown();
+        case "capability.progress": {
+            const request = pending.get(message.id);
+            if (!request)
+                return fatal(`Unknown capability id: ${message.id}`, "PROTOCOL_ERROR");
+            request.progress?.(message.value);
+            return;
+        }
+        case "capability.result": {
+            const request = pending.get(message.id);
+            if (!request)
+                return fatal(`Unknown capability id: ${message.id}`, "PROTOCOL_ERROR");
+            pending.delete(message.id);
+            request.cleanup();
+            if (message.ok)
+                request.resolve(message.value);
+            else
+                request.reject(Object.assign(new Error(message.error.message), { code: message.error.code }));
+            return;
+        }
+        case "event": {
+            if (!loaded)
+                return fatal("Event before command loaded", "PROTOCOL_ERROR");
+            const failed = (error) => {
+                if (error instanceof UnsupportedApiError)
+                    fatal(error);
+                else
+                    send({ type: "error", code: "EVENT_ERROR", message: errorMessage(error), fatal: false });
+            };
+            try {
+                // Do not await: a handler can be waiting for a capability.result on stdin.
+                void Promise.resolve(root.dispatch(message.node, message.handler, message.args)).catch(failed);
+            }
+            catch (error) {
+                failed(error);
+            }
+            try {
+                root.flush();
+            }
+            catch (error) {
+                fatal(error);
+            }
+        }
+    }
+}
+const decoder = createLineDecoder({
+    onLine: handle,
+    onError: (error) => fatal(error, "PROTOCOL_ERROR"),
+});
+process.stdin.on("data", (chunk) => decoder.push(chunk));
+process.stdin.on("end", () => {
+    decoder.end();
+    shutdown();
+});

package/dist/provider.d.ts

@@ -0,0 +1,8 @@
+import type { AI } from "./api/index.js";
+import { type ProviderRequest, type ProviderResponse } from "@blastlauncher/protocol";
+export declare function createModelProvider(exports: {
+    getModels?: AI.GetModels;
+    streamCompletion?: AI.StreamCompletion;
+}, send: (message: ProviderResponse) => void): {
+    handle(message: ProviderRequest): void;
+};

package/dist/provider.js

@@ -0,0 +1,107 @@
+import { decodeModelRequest, parseRuntimeMessage, } from "@blastlauncher/protocol";
+export function createModelProvider(exports, send) {
+    if (typeof exports.getModels !== "function" || typeof exports.streamCompletion !== "function")
+        throw new Error("Model provider requires named getModels and streamCompletion exports");
+    // Providers may attach private metadata; only the public model crosses the wire.
+    const modelFields = [
+        "id",
+        "title",
+        "isLocal",
+        "icon",
+        "description",
+        "capabilities",
+        "contextWindow",
+        "sizeInBytes",
+    ];
+    const active = new Map();
+    function emit(message) {
+        const parsed = parseRuntimeMessage(JSON.parse(JSON.stringify(message)));
+        if (!parsed.ok)
+            throw new Error(parsed.error);
+        send(parsed.message);
+    }
+    async function run(message) {
+        const state = { cancelled: false };
+        if (active.has(message.id))
+            throw new Error("Duplicate provider request id");
+        active.set(message.id, state);
+        try {
+            if (message.type === "provider.getModels") {
+                const models = await exports.getModels();
+                if (!state.cancelled)
+                    emit({
+                        type: "provider.models",
+                        id: message.id,
+                        models: models.map((model) => Object.fromEntries(modelFields
+                            .filter((key) => Object.hasOwn(model, key))
+                            .map((key) => [key, model[key]]))),
+                    });
+            }
+            else {
+                const result = await exports.streamCompletion(message.model, decodeModelRequest(message.request));
+                const stream = "fullStream" in result
+                    ? result.fullStream
+                    : "textStream" in result
+                        ? result.textStream
+                        : result;
+                const iterator = stream[Symbol.asyncIterator]();
+                state.iterator = iterator;
+                if (state.cancelled) {
+                    void Promise.resolve()
+                        .then(() => iterator.return?.())
+                        .catch(() => undefined);
+                    return;
+                }
+                while (!state.cancelled) {
+                    const next = await iterator.next();
+                    if (state.cancelled || next.done)
+                        break;
+                    emit({
+                        type: "provider.part",
+                        id: message.id,
+                        part: typeof next.value === "string"
+                            ? { type: "text-delta", textDelta: next.value }
+                            : next.value,
+                    });
+                }
+                if (!state.cancelled)
+                    emit({ type: "provider.end", id: message.id });
+            }
+        }
+        catch (error) {
+            if (!state.cancelled)
+                send({
+                    type: "provider.error",
+                    id: message.id,
+                    error: {
+                        code: "PROVIDER_ERROR",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+        }
+        finally {
+            active.delete(message.id);
+        }
+    }
+    return {
+        handle(message) {
+            if (message.type === "provider.abort") {
+                const state = active.get(message.id);
+                if (state) {
+                    state.cancelled = true;
+                    // A blocked producer need not cooperate; stop publishing immediately.
+                    void Promise.resolve()
+                        .then(() => state.iterator?.return?.())
+                        .catch(() => undefined);
+                    active.delete(message.id);
+                }
+                return;
+            }
+            void run(message).catch((error) => send({
+                type: "provider.error",
+                id: message.id,
+                error: { code: "PROVIDER_ERROR", message: String(error) },
+            }));
+        },
+    };
+}

package/dist/reconciler/index.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { SceneRootOptions } from "./types.js";
+export type { JsonValue, SceneNode, SceneRootOptions, SceneSnapshot } from "./types.js";
+export declare function createSceneRoot({ publish, onWarning, onError }: SceneRootOptions): {
+    render: (element: ReactNode) => void;
+    unmount(): void;
+    dispatch(nodeId: string, handler: string, args: unknown[]): unknown;
+    flush: () => void;
+};

package/dist/reconciler/index.js

@@ -0,0 +1,186 @@
+import { createContext } from "react";
+import Reconciler from "react-reconciler";
+import { ConcurrentRoot, DiscreteEventPriority, NoEventPriority, } from "react-reconciler/constants.js";
+import { serializeProps } from "./serialize.js";
+function remove(parent, child) {
+    const index = parent.children.indexOf(child);
+    if (index !== -1)
+        parent.children.splice(index, 1);
+}
+function insert(parent, child, before) {
+    remove(parent, child);
+    const index = before ? parent.children.indexOf(before) : -1;
+    parent.children.splice(index === -1 ? parent.children.length : index, 0, child);
+}
+function instance(container, type, props) {
+    return { id: String(container.nextId++), type, props, children: [], hidden: false };
+}
+const noop = () => { };
+let priority = NoEventPriority;
+const config = {
+    rendererVersion: "0.0.0",
+    rendererPackageName: "@blastlauncher/runtime",
+    extraDevToolsConfig: null,
+    bindToConsole: (_method, args) => () => console.log(...args),
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    isPrimaryRenderer: true,
+    getRootHostContext: () => ({}),
+    getChildHostContext: (context) => context,
+    getPublicInstance: (node) => node,
+    createInstance: (type, props, container) => instance(container, type, props),
+    createTextInstance: (text, container) => instance(container, "#text", { text }),
+    appendInitialChild: insert,
+    appendChild: insert,
+    appendChildToContainer: insert,
+    insertBefore: insert,
+    insertInContainerBefore: insert,
+    removeChild: remove,
+    removeChildFromContainer: remove,
+    finalizeInitialChildren: () => false,
+    shouldSetTextContent: () => false,
+    prepareForCommit: () => null,
+    resetAfterCommit: (container) => container.commit(),
+    commitUpdate: (node, _type, _old, props) => {
+        node.props = props;
+    },
+    commitTextUpdate: (node, _old, text) => {
+        node.props = { text };
+    },
+    clearContainer: (container) => {
+        container.children = [];
+    },
+    hideInstance: (node) => {
+        node.hidden = true;
+    },
+    hideTextInstance: (node) => {
+        node.hidden = true;
+    },
+    unhideInstance: (node) => {
+        node.hidden = false;
+    },
+    unhideTextInstance: (node) => {
+        node.hidden = false;
+    },
+    scheduleTimeout: setTimeout,
+    cancelTimeout: clearTimeout,
+    noTimeout: -1,
+    supportsMicrotasks: true,
+    scheduleMicrotask: queueMicrotask,
+    preparePortalMount: noop,
+    getInstanceFromNode: () => null,
+    beforeActiveInstanceBlur: noop,
+    afterActiveInstanceBlur: noop,
+    prepareScopeUpdate: noop,
+    getInstanceFromScope: () => null,
+    detachDeletedInstance: noop,
+    NotPendingTransition: null,
+    HostTransitionContext: createContext(null),
+    setCurrentUpdatePriority: (next) => {
+        priority = next;
+    },
+    getCurrentUpdatePriority: () => priority,
+    // All ordinary updates use the sync lane so flush() needs no timers.
+    resolveUpdatePriority: () => priority || DiscreteEventPriority,
+    resetFormInstance: noop,
+    requestPostPaintCallback: (callback) => callback(performance.now()),
+    shouldAttemptEagerTransition: () => false,
+    trackSchedulerEvent: noop,
+    resolveEventType: () => null,
+    resolveEventTimeStamp: () => performance.now(),
+    maySuspendCommit: () => false,
+    maySuspendCommitOnUpdate: () => false,
+    maySuspendCommitInSyncRender: () => false,
+    preloadInstance: () => true,
+    startSuspendingCommit: () => null,
+    suspendInstance: noop,
+    suspendOnActiveViewTransition: noop,
+    waitForCommitToBeReady: () => null,
+    getSuspendedCommitReason: () => null,
+};
+const renderer = Reconciler(config);
+export function createSceneRoot({ publish, onWarning = noop, onError }) {
+    let revision = 0;
+    let handlers = new Map();
+    const errors = [];
+    // Errors raised while serializing or publishing a commit. Throwing inside
+    // React's commit phase corrupts the reconciler for every later root in the
+    // process, so they are held here and reported once React has finished.
+    const commitErrors = [];
+    function drainCommitErrors() {
+        for (const error of commitErrors.splice(0))
+            reportError(error);
+    }
+    const container = {
+        children: [],
+        nextId: 1,
+        commit() {
+            try {
+                commitSnapshot();
+            }
+            catch (error) {
+                commitErrors.push(error);
+                // Async updates are not followed by flush(); report them on a microtask.
+                queueMicrotask(drainCommitErrors);
+            }
+        },
+    };
+    function commitSnapshot() {
+        const nextHandlers = new Map();
+        function snapshot(node) {
+            const callbacks = new Map();
+            const props = serializeProps(node.type, node.props, callbacks, onWarning);
+            nextHandlers.set(node.id, callbacks);
+            return {
+                id: node.id,
+                type: node.type,
+                props,
+                // Covered navigation views remain mounted, but cannot receive client events.
+                children: node.type === "Navigation.Entry" && node.props.active === false
+                    ? []
+                    : node.children.filter((child) => !child.hidden).map(snapshot),
+            };
+        }
+        const children = container.children.filter((child) => !child.hidden).map(snapshot);
+        // A fragment with multiple top-level nodes needs a serializable parent.
+        const root = children.length > 1 ? { id: "0", type: "#root", props: {}, children } : (children[0] ?? null);
+        handlers = nextHandlers;
+        publish({ revision: ++revision, root });
+    }
+    function reportError(error) {
+        if (onError)
+            onError(error);
+        else
+            errors.push(error);
+    }
+    const root = renderer.createContainer(container, ConcurrentRoot, null, false, null, "", reportError, renderer.defaultOnCaughtError, reportError, noop, null);
+    function flush() {
+        renderer.flushSyncWork();
+        while (renderer.flushPassiveEffects())
+            renderer.flushSyncWork();
+        drainCommitErrors();
+        if (errors.length)
+            throw errors.shift();
+    }
+    function render(element) {
+        renderer.updateContainerSync(element, root, null, null);
+        flush();
+    }
+    return {
+        render,
+        unmount() {
+            render(null);
+        },
+        dispatch(nodeId, handler, args) {
+            const callbacks = handlers.get(nodeId);
+            if (!callbacks)
+                throw new Error(`Unknown scene node: ${nodeId}`);
+            const callback = callbacks.get(handler);
+            if (!callback)
+                throw new Error(`Unknown handler ${handler} on scene node ${nodeId}`);
+            return callback(...args);
+        },
+        flush,
+    };
+}

package/dist/reconciler/serialize.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from "./types.js";
+export type Handler = (...args: unknown[]) => unknown;
+export declare function serializeProps(type: string, props: Record<string, unknown>, handlers: Map<string, Handler>, warn: (message: string) => void): Record<string, JsonValue>;