opencode-ext-connector 0.5.0 → 0.7.0

package/dist/providers/xai/access-state.js

@@ -0,0 +1,118 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+const XaiAccessRecordSchema = z.discriminatedUnion("state", [
+    z
+        .object({
+        schema_version: z.literal(1),
+        provider: z.literal("xai"),
+        state: z.literal("ready"),
+        access: z.string().min(1),
+        expires: z.number().int().nonnegative(),
+    })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        schema_version: z.literal(1),
+        provider: z.literal("xai"),
+        state: z.literal("unavailable"),
+    })
+        .strict()
+        .readonly(),
+]);
+const UnavailableState = Object.freeze({ kind: "unavailable" });
+class XaiAccessStateInvariantError extends Error {
+    name = "XaiAccessStateInvariantError";
+    constructor() {
+        super("unexpected xAI access state");
+    }
+}
+function assertNeverAccessState(_state) {
+    throw new XaiAccessStateInvariantError();
+}
+function currentProcessUid() {
+    return typeof process.getuid === "function" ? process.getuid() : undefined;
+}
+async function openAccessFile(path) {
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    return {
+        stat: async () => {
+            const metadata = await handle.stat();
+            return {
+                regular: metadata.isFile(),
+                links: metadata.nlink,
+                mode: metadata.mode & 0o7777,
+                ownerUid: metadata.uid,
+            };
+        },
+        readText: () => handle.readFile("utf8"),
+        close: () => handle.close(),
+    };
+}
+export function resolveXaiAccessPath(env) {
+    const dataHome = env["XDG_DATA_HOME"];
+    if (dataHome !== undefined && dataHome.length > 0) {
+        return isAbsolute(dataHome) ? join(dataHome, "opencode", "xai-access.json") : null;
+    }
+    const home = env["HOME"];
+    return home !== undefined && home.length > 0 && isAbsolute(home)
+        ? join(home, ".local", "share", "opencode", "xai-access.json")
+        : null;
+}
+function parsedState(raw) {
+    const parsedJson = JSON.parse(raw);
+    const record = XaiAccessRecordSchema.safeParse(parsedJson);
+    if (!record.success)
+        return UnavailableState;
+    switch (record.data.state) {
+        case "ready":
+            return Object.freeze({
+                kind: "ready",
+                access: record.data.access,
+                expires: record.data.expires,
+            });
+        case "unavailable":
+            return UnavailableState;
+        default:
+            return assertNeverAccessState(record.data);
+    }
+}
+export async function readXaiAccessState(options) {
+    const path = resolveXaiAccessPath(options.env);
+    if (path === null)
+        return UnavailableState;
+    const openFile = options.openFile ?? openAccessFile;
+    let file;
+    try {
+        file = await openFile(path);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return UnavailableState;
+        throw error;
+    }
+    let state = UnavailableState;
+    try {
+        const metadata = await file.stat();
+        const runtimeUid = (options.currentUid ?? currentProcessUid)();
+        const ownerMatches = runtimeUid === undefined || metadata.ownerUid === runtimeUid;
+        if (metadata.regular && metadata.links === 1 && metadata.mode === 0o600 && ownerMatches) {
+            state = parsedState(await file.readText());
+        }
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+    }
+    try {
+        await file.close();
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return UnavailableState;
+        throw error;
+    }
+    return state;
+}

package/dist/providers/xai/authority-observer.d.ts

@@ -0,0 +1,13 @@
+import type { Clock } from "../../core/clock.js";
+import { type AsyncDisposableHandle } from "../../core/lifecycle.js";
+import type { ProcessSupervisor } from "../../core/process.js";
+export type XaiAuthorityObserverOptions = {
+    readonly enabled: boolean;
+    readonly clock: Clock;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly processSupervisor: ProcessSupervisor;
+    readonly pollMs?: number;
+    readonly retryMs?: number;
+    readonly readAuthFile?: (path: string) => Promise<string>;
+};
+export declare function createXaiAuthorityObserver(options: XaiAuthorityObserverOptions): AsyncDisposableHandle;

package/dist/providers/xai/authority-observer.js

@@ -0,0 +1,165 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { InvalidArgumentError, OperationCancelledError } from "../../core/errors.js";
+import { createAsyncDisposable } from "../../core/lifecycle.js";
+import { opencodeAuthJsonPaths } from "../../opencode/auth-store.js";
+const AUTH_SYNC_HELPER = "opensandbox-xai-auth-sync";
+const AUTH_SYNC_PATH = "/usr/local/bin:/usr/bin:/bin";
+const AuthRootSchema = z.record(z.string(), z.unknown());
+function errorCode(error) {
+    return "code" in error ? Reflect.get(error, "code") : undefined;
+}
+function commandEnvironment(env, home) {
+    const dataHome = env["XDG_DATA_HOME"];
+    return dataHome === undefined || dataHome.length === 0 || !isAbsolute(dataHome)
+        ? Object.freeze({ HOME: home, PATH: AUTH_SYNC_PATH })
+        : Object.freeze({ HOME: home, PATH: AUTH_SYNC_PATH, XDG_DATA_HOME: dataHome });
+}
+class XaiAuthorityInvariantError extends Error {
+    name = "XaiAuthorityInvariantError";
+    constructor() {
+        super("unexpected xAI authority state");
+    }
+}
+function assertNeverAuthorityState(_state) {
+    throw new XaiAuthorityInvariantError();
+}
+export function createXaiAuthorityObserver(options) {
+    const pollMs = options.pollMs ?? 1_000;
+    const retryMs = options.retryMs ?? 5_000;
+    if (!Number.isSafeInteger(pollMs) || pollMs <= 0)
+        throw new InvalidArgumentError("pollMs");
+    if (!Number.isSafeInteger(retryMs) || retryMs <= 0)
+        throw new InvalidArgumentError("retryMs");
+    if (!options.enabled)
+        return createAsyncDisposable(() => undefined);
+    const home = options.env["HOME"];
+    if (home === undefined || home.length === 0 || !isAbsolute(home)) {
+        return createAsyncDisposable(() => undefined);
+    }
+    const dataHome = options.env["XDG_DATA_HOME"];
+    if (dataHome !== undefined && dataHome.length > 0 && !isAbsolute(dataHome)) {
+        return createAsyncDisposable(() => undefined);
+    }
+    const [authPath] = opencodeAuthJsonPaths(options.env);
+    if (authPath === undefined || !isAbsolute(authPath))
+        return createAsyncDisposable(() => undefined);
+    const helper = join(home, ".local", "bin", AUTH_SYNC_HELPER);
+    const environment = commandEnvironment(options.env, home);
+    const loadAuth = options.readAuthFile ?? ((path) => readFile(path, "utf8"));
+    const controller = new AbortController();
+    let scheduled;
+    let activeProcess;
+    let activeEvaluation;
+    let synchronizedFingerprint;
+    let disposalStarted = false;
+    const arm = (delayMs) => {
+        if (disposalStarted)
+            return;
+        scheduled?.cancel();
+        scheduled = options.clock.schedule(delayMs, () => {
+            scheduled = undefined;
+            startEvaluation();
+        });
+    };
+    const observe = async () => {
+        let raw;
+        try {
+            raw = await loadAuth(authPath);
+        }
+        catch (error) {
+            if (error instanceof Error && errorCode(error) === "ENOENT") {
+                return { kind: "ready", fingerprint: "null" };
+            }
+            if (error instanceof Error)
+                return { kind: "retry" };
+            throw error;
+        }
+        try {
+            const parsedJson = JSON.parse(raw);
+            const root = AuthRootSchema.safeParse(parsedJson);
+            return root.success
+                ? { kind: "ready", fingerprint: JSON.stringify(root.data["xai"] ?? null) }
+                : { kind: "retry" };
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return { kind: "retry" };
+            throw error;
+        }
+    };
+    const invoke = async () => {
+        const process = await options.processSupervisor.start({ executable: helper, arguments: [], cwd: null, environment }, controller.signal);
+        activeProcess = process;
+        try {
+            const exit = await process.wait(controller.signal);
+            switch (exit.kind) {
+                case "code":
+                    return exit.code === 0;
+                case "signal":
+                    return false;
+                default:
+                    return assertNeverAuthorityState(exit);
+            }
+        }
+        finally {
+            activeProcess = undefined;
+            await process.dispose();
+        }
+    };
+    const evaluate = async () => {
+        const observation = await observe();
+        if (disposalStarted)
+            return;
+        switch (observation.kind) {
+            case "retry":
+                arm(retryMs);
+                return;
+            case "ready":
+                if (observation.fingerprint === synchronizedFingerprint) {
+                    arm(pollMs);
+                    return;
+                }
+                if (await invoke())
+                    synchronizedFingerprint = observation.fingerprint;
+                if (!disposalStarted) {
+                    arm(observation.fingerprint === synchronizedFingerprint ? pollMs : retryMs);
+                }
+                return;
+            default:
+                return assertNeverAuthorityState(observation);
+        }
+    };
+    const startEvaluation = () => {
+        if (disposalStarted || activeEvaluation !== undefined)
+            return;
+        const operation = evaluate().catch((error) => {
+            if (error instanceof OperationCancelledError && disposalStarted)
+                return;
+            if (error instanceof Error) {
+                arm(retryMs);
+                return;
+            }
+            throw error;
+        });
+        activeEvaluation = operation;
+        void operation.then(() => {
+            if (activeEvaluation === operation)
+                activeEvaluation = undefined;
+        }, () => {
+            if (activeEvaluation === operation)
+                activeEvaluation = undefined;
+        });
+    };
+    const disposal = createAsyncDisposable(async () => {
+        disposalStarted = true;
+        scheduled?.cancel();
+        scheduled = undefined;
+        controller.abort();
+        await activeProcess?.terminate();
+        await activeEvaluation;
+    });
+    startEvaluation();
+    return { dispose: disposal.dispose, [Symbol.asyncDispose]: disposal[Symbol.asyncDispose] };
+}

package/dist/providers/xai/consumer-auth.d.ts

@@ -0,0 +1,23 @@
+import type { Clock } from "../../core/clock.js";
+export type NetworkFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type XaiConsumerAuthOptions = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly clock: Clock;
+    readonly networkFetch: NetworkFetch;
+};
+export type XaiConsumerAuthHook = {
+    readonly provider: "xai";
+    readonly loader: (getAuth: () => Promise<unknown>) => Promise<{
+        readonly apiKey: string;
+        readonly fetch: NetworkFetch;
+    } | {
+        readonly apiKey?: never;
+        readonly fetch?: never;
+    }>;
+    readonly methods: [];
+};
+export declare class XaiAccessUnavailableError extends Error {
+    readonly name = "XaiAccessUnavailableError";
+    constructor();
+}
+export declare function createXaiConsumerAuth(options: XaiConsumerAuthOptions): XaiConsumerAuthHook;

package/dist/providers/xai/consumer-auth.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { readXaiAccessState } from "./access-state.js";
+const XAI_CONSUMER_MARKER = "cli-session:xai";
+const XAI_DUMMY_API_KEY = "xai-access-file";
+const XaiConsumerMarkerSchema = z
+    .object({ type: z.literal("api"), key: z.literal(XAI_CONSUMER_MARKER) })
+    .strict();
+export class XaiAccessUnavailableError extends Error {
+    name = "XaiAccessUnavailableError";
+    constructor() {
+        super("xAI consumer access is unavailable");
+    }
+}
+function assertNeverAccessState(_state) {
+    throw new XaiAccessUnavailableError();
+}
+function createConsumerFetch(options) {
+    return async (input, init) => {
+        const state = await readXaiAccessState({ env: options.env });
+        let access;
+        switch (state.kind) {
+            case "ready":
+                if (state.expires <= options.clock.nowMs())
+                    throw new XaiAccessUnavailableError();
+                access = state.access;
+                break;
+            case "unavailable":
+                throw new XaiAccessUnavailableError();
+            default:
+                return assertNeverAccessState(state);
+        }
+        const headers = new Headers(input instanceof Request ? input.headers : undefined);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.forEach((value, key) => {
+            headers.set(key, value);
+        });
+        headers.set("authorization", `Bearer ${access}`);
+        return options.networkFetch(input, init === undefined ? { headers } : { ...init, headers });
+    };
+}
+export function createXaiConsumerAuth(options) {
+    return {
+        provider: "xai",
+        loader: async (getAuth) => {
+            const marker = XaiConsumerMarkerSchema.safeParse(await getAuth());
+            return marker.success
+                ? { apiKey: XAI_DUMMY_API_KEY, fetch: createConsumerFetch(options) }
+                : {};
+        },
+        methods: [],
+    };
+}

package/dist/server.d.ts

@@ -4,6 +4,7 @@ export declare const claudeAuthServer: V1Plugin;
 export declare const cursorAuthServer: V1Plugin;
 export declare const commandCodeAuthServer: V1Plugin;
 export declare const ollamaAuthServer: V1Plugin;
+export declare const xaiAuthServer: V1Plugin;
 export type ConnectorPluginModule = {
     readonly id: "opencode-ext-connector";
     readonly server: V1Plugin;

package/dist/server.js

@@ -14,6 +14,8 @@ import { createProductionProcessSupervisor } from "./process/production-supervis
 import { createClaudeCredentialAuthorityScheduler } from "./providers/claude/credential-authority-scheduler.js";
 import { writeClaudeCredentials } from "./providers/claude/writeback.js";
 import { productionOllamaFetch } from "./providers/ollama/http.js";
+import { createXaiAuthorityObserver } from "./providers/xai/authority-observer.js";
+import { createXaiConsumerAuth } from "./providers/xai/consumer-auth.js";
 const env = process.env;
 const transport = createFetchHttpTransport();
 const authStore = createOpenCodeAuthStore({ env });
@@ -86,10 +88,17 @@ export const connectorServer = async (input, options) => {
         processSupervisor,
         logger,
     });
+    const xaiAuthority = createXaiAuthorityObserver({
+        enabled: connectorOptions.xaiOAuth?.mode === "authority",
+        clock,
+        env,
+        processSupervisor,
+    });
     const dispose = hooks.dispose;
     const disposal = createAsyncDisposable(async () => {
         const results = await Promise.allSettled([
             Promise.resolve().then(() => credentialAuthority.dispose()),
+            Promise.resolve().then(() => xaiAuthority.dispose()),
             Promise.resolve().then(() => processSupervisor.dispose()),
             Promise.resolve().then(() => dispose?.()),
             Promise.resolve().then(disposeV1LanguageRuntime),
@@ -129,6 +138,12 @@ export const ollamaAuthServer = async (_input, options) => {
     }).find((candidate) => candidate.id === "ollama");
     return entry === undefined ? {} : buildV1AuthHooks(entry, providerDeps, options);
 };
+export const xaiAuthServer = async (_input, options) => {
+    const connectorOptions = parseConnectorOptions(pickConnectorOptionsInput(options));
+    return connectorOptions.xaiOAuth?.mode === "consumer"
+        ? { auth: createXaiConsumerAuth({ env, clock, networkFetch: globalThis.fetch }) }
+        : {};
+};
 export const plugin = {
     id: "opencode-ext-connector",
     server: connectorServer,

package/dist/xai.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin as V1Plugin } from "@opencode-ai/plugin";
+export declare const xaiAuthServer: V1Plugin;

package/dist/xai.js

@@ -0,0 +1 @@
+export const xaiAuthServer = async (input, options) => (await import("./server.js")).xaiAuthServer(input, options);