@matrix-ai/sdk 1.6.0 → 1.6.2

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 export * from "./gen/types.gen.js";
 import { type Config } from "./gen/client/types.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export { type Config as OpencodeClientConfig, OpencodeClient };
-export declare function createOpencodeClient(config?: Config & {
+import { MatrixClient } from "./gen/sdk.gen.js";
+export { type Config as MatrixClientConfig, MatrixClient };
+export declare function createMatrixClient(config?: Config & {
     directory?: string;
-}): OpencodeClient;
+}): MatrixClient;

package/dist/client.js

@@ -1,8 +1,33 @@
 export * from "./gen/types.gen.js";
 import { createClient } from "./gen/client/client.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export { OpencodeClient };
-export function createOpencodeClient(config) {
+import { MatrixClient } from "./gen/sdk.gen.js";
+export { MatrixClient };
+function pick(value, fallback) {
+    if (!value)
+        return;
+    if (!fallback)
+        return value;
+    if (value === fallback)
+        return fallback;
+    if (value === encodeURIComponent(fallback))
+        return fallback;
+    return value;
+}
+function rewrite(request, directory) {
+    if (request.method !== "GET" && request.method !== "HEAD")
+        return request;
+    const value = pick(request.headers.get("x-matrix-directory"), directory);
+    if (!value)
+        return request;
+    const url = new URL(request.url);
+    if (!url.searchParams.has("directory")) {
+        url.searchParams.set("directory", value);
+    }
+    const next = new Request(url, request);
+    next.headers.delete("x-matrix-directory");
+    return next;
+}
+export function createMatrixClient(config) {
     if (!config?.fetch) {
         const customFetch = (req) => {
             // @ts-ignore
@@ -17,9 +42,10 @@ export function createOpencodeClient(config) {
     if (config?.directory) {
         config.headers = {
             ...config.headers,
-            "x-opencode-directory": encodeURIComponent(config.directory),
+            "x-matrix-directory": encodeURIComponent(config.directory),
         };
     }
     const client = createClient(config);
-    return new OpencodeClient({ client });
+    client.interceptors.request.use((request) => rewrite(request, config?.directory));
+    return new MatrixClient({ client });
 }

package/dist/gen/sdk.gen.d.ts

@@ -374,7 +374,7 @@ declare class Event extends _HeyApiClient {
      */
     subscribe<ThrowOnError extends boolean = false>(options?: Options<EventSubscribeData, ThrowOnError>): Promise<import("./core/serverSentEvents.gen.js").ServerSentEventsResult<EventSubscribeResponses, unknown>>;
 }
-export declare class OpencodeClient extends _HeyApiClient {
+export declare class MatrixClient extends _HeyApiClient {
     /**
      * Respond to a permission request
      */

package/dist/gen/sdk.gen.js

@@ -844,7 +844,7 @@ class Event extends _HeyApiClient {
         });
     }
 }
-export class OpencodeClient extends _HeyApiClient {
+export class MatrixClient extends _HeyApiClient {
     /**
      * Respond to a permission request
      */

package/dist/gen/types.gen.d.ts

@@ -1050,7 +1050,7 @@ export type Config = {
         diff_style?: "auto" | "stacked";
     };
     /**
-     * Command configuration, see https://opencode.ai/docs/commands
+     * Command configuration, see https://y-square-t3.github.io/matrix/docs/commands
      */
     command?: {
         [key: string]: {
@@ -1107,7 +1107,7 @@ export type Config = {
         [key: string]: AgentConfig | undefined;
     };
     /**
-     * Agent configuration, see https://opencode.ai/docs/agent
+     * Agent configuration, see https://y-square-t3.github.io/matrix/docs/agent
      */
     agent?: {
         plan?: AgentConfig;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export * from "./client.js";
 export * from "./server.js";
 import type { ServerOptions } from "./server.js";
-export declare function createOpencode(options?: ServerOptions): Promise<{
-    client: import("./client.js").OpencodeClient;
+export declare function createMatrix(options?: ServerOptions): Promise<{
+    client: import("./client.js").MatrixClient;
     server: {
         url: string;
         close(): void;

package/dist/index.js

@@ -1,12 +1,12 @@
 export * from "./client.js";
 export * from "./server.js";
-import { createOpencodeClient } from "./client.js";
-import { createOpencodeServer } from "./server.js";
-export async function createOpencode(options) {
-    const server = await createOpencodeServer({
+import { createMatrixClient } from "./client.js";
+import { createMatrixServer } from "./server.js";
+export async function createMatrix(options) {
+    const server = await createMatrixServer({
         ...options,
     });
-    const client = createOpencodeClient({
+    const client = createMatrixClient({
         baseUrl: server.url,
     });
     return {

package/dist/process.d.ts

@@ -0,0 +1,3 @@
+import { type ChildProcess } from "node:child_process";
+export declare function stop(proc: ChildProcess): void;
+export declare function bindAbort(proc: ChildProcess, signal?: AbortSignal, onAbort?: () => void): () => void;

package/dist/process.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+// Duplicated from `packages/matrix/src/util/process.ts` because the SDK cannot
+// import `matrix` without creating a cycle (`matrix` depends on `@matrix-ai/sdk`).
+export function stop(proc) {
+    if (proc.exitCode !== null || proc.signalCode !== null)
+        return;
+    if (process.platform === "win32" && proc.pid) {
+        const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
+        if (!out.error && out.status === 0)
+            return;
+    }
+    proc.kill();
+}
+export function bindAbort(proc, signal, onAbort) {
+    if (!signal)
+        return () => { };
+    const abort = () => {
+        clear();
+        stop(proc);
+        onAbort?.();
+    };
+    const clear = () => {
+        signal.removeEventListener("abort", abort);
+        proc.off("exit", clear);
+        proc.off("error", clear);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    proc.on("exit", clear);
+    proc.on("error", clear);
+    if (signal.aborted)
+        abort();
+    return clear;
+}

package/dist/server.d.ts

@@ -14,10 +14,10 @@ export type TuiOptions = {
     signal?: AbortSignal;
     config?: Config;
 };
-export declare function createOpencodeServer(options?: ServerOptions): Promise<{
+export declare function createMatrixServer(options?: ServerOptions): Promise<{
     url: string;
     close(): void;
 }>;
-export declare function createOpencodeTui(options?: TuiOptions): {
+export declare function createMatrixTui(options?: TuiOptions): {
     close(): void;
 };

package/dist/server.js

@@ -1,5 +1,6 @@
-import { spawn } from "node:child_process";
-export async function createOpencodeServer(options) {
+import launch from "cross-spawn";
+import { stop, bindAbort } from "./process.js";
+export async function createMatrixServer(options) {
     options = Object.assign({
         hostname: "127.0.0.1",
         port: 4096,
@@ -8,28 +9,38 @@ export async function createOpencodeServer(options) {
     const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
     if (options.config?.logLevel)
         args.push(`--log-level=${options.config.logLevel}`);
-    const proc = spawn(`opencode`, args, {
-        signal: options.signal,
+    const proc = launch(`matrix`, args, {
         env: {
             ...process.env,
-            OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
+            MATRIX_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
         },
     });
+    let clear = () => { };
     const url = await new Promise((resolve, reject) => {
         const id = setTimeout(() => {
+            clear();
+            stop(proc);
             reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
         }, options.timeout);
         let output = "";
+        let resolved = false;
         proc.stdout?.on("data", (chunk) => {
+            if (resolved)
+                return;
             output += chunk.toString();
             const lines = output.split("\n");
             for (const line of lines) {
-                if (line.startsWith("opencode server listening")) {
+                if (line.startsWith("matrix server listening")) {
                     const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
                     if (!match) {
-                        throw new Error(`Failed to parse server url from output: ${line}`);
+                        clear();
+                        stop(proc);
+                        clearTimeout(id);
+                        reject(new Error(`Failed to parse server url from output: ${line}`));
+                        return;
                     }
                     clearTimeout(id);
+                    resolved = true;
                     resolve(match[1]);
                     return;
                 }
@@ -50,21 +61,20 @@ export async function createOpencodeServer(options) {
             clearTimeout(id);
             reject(error);
         });
-        if (options.signal) {
-            options.signal.addEventListener("abort", () => {
-                clearTimeout(id);
-                reject(new Error("Aborted"));
-            });
-        }
+        clear = bindAbort(proc, options.signal, () => {
+            clearTimeout(id);
+            reject(options.signal?.reason);
+        });
     });
     return {
         url,
         close() {
-            proc.kill();
+            clear();
+            stop(proc);
         },
     };
 }
-export function createOpencodeTui(options) {
+export function createMatrixTui(options) {
     const args = [];
     if (options?.project) {
         args.push(`--project=${options.project}`);
@@ -78,17 +88,18 @@ export function createOpencodeTui(options) {
     if (options?.agent) {
         args.push(`--agent=${options.agent}`);
     }
-    const proc = spawn(`opencode`, args, {
-        signal: options?.signal,
+    const proc = launch(`matrix`, args, {
         stdio: "inherit",
         env: {
             ...process.env,
-            OPENCODE_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
+            MATRIX_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
         },
     });
+    const clear = bindAbort(proc, options?.signal);
     return {
         close() {
-            proc.kill();
+            clear();
+            stop(proc);
         },
     };
 }

package/dist/v2/client.d.ts

@@ -1,8 +1,8 @@
 export * from "./gen/types.gen.js";
 import { type Config } from "./gen/client/types.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export { type Config as OpencodeClientConfig, OpencodeClient };
-export declare function createOpencodeClient(config?: Config & {
+import { MatrixClient } from "./gen/sdk.gen.js";
+export { type Config as MatrixClientConfig, MatrixClient };
+export declare function createMatrixClient(config?: Config & {
     directory?: string;
     experimental_workspaceID?: string;
-}): OpencodeClient;
+}): MatrixClient;

package/dist/v2/client.js

@@ -1,8 +1,43 @@
 export * from "./gen/types.gen.js";
 import { createClient } from "./gen/client/client.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export { OpencodeClient };
-export function createOpencodeClient(config) {
+import { MatrixClient } from "./gen/sdk.gen.js";
+export { MatrixClient };
+function pick(value, fallback, encode) {
+    if (!value)
+        return;
+    if (!fallback)
+        return value;
+    if (value === fallback)
+        return fallback;
+    if (encode && value === encode(fallback))
+        return fallback;
+    return value;
+}
+function rewrite(request, values) {
+    if (request.method !== "GET" && request.method !== "HEAD")
+        return request;
+    const url = new URL(request.url);
+    let changed = false;
+    for (const [name, key] of [
+        ["x-matrix-directory", "directory"],
+        ["x-matrix-workspace", "workspace"],
+    ]) {
+        const value = pick(request.headers.get(name), key === "directory" ? values.directory : values.workspace, key === "directory" ? encodeURIComponent : undefined);
+        if (!value)
+            continue;
+        if (!url.searchParams.has(key)) {
+            url.searchParams.set(key, value);
+        }
+        changed = true;
+    }
+    if (!changed)
+        return request;
+    const next = new Request(url, request);
+    next.headers.delete("x-matrix-directory");
+    next.headers.delete("x-matrix-workspace");
+    return next;
+}
+export function createMatrixClient(config) {
     if (!config?.fetch) {
         const customFetch = (req) => {
             // @ts-ignore
@@ -15,19 +50,21 @@ export function createOpencodeClient(config) {
         };
     }
     if (config?.directory) {
-        const isNonASCII = /[^\x00-\x7F]/.test(config.directory);
-        const encodedDirectory = isNonASCII ? encodeURIComponent(config.directory) : config.directory;
         config.headers = {
             ...config.headers,
-            "x-opencode-directory": encodedDirectory,
+            "x-matrix-directory": encodeURIComponent(config.directory),
         };
     }
     if (config?.experimental_workspaceID) {
         config.headers = {
             ...config.headers,
-            "x-opencode-workspace": config.experimental_workspaceID,
+            "x-matrix-workspace": config.experimental_workspaceID,
         };
     }
     const client = createClient(config);
-    return new OpencodeClient({ client });
+    client.interceptors.request.use((request) => rewrite(request, {
+        directory: config?.directory,
+        workspace: config?.experimental_workspaceID,
+    }));
+    return new MatrixClient({ client });
 }