gpui-bridge 0.0.0-stage → 0.3.0

package/dist/host-process.d.ts

@@ -0,0 +1,18 @@
+import type { HostEvents, HostTransport } from "./app.js";
+import type { ClientMessage } from "./protocol.js";
+export interface HostProcessOptions extends HostEvents {
+    path: string;
+    args: string[];
+    debug: boolean;
+}
+export declare class HostProcess implements HostTransport {
+    private readonly child;
+    private readonly stderrTail;
+    private exited;
+    constructor(options: HostProcessOptions);
+    get running(): boolean;
+    send(message: ClientMessage): void;
+    /** Closes stdin; the host exits on EOF. */
+    close(): void;
+    kill(): void;
+}

package/dist/host-process.js

@@ -0,0 +1,56 @@
+// Spawns the host binary and speaks JSON Lines over its stdin/stdout.
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+const STDERR_TAIL_LINES = 20;
+export class HostProcess {
+    child;
+    stderrTail = [];
+    exited = false;
+    constructor(options) {
+        this.child = spawn(options.path, options.args, { stdio: ["pipe", "pipe", "pipe"] });
+        createInterface({ input: this.child.stdout }).on("line", (line) => {
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                options.onCorruptLine(line);
+                return;
+            }
+            options.onMessage(message);
+        });
+        createInterface({ input: this.child.stderr }).on("line", (line) => {
+            this.stderrTail.push(line);
+            if (this.stderrTail.length > STDERR_TAIL_LINES)
+                this.stderrTail.shift();
+            if (options.debug)
+                console.error(`[host] ${line}`);
+        });
+        // Writes racing a dying host fail with EPIPE; the exit handler reports the real cause.
+        this.child.stdin.on("error", () => { });
+        const finish = (exit) => {
+            if (this.exited)
+                return;
+            this.exited = true;
+            options.onExit({ ...exit, stderrTail: [...this.stderrTail] });
+        };
+        this.child.on("error", (spawnError) => finish({ code: null, signal: null, spawnError }));
+        // "close" (not "exit") so all stdout/stderr lines are delivered first.
+        this.child.on("close", (code, signal) => finish({ code, signal }));
+    }
+    get running() {
+        return !this.exited;
+    }
+    send(message) {
+        if (this.exited)
+            return;
+        this.child.stdin.write(JSON.stringify(message) + "\n");
+    }
+    /** Closes stdin; the host exits on EOF. */
+    close() {
+        this.child.stdin.end();
+    }
+    kill() {
+        this.child.kill();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { type App } from "./app.js";
+export * from "./app.js";
+export * from "./protocol.js";
+export interface AppOptions {
+    /** Host binary. Defaults to `$GPUI_BRIDGE_HOST`, then the platform package installed with this one, then the debug build in this repository. */
+    hostPath?: string;
+    /** Forward host logs (stderr) to the console. */
+    debug?: boolean;
+    /** Run the host without a window (`--no-window`), e.g. for tests. */
+    headless?: boolean;
+}
+/** The host to run: `$GPUI_BRIDGE_HOST`, then the packaged one, then a build in this repository. */
+export declare function defaultHostPath(): string;
+/** Starts the host and completes the handshake. Rejects with a clear message if the host cannot start. */
+export declare function createApp(options?: AppOptions): Promise<App>;

package/dist/index.js

@@ -0,0 +1,58 @@
+// Public API of the gpui-bridge Node client.
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { connect } from "./app.js";
+import { HostProcess } from "./host-process.js";
+export * from "./app.js";
+export * from "./protocol.js";
+const exe = process.platform === "win32" ? "gpui-bridge-host.exe" : "gpui-bridge-host";
+// dist/index.js -> the package root
+const pkg = join(dirname(fileURLToPath(import.meta.url)), "..");
+const nodeRequire = createRequire(import.meta.url);
+// The platform the host must run on, and the suffix of the package that ships it.
+const platform = `${process.platform}-${process.arch}`;
+/**
+ * Walks up from this file looking for a Cargo build of the host. The number of folders
+ * between a client and the workspace root is not part of the contract, so this survives
+ * a client moving inside `packages/` (or anywhere else).
+ */
+function repoTarget() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 6; depth++) {
+        for (const profile of ["debug", "release"]) {
+            const candidate = join(dir, "target", profile, exe);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        dir = dirname(dir);
+    }
+    return undefined;
+}
+/**
+ * The binary of `@indios/gpui-bridge-<platform>-<arch>`, an optional dependency of this package:
+ * npm and pnpm install only the one whose `os`/`cpu` match the machine, so whatever is
+ * installed here is a host this machine can run. That package carries no code, only the
+ * asset, so it is found through its manifest (it declares no `exports` to walk).
+ */
+function packagedHost() {
+    try {
+        const manifest = nodeRequire.resolve(`@indios/gpui-bridge-${platform}/package.json`);
+        const candidate = join(dirname(manifest), "bin", exe);
+        return existsSync(candidate) ? candidate : undefined;
+    }
+    catch {
+        return undefined; // another platform, or a checkout where the asset was never staged
+    }
+}
+/** The host to run: `$GPUI_BRIDGE_HOST`, then the packaged one, then a build in this repository. */
+export function defaultHostPath() {
+    return process.env.GPUI_BRIDGE_HOST ?? packagedHost() ?? repoTarget() ?? join(pkg, "..", "..", "..", "target", "debug", exe);
+}
+/** Starts the host and completes the handshake. Rejects with a clear message if the host cannot start. */
+export function createApp(options = {}) {
+    const path = options.hostPath ?? defaultHostPath();
+    const args = options.headless ? ["--no-window"] : [];
+    return connect(path, (events) => new HostProcess({ path, args, debug: options.debug ?? false, ...events }));
+}