dsh-openwrite 0.2.28 → 0.2.33

package/packages/openwrite-bridge/lib/host-web.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A loopback-only relay onto the host's own `ctx.web` service.
+ *
+ * OpenWrite's deep research runs as a separate Node process. The host's search
+ * and fetch providers (including `web_search` / `web_fetch`) live in the host
+ * process, so the child cannot reach them directly. This relay gives it a
+ * machine-token HTTP face over exactly those two capabilities; no provider key
+ * and no browser session can reach it.
+ *
+ * `/bocha` exists because the vendored DeepResearch framework already speaks
+ * the Bocha search protocol. Mapping one search onto that protocol lets us use
+ * the host's search without forking the framework's search-provider union.
+ */
+export interface HostWebSearchSource {
+    url: string;
+    title?: string;
+    snippet?: string;
+    publishedAt?: string;
+}
+export interface HostWebSearchResult {
+    content?: string;
+    sources: HostWebSearchSource[];
+    truncated?: boolean;
+}
+export interface HostWebFetchResult {
+    url: string;
+    statusCode: number;
+    body: {
+        kind: 'html' | 'text';
+        content: string;
+    };
+    truncated?: boolean;
+}
+/** Structural view of the host's `web` service (`ctx.get('web')`). */
+export interface HostWebService {
+    search(request: {
+        query: string;
+        maxResults?: number;
+    }, signal?: AbortSignal): Promise<HostWebSearchResult>;
+    fetch(request: {
+        url: string;
+    }, signal?: AbortSignal): Promise<HostWebFetchResult>;
+}
+export interface HostWebRelayOptions {
+    web: HostWebService;
+    /** Machine token; every request must present it as a bearer credential. */
+    token: string;
+}
+export declare class HostWebRelay {
+    private readonly options;
+    private server?;
+    private port;
+    private closed;
+    constructor(options: HostWebRelayOptions);
+    listen(): Promise<void>;
+    baseUrl(): string;
+    token(): string;
+    close(): Promise<void>;
+    private authorized;
+    private handle;
+}

package/packages/openwrite-bridge/lib/host-web.js

@@ -0,0 +1,166 @@
+import { createServer } from 'node:http';
+const BODY_LIMIT_BYTES = 1 * 1024 * 1024;
+const REQUEST_TIMEOUT_MS = 120_000;
+function json(res, status, payload) {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+    res.end(body);
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > BODY_LIMIT_BYTES)
+            throw new Error('request body too large');
+        chunks.push(Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return {};
+    const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('request body must be a JSON object');
+    return parsed;
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/** Normalize the host's search result to the wire shape. */
+function searchWire(result) {
+    const sources = Array.isArray(result.sources)
+        ? result.sources
+            .filter(source => source !== null && typeof source === 'object' && nonEmptyString(source.url) !== '')
+            .map(source => ({
+            url: nonEmptyString(source.url),
+            ...(nonEmptyString(source.title) === '' ? {} : { title: nonEmptyString(source.title) }),
+            ...(nonEmptyString(source.snippet) === '' ? {} : { snippet: nonEmptyString(source.snippet) }),
+            ...(nonEmptyString(source.publishedAt) === '' ? {} : { publishedAt: nonEmptyString(source.publishedAt) }),
+        }))
+        : [];
+    return {
+        ...(nonEmptyString(result.content) === '' ? {} : { content: nonEmptyString(result.content) }),
+        sources,
+        truncated: result.truncated === true,
+    };
+}
+/** Normalize the host's fetch result; body kind and text are always present. */
+function fetchWire(result) {
+    const kind = result.body?.kind === 'html' ? 'html' : 'text';
+    return {
+        url: nonEmptyString(result.url),
+        statusCode: Number.isInteger(result.statusCode) ? result.statusCode : 0,
+        body: { kind, content: typeof result.body?.content === 'string' ? result.body.content : '' },
+        truncated: result.truncated === true,
+    };
+}
+/** The Bocha response shape the vendored search provider parses. */
+function bochaWire(sources) {
+    return {
+        code: 200,
+        data: {
+            webPages: {
+                value: sources.map(source => ({
+                    name: nonEmptyString(source.title) || nonEmptyString(source.url),
+                    url: nonEmptyString(source.url),
+                    snippet: nonEmptyString(source.snippet),
+                    summary: nonEmptyString(source.snippet),
+                })),
+            },
+        },
+    };
+}
+export class HostWebRelay {
+    options;
+    server;
+    port = 0;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async listen() {
+        if (this.server !== undefined)
+            return;
+        const server = createServer((req, res) => {
+            void this.handle(req, res).catch((error) => {
+                if (res.headersSent) {
+                    res.end();
+                    return;
+                }
+                json(res, 502, { error: { message: error instanceof Error ? error.message : String(error) } });
+            });
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => {
+                server.removeListener('error', reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        this.port = typeof address === 'object' && address !== null ? address.port : 0;
+        this.server = server;
+    }
+    baseUrl() {
+        return `http://127.0.0.1:${this.port}`;
+    }
+    token() {
+        return this.options.token;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const server = this.server;
+        this.server = undefined;
+        if (server === undefined)
+            return;
+        await new Promise(resolve => server.close(() => resolve()));
+    }
+    authorized(req) {
+        return req.headers.authorization === `Bearer ${this.options.token}`;
+    }
+    async handle(req, res) {
+        if (!this.authorized(req)) {
+            json(res, 401, { error: { message: 'unauthorized' } });
+            return;
+        }
+        if (req.method !== 'POST') {
+            json(res, 405, { error: { message: 'method not allowed' } });
+            return;
+        }
+        const url = new URL(req.url ?? '/', 'http://relay');
+        const body = await readJson(req);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            if (url.pathname === '/search') {
+                const query = nonEmptyString(body.query);
+                if (query === '')
+                    throw new Error('query is required');
+                const maxResults = Number.isInteger(body.maxResults) && Number(body.maxResults) > 0 ? Number(body.maxResults) : undefined;
+                json(res, 200, searchWire(await this.options.web.search({ query, ...(maxResults === undefined ? {} : { maxResults }) }, controller.signal)));
+                return;
+            }
+            if (url.pathname === '/bocha') {
+                const query = nonEmptyString(body.query);
+                if (query === '')
+                    throw new Error('query is required');
+                const count = Number.isInteger(body.count) && Number(body.count) > 0 ? Number(body.count) : 10;
+                const result = await this.options.web.search({ query, maxResults: Math.min(count, 50) }, controller.signal);
+                json(res, 200, bochaWire(result.sources ?? []));
+                return;
+            }
+            if (url.pathname === '/fetch') {
+                const target = nonEmptyString(body.url);
+                if (target === '')
+                    throw new Error('url is required');
+                json(res, 200, fetchWire(await this.options.web.fetch({ url: target }, controller.signal)));
+                return;
+            }
+            json(res, 404, { error: { message: 'not found' } });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/packages/openwrite-bridge/lib/index.d.ts

@@ -6,6 +6,10 @@ export interface Config {
     mode?: 'managed' | 'external';
     runtimeRoot?: string;
     artifacts?: string;
+    /** Absolute path to a prepared Python >=3.10; skips uv and interpreter downloads. */
+    pythonPath?: string;
+    /** Optional absolute directories containing dependencies for the supplied interpreter. */
+    pythonModulePaths?: string[];
     /** Base URL of the local OpenWrite Studio server. */
     baseUrl: string;
     /** Optional instance token of an externally managed Studio server. */

package/packages/openwrite-bridge/lib/index.js

@@ -7,21 +7,77 @@
 import { tmpdir, homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { ManagedRuntime } from './managed-runtime.js';
-import { join } from 'node:path';
+import { HostLlmRelay, newRelayToken } from './host-llm.js';
+import { HostWebRelay } from './host-web.js';
+import { join, isAbsolute } from 'node:path';
+import { existsSync } from 'node:fs';
 import Schema from '@deepseek-ai/schemastery';
 import { NovelDomainService } from './domain.js';
 export const name = '@dsh-novel/openwrite-bridge';
 export const inject = [];
 export const Config = Schema.object({
-    mode: Schema.union(['managed', 'external']),
+    // Explicit default: the code relied on `undefined` falling through to external,
+    // which is invisible in the schema and easy to break.
+    mode: Schema.union(['managed', 'external']).default('external'),
     runtimeRoot: Schema.string(),
     artifacts: Schema.string(),
+    pythonPath: Schema.string(),
+    pythonModulePaths: Schema.array(Schema.string()),
     baseUrl: Schema.string().default('http://127.0.0.1:4567'),
     authToken: Schema.string().role('secret'),
     timeoutMs: Schema.number().default(600000),
     outputDir: Schema.string().default(join(tmpdir(), 'openwrite-exports')),
 });
+/**
+ * Validate the configuration before any request is served. Every one of these
+ * used to surface as a first-request failure with a misleading cause: a bogus
+ * runtimeRoot or artifacts path only raised ENOENT inside `ensure()`, a
+ * non-URL baseUrl threw inside `new URL()` and was rewritten to NETWORK_ERROR,
+ * and `timeoutMs <= 0` made every request abort immediately.
+ */
+function validateConfig(config) {
+    if (!Number.isFinite(config.timeoutMs) || config.timeoutMs <= 0) {
+        throw new Error(`openwrite-bridge: timeoutMs must be a positive number, got ${String(config.timeoutMs)}`);
+    }
+    if (config.mode === 'external') {
+        try {
+            const parsed = new URL(config.baseUrl);
+            if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+                throw new Error(`unsupported protocol ${parsed.protocol}`);
+            }
+        }
+        catch (cause) {
+            throw new Error(`openwrite-bridge: baseUrl must be an http(s) URL, got ${JSON.stringify(config.baseUrl)} (${cause instanceof Error ? cause.message : String(cause)})`);
+        }
+        // No authToken rule here: a tokenless Studio server is a legitimate
+        // external configuration, and there is no way to tell it from a forgotten
+        // token without asking the server. Only the *contradiction* below is a
+        // definite misconfiguration.
+    }
+    if (config.mode === 'managed') {
+        // The token is only used in external mode; managed mode authenticates through
+        // the runtime's own connection, so a supplied token is silently ignored.
+        if (config.authToken !== undefined && config.authToken !== '') {
+            throw new Error('openwrite-bridge: authToken is ignored in managed mode (the managed runtime issues its own connection token); remove it or switch to mode "external"');
+        }
+        const artifacts = config.artifacts ?? fileURLToPath(new URL('../../../release/', import.meta.url));
+        if (!existsSync(join(artifacts, 'runtime-manifest.json'))) {
+            throw new Error(`openwrite-bridge: artifacts must contain runtime-manifest.json, got ${JSON.stringify(artifacts)}`);
+        }
+        for (const [key, value] of [['pythonPath', config.pythonPath], ['runtimeRoot', config.runtimeRoot]]) {
+            if (value === undefined || value === '')
+                continue;
+            if (!isAbsolute(value))
+                throw new Error(`openwrite-bridge: ${key} must be an absolute path, got ${JSON.stringify(value)}`);
+        }
+        for (const value of config.pythonModulePaths ?? []) {
+            if (!isAbsolute(value))
+                throw new Error(`openwrite-bridge: pythonModulePaths entries must be absolute, got ${JSON.stringify(value)}`);
+        }
+    }
+}
 export function apply(ctx, config) {
+    validateConfig(config);
     // The web host process mounts ctx.workspaceRegistry. Resolve it lazily on
     // every call: plugin start order must not strand the lookup, an absent
     // registry (null) fails closed in the domain, and ctx.inject(['webServer',
@@ -32,8 +88,90 @@ export function apply(ctx, config) {
             return null;
         return registry.get(workspaceId)?.path;
     };
+    // The relay onto the host's own model directory. It is created lazily: a
+    // host that composes no `llm` service still loads the plugin, it just offers
+    // no host models. The relay binds an ephemeral loopback port and answers
+    // only to a machine token, so no provider key and no browser session can
+    // reach it.
+    let relay;
+    const defaultSelection = () => {
+        let service;
+        try {
+            service = ctx.get('agentDefaultModel');
+        }
+        catch {
+            return undefined;
+        }
+        if (service === undefined || service === null)
+            return undefined;
+        try {
+            const selection = service.currentSelection();
+            const provider = typeof selection?.provider === 'string' ? selection.provider : '';
+            const model = typeof selection?.model === 'string' ? selection.model : '';
+            if (provider === '' || model === '')
+                return undefined;
+            const effort = typeof selection?.reasoningEffort === 'string' ? selection.reasoningEffort : '';
+            return { provider, model, ...(effort === '' ? {} : { reasoningEffort: effort }) };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const ensureRelay = async () => {
+        if (relay !== undefined)
+            return relay;
+        let llm;
+        try {
+            llm = ctx.get('llm');
+        }
+        catch {
+            return undefined;
+        }
+        if (llm === undefined || llm === null)
+            return undefined;
+        const created = new HostLlmRelay({
+            llm: llm,
+            token: newRelayToken(),
+            defaultSelection,
+        });
+        await created.listen();
+        relay = created;
+        return relay;
+    };
+    ctx.effect(() => () => { void relay?.close(); relay = undefined; }, 'openwrite: host llm relay cleanup');
+    // The relay onto the host's own web search/fetch. Only the managed runtime
+    // needs it; an external Studio keeps its own search providers.
+    let webRelay;
+    const ensureWebRelay = async () => {
+        if (webRelay !== undefined)
+            return webRelay;
+        let web;
+        try {
+            web = ctx.get('web');
+        }
+        catch {
+            return undefined;
+        }
+        if (web === undefined || web === null)
+            return undefined;
+        const created = new HostWebRelay({ web: web, token: newRelayToken() });
+        await created.listen();
+        webRelay = created;
+        return created;
+    };
+    ctx.effect(() => () => { void webRelay?.close(); webRelay = undefined; }, 'openwrite: host web relay cleanup');
     // A supplied legacy baseUrl remains external; the standard bundle selects managed explicitly.
-    const runtime = config.mode === 'managed' ? new ManagedRuntime(config.runtimeRoot ?? join(process.env['DSH_HOME']?.trim() || join(homedir(), '.dsh'), 'openwrite'), config.artifacts ?? fileURLToPath(new URL('../../../release/', import.meta.url))) : undefined;
+    const runtime = config.mode === 'managed' ? new ManagedRuntime(config.runtimeRoot ?? join(process.env['DSH_HOME']?.trim() || join(homedir(), '.dsh'), 'openwrite'), config.artifacts ?? fileURLToPath(new URL('../../../release/', import.meta.url)), { pythonPath: config.pythonPath, pythonModulePaths: config.pythonModulePaths,
+        // The relay is resolved per backend start: its port is ephemeral, so a
+        // cached address would outlive the server it points at.
+        hostLlm: async () => {
+            const created = await ensureRelay();
+            return created === undefined ? undefined : { url: created.baseUrl(), token: created.token() };
+        },
+        hostWeb: async () => {
+            const created = await ensureWebRelay();
+            return created === undefined ? undefined : { url: created.baseUrl(), token: created.token() };
+        } }) : undefined;
     const authorizeRequest = (headers) => {
         const connection = ctx.get('connection');
         return connection ? connection.requestRejection({ headers }) : 503;
@@ -61,15 +199,21 @@ export function apply(ctx, config) {
             }
             const chunks = [];
             let size = 0;
+            // Answering 413 while still iterating `req` resets the connection, so the
+            // client sees a truncated response. Drain first, then respond.
+            let tooLarge = false;
             for await (const chunk of req) {
                 size += chunk.length;
                 if (size > 1024) {
-                    respond(413, { error: 'Request too large', message: 'Request too large', code: 'REQUEST_TOO_LARGE' });
-                    return;
+                    tooLarge = true;
+                    break;
                 }
-                ;
                 chunks.push(Buffer.from(chunk));
             }
+            if (tooLarge) {
+                respond(413, { error: 'Request too large', message: 'Request too large', code: 'REQUEST_TOO_LARGE' });
+                return;
+            }
             try {
                 const action = JSON.parse(Buffer.concat(chunks).toString()).action;
                 if (action === 'cancel')

package/packages/openwrite-bridge/lib/managed-runtime.d.ts

@@ -48,10 +48,34 @@ export declare class UnsupportedRuntimePlatformError extends Error {
 }
 export type SpawnFn = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
 export interface RuntimeOptions {
+    /** Prepared Python >=3.10. Dependencies belong to the author; Core stays in our own directory. */
+    pythonPath?: string;
+    /** Explicit dependency directories, e.g. an Android author's prepared pyroot. */
+    pythonModulePaths?: string[];
     spawn?: SpawnFn;
     delay?: typeof delay;
     restartLimit?: number;
     backoffMs?: number[];
+    /**
+     * The host's OpenAI-compatible relay, handed to Core over the stdio
+     * handshake. Core needs it to call the models dsh itself can reach; the
+     * relay address is ephemeral, so it is resolved per start, never cached.
+     */
+    hostLlm?: () => Promise<HostLlmHandshake | undefined> | HostLlmHandshake | undefined;
+    /** The host's search/fetch relay, handed to Core over the same handshake. */
+    hostWeb?: () => Promise<HostWebHandshake | undefined> | HostWebHandshake | undefined;
+}
+/** The relay coordinates Core receives in its private startup handshake. */
+export interface HostLlmHandshake {
+    /** OpenAI-compatible base URL of the relay. */
+    url: string;
+    /** Machine token the relay requires as a bearer credential. */
+    token: string;
+}
+/** The host's web search/fetch relay coordinates. */
+export interface HostWebHandshake {
+    url: string;
+    token: string;
 }
 export declare const DEFAULT_RESTART_LIMIT = 5;
 export declare const DEFAULT_BACKOFF_MS: number[];
@@ -89,6 +113,10 @@ export declare class ManagedRuntime {
     private readonly wait;
     private readonly restartLimit;
     private readonly backoffMs;
+    private readonly pythonPath?;
+    private readonly pythonModulePaths;
+    private readonly hostLlm?;
+    private readonly hostWeb?;
     constructor(root: string, artifacts: string, options?: RuntimeOptions);
     status(): RuntimeStatus;
     private update;
@@ -101,8 +129,23 @@ export declare class ManagedRuntime {
      * forcefully and pushed through the normal recovery path.
      */
     private verifyConnection;
-    /** Short-timeout liveness probe; false covers exit, refusal, hang, and auth drift. */
-    private probeHealth;
+    /**
+     * The host relay coordinates, if the host offers one.
+     *
+     * A relay that cannot be reached is not a startup failure: Core still runs,
+     * it simply has no host models to offer. The failure is silent on purpose —
+     * the relay's own diagnostics belong to the host, not to the backend boot.
+     */
+    private resolveHostLlm;
+    private resolveHostWeb;
+    /**
+     * Liveness with three outcomes. `dead` is only returned on positive evidence —
+     * the child exited, or the connection was refused, or health answered
+     * non-ok (auth drift). A probe that timed out returns `unknown`, because a
+     * busy backend is indistinguishable from a hung one at a 1.5 s deadline and
+     * killing the former destroys in-flight work.
+     */
+    private probeLiveness;
     cancel(): Promise<void>;
     dispose(): Promise<void>;
     private exitDiagnostic;
@@ -130,6 +173,8 @@ export declare class ManagedRuntime {
     private downloadFrom;
     private extract;
     private command;
+    /** Shared Android/embedded Python may need its host's native-library search paths. */
+    private pythonLibraryEnv;
     private lock;
     private prepare;
     private start;