@blankline/dropstone-sdk 1.0.8

package/dist/gen/types.gen.js

@@ -0,0 +1,2 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./client.js";
+export * from "./server.js";
+export * from "./api.js";
+import type { ServerOptions } from "./server.js";
+export declare function createDropstone(options?: ServerOptions): Promise<{
+    client: import("./client.js").DropstoneClient;
+    server: {
+        url: string;
+        close(): void;
+    };
+}>;

package/dist/index.js

@@ -0,0 +1,17 @@
+export * from "./client.js";
+export * from "./server.js";
+export * from "./api.js";
+import { createDropstoneClient } from "./client.js";
+import { createDropstoneServer } from "./server.js";
+export async function createDropstone(options) {
+    const server = await createDropstoneServer({
+        ...options,
+    });
+    const client = createDropstoneClient({
+        baseUrl: server.url,
+    });
+    return {
+        client,
+        server,
+    };
+}

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/dropstone/src/util/process.ts` because the SDK cannot
+// import `dropstone` without creating a cycle (`dropstone` depends on `@blankline/dropstone-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

@@ -0,0 +1,23 @@
+import { type Config } from "./gen/types.gen.js";
+export type ServerOptions = {
+    hostname?: string;
+    port?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+    config?: Config;
+};
+export type TuiOptions = {
+    project?: string;
+    model?: string;
+    session?: string;
+    agent?: string;
+    signal?: AbortSignal;
+    config?: Config;
+};
+export declare function createDropstoneServer(options?: ServerOptions): Promise<{
+    url: string;
+    close(): void;
+}>;
+export declare function createDropstoneTui(options?: TuiOptions): {
+    close(): void;
+};

package/dist/server.js

@@ -0,0 +1,105 @@
+import launch from "cross-spawn";
+import { stop, bindAbort } from "./process.js";
+export async function createDropstoneServer(options) {
+    options = Object.assign({
+        hostname: "127.0.0.1",
+        port: 4096,
+        timeout: 5000,
+    }, options ?? {});
+    const args = [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`];
+    if (options.config?.logLevel)
+        args.push(`--log-level=${options.config.logLevel}`);
+    const proc = launch(`dropstone`, args, {
+        env: {
+            ...process.env,
+            DROPSTONE_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("dropstone server listening")) {
+                    const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
+                    if (!match) {
+                        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;
+                }
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        proc.on("exit", (code) => {
+            clearTimeout(id);
+            let msg = `Server exited with code ${code}`;
+            if (output.trim()) {
+                msg += `\nServer output: ${output}`;
+            }
+            reject(new Error(msg));
+        });
+        proc.on("error", (error) => {
+            clearTimeout(id);
+            reject(error);
+        });
+        clear = bindAbort(proc, options.signal, () => {
+            clearTimeout(id);
+            reject(options.signal?.reason);
+        });
+    });
+    return {
+        url,
+        close() {
+            clear();
+            stop(proc);
+        },
+    };
+}
+export function createDropstoneTui(options) {
+    const args = [];
+    if (options?.project) {
+        args.push(`--project=${options.project}`);
+    }
+    if (options?.model) {
+        args.push(`--model=${options.model}`);
+    }
+    if (options?.session) {
+        args.push(`--session=${options.session}`);
+    }
+    if (options?.agent) {
+        args.push(`--agent=${options.agent}`);
+    }
+    const proc = launch(`dropstone`, args, {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            DROPSTONE_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
+        },
+    });
+    const clear = bindAbort(proc, options?.signal);
+    return {
+        close() {
+            clear();
+            stop(proc);
+        },
+    };
+}

package/dist/v2/client.d.ts

@@ -0,0 +1,8 @@
+export * from "./gen/types.gen.js";
+import { type Config } from "./gen/client/types.gen.js";
+import { DropstoneClient } from "./gen/sdk.gen.js";
+export { type Config as DropstoneClientConfig, DropstoneClient };
+export declare function createDropstoneClient(config?: Config & {
+    directory?: string;
+    experimental_workspaceID?: string;
+}): DropstoneClient;

package/dist/v2/client.js

@@ -0,0 +1,96 @@
+export * from "./gen/types.gen.js";
+import { createClient } from "./gen/client/client.gen.js";
+import { DropstoneClient } from "./gen/sdk.gen.js";
+export { DropstoneClient };
+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-dropstone-directory", "directory"],
+        ["x-dropstone-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-dropstone-directory");
+    next.headers.delete("x-dropstone-workspace");
+    return next;
+}
+export function createDropstoneClient(config) {
+    if (!config?.fetch) {
+        const customFetch = (req) => {
+            // @ts-ignore
+            req.timeout = false;
+            return fetch(req);
+        };
+        config = {
+            ...config,
+            fetch: customFetch,
+        };
+    }
+    if (config?.directory) {
+        config.headers = {
+            ...config.headers,
+            "x-dropstone-directory": encodeURIComponent(config.directory),
+        };
+    }
+    if (config?.experimental_workspaceID) {
+        config.headers = {
+            ...config.headers,
+            "x-dropstone-workspace": config.experimental_workspaceID,
+        };
+    }
+    const client = createClient(config);
+    client.interceptors.request.use((request) => rewrite(request, {
+        directory: config?.directory,
+        workspace: config?.experimental_workspaceID,
+    }));
+    client.interceptors.response.use((response) => {
+        const contentType = response.headers.get("content-type");
+        if (contentType === "text/html")
+            throw new Error("Request is not supported by this version of Dropstone Server (Server responded with text/html)");
+        return response;
+    });
+    // The generated client falls back to throwing a literal `{}` when the server
+    // responds with an empty / unparseable error body, which surfaces as a bare
+    // `{}` in TUI / CLI error output. Wrap ONLY that case in a real Error so
+    // downstream formatters get a useful message — but pass through any parsed
+    // JSON error body unchanged so existing consumers can still inspect fields.
+    client.interceptors.error.use((error, response, request) => {
+        const isEmpty = error === undefined ||
+            error === null ||
+            error === "" ||
+            (typeof error === "object" && !(error instanceof Error) && Object.keys(error).length === 0);
+        if (!isEmpty)
+            return error;
+        const method = request?.method ?? "?";
+        const url = request?.url ?? "?";
+        if (!response)
+            return new Error(`dropstone server ${method} ${url}: network error (no response)`);
+        const status = response.status;
+        const statusText = response.statusText ? " " + response.statusText : "";
+        return new Error(`dropstone server ${method} ${url} → ${status}${statusText}: (empty response body)`);
+    });
+    return new DropstoneClient({ client });
+}

package/dist/v2/data.d.ts

@@ -0,0 +1,9 @@
+import type { Part, UserMessage } from "./client.js";
+export declare const message: {
+    user(input: Omit<UserMessage, "role" | "time" | "id"> & {
+        parts: Omit<Part, "id" | "sessionID" | "messageID">[];
+    }): {
+        info: UserMessage;
+        parts: Part[];
+    };
+};

package/dist/v2/data.js

@@ -0,0 +1,22 @@
+export const message = {
+    user(input) {
+        const { parts: _parts, ...rest } = input;
+        const info = {
+            ...rest,
+            id: "asdasd",
+            time: {
+                created: Date.now(),
+            },
+            role: "user",
+        };
+        return {
+            info,
+            parts: input.parts.map((part) => ({
+                ...part,
+                id: "asdasd",
+                messageID: info.id,
+                sessionID: info.sessionID,
+            })),
+        };
+    },
+};

package/dist/v2/gen/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from "./types.gen.js";
+export declare const createClient: (config?: Config) => Client;

package/dist/v2/gen/client/client.gen.js

@@ -0,0 +1,232 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from "../core/serverSentEvents.gen.js";
+import { getValidRequestBody } from "../core/utils.gen.js";
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from "./utils.gen.js";
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === "") {
+            opts.headers.delete("Content-Type");
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: "follow",
+            ...opts,
+            body: getValidRequestBody(opts),
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request.fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response;
+        try {
+            response = await _fetch(request);
+        }
+        catch (error) {
+            // Handle fetch exceptions (AbortError, network errors, etc.)
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = (await fn(error, undefined, request, opts));
+                }
+            }
+            finalError = finalError || {};
+            if (opts.throwOnError) {
+                throw finalError;
+            }
+            // Return error response
+            return opts.responseStyle === "data"
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response: undefined,
+                };
+        }
+        for (const fn of interceptors.response.fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+            if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+                let emptyData;
+                switch (parseAs) {
+                    case "arrayBuffer":
+                    case "blob":
+                    case "text":
+                        emptyData = await response[parseAs]();
+                        break;
+                    case "formData":
+                        emptyData = new FormData();
+                        break;
+                    case "stream":
+                        emptyData = response.body;
+                        break;
+                    case "json":
+                    default:
+                        emptyData = {};
+                        break;
+                }
+                return opts.responseStyle === "data"
+                    ? emptyData
+                    : {
+                        data: emptyData,
+                        ...result,
+                    };
+            }
+            let data;
+            switch (parseAs) {
+                case "arrayBuffer":
+                case "blob":
+                case "formData":
+                case "text":
+                    data = await response[parseAs]();
+                    break;
+                case "json": {
+                    // Some servers return 200 with no Content-Length and empty body.
+                    // response.json() would throw; read as text and parse if non-empty.
+                    const text = await response.text();
+                    data = text ? JSON.parse(text) : {};
+                    break;
+                }
+                case "stream":
+                    return opts.responseStyle === "data"
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === "json") {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === "data"
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error.fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === "data"
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    return {
+        buildUrl,
+        connect: makeMethodFn("CONNECT"),
+        delete: makeMethodFn("DELETE"),
+        get: makeMethodFn("GET"),
+        getConfig,
+        head: makeMethodFn("HEAD"),
+        interceptors,
+        options: makeMethodFn("OPTIONS"),
+        patch: makeMethodFn("PATCH"),
+        post: makeMethodFn("POST"),
+        put: makeMethodFn("PUT"),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn("CONNECT"),
+            delete: makeSseFn("DELETE"),
+            get: makeSseFn("GET"),
+            head: makeSseFn("HEAD"),
+            options: makeSseFn("OPTIONS"),
+            patch: makeSseFn("PATCH"),
+            post: makeSseFn("POST"),
+            put: makeSseFn("PUT"),
+            trace: makeSseFn("TRACE"),
+        },
+        trace: makeMethodFn("TRACE"),
+    };
+};

package/dist/v2/gen/client/index.d.ts

@@ -0,0 +1,8 @@
+export type { Auth } from "../core/auth.gen.js";
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js";
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
+export { buildClientParams } from "../core/params.gen.js";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js";
+export { createClient } from "./client.gen.js";
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from "./types.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";

package/dist/v2/gen/client/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from "../core/bodySerializer.gen.js";
+export { buildClientParams } from "../core/params.gen.js";
+export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js";
+export { createClient } from "./client.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";