@try-works/dsh-model-as-tool 0.1.3 → 0.4.0

package/node_modules/@try-works/tool-mode-extension-sdk/lib/worker/worker-child.js

@@ -0,0 +1,351 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/** Managed process bridge. No filesystem authority is implied by process isolation. */
+import { pathToFileURL } from 'node:url';
+import { readFileSync, readSync, statSync, existsSync } from 'node:fs';
+import { dirname, resolve, sep } from 'node:path';
+import { isWorkerObject, workerWire, workerFrame, workerId } from "../worker.js";
+function argument(flag) {
+    const index = process.argv.indexOf(flag);
+    const value = process.argv[index + 1];
+    if (index === -1 || value === undefined)
+        throw new Error(`missing ${flag}`);
+    return value;
+}
+function bound(flag) {
+    const value = Number(argument(flag));
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`invalid ${flag}`);
+    return value;
+}
+const maxLine = bound('--max-line-bytes');
+const maxInput = bound('--max-input-bytes');
+const pathTimeout = bound('--resolve-path-timeout-ms');
+let diagnosticBytes = 0;
+function diagnostic(message) {
+    const remaining = 64 * 1024 - diagnosticBytes;
+    if (remaining <= 0)
+        return;
+    const line = Buffer.from(message).subarray(0, Math.min(4096, remaining)).toString('utf8');
+    diagnosticBytes += Buffer.byteLength(line);
+    process.stderr.write(`${line}\n`);
+}
+function send(message) {
+    const line = JSON.stringify(message);
+    if (Buffer.byteLength(line, 'utf8') > maxLine) {
+        diagnostic('worker result protocol line exceeded byte limit');
+        process.exit(1);
+    }
+    process.stdout.write(`${line}\n`);
+}
+function fatal(message) {
+    try {
+        send({ kind: 'fault', message: message.slice(0, 4096) });
+    }
+    finally {
+        process.exit(1);
+    }
+}
+function readObject(path) {
+    if (statSync(path).size > 512 * 1024)
+        throw new Error('manifest metadata exceeds byte limit');
+    const value = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isWorkerObject(value))
+        throw new Error('manifest metadata must be an object');
+    return value;
+}
+/** Manifest model IDs, including models that have no implementation. */
+function modelMapping(entry, extensionId) {
+    let root = dirname(entry);
+    while (!existsSync(resolve(root, 'package.json'))) {
+        const parent = dirname(root);
+        if (parent === root)
+            throw new Error('entry has no owning package.json');
+        root = parent;
+    }
+    const pkg = readObject(resolve(root, 'package.json'));
+    if (!isWorkerObject(pkg['toolMode']) || typeof pkg['toolMode']['manifest'] !== 'string')
+        throw new Error('package has no toolMode.manifest');
+    const path = resolve(root, pkg['toolMode']['manifest']);
+    if (!path.startsWith(root + sep))
+        throw new Error('manifest must be inside owning package');
+    const manifest = readObject(path);
+    if (manifest['id'] !== extensionId || !Array.isArray(manifest['implementations']) || !Array.isArray(manifest['models']))
+        throw new Error('invalid extension manifest identity or mapping');
+    const models = new Set();
+    for (const model of manifest['models']) {
+        if (!isWorkerObject(model) || !workerId(model['id']) || models.has(model['id']))
+            throw new Error('invalid or duplicate manifest model');
+        models.add(model['id']);
+    }
+    const implementations = new Map();
+    for (const item of manifest['implementations']) {
+        if (!isWorkerObject(item) || !workerId(item['id']) || !workerId(item['modelId'])
+            || !models.has(item['modelId']) || implementations.has(item['id']))
+            throw new Error('invalid or duplicate implementation model mapping');
+        implementations.set(item['id'], item['modelId']);
+    }
+    return { implementations, models };
+}
+function bridgeContext(extensionId, generation, signal) {
+    const memory = new Map();
+    return {
+        extensionId, extensionVersion: '0.0.0-worker', activationGeneration: generation,
+        storage: {
+            async read(key) { return memory.get(key); },
+            async write(key, value) { memory.set(key, value); }, directory: '',
+        },
+        logger: { log(level, message, fields) {
+                if (diagnosticBytes >= 64 * 1024)
+                    return;
+                // Serialize bounded structure only; do not stringify arbitrary huge diagnostics.
+                let detail = '';
+                try {
+                    if (fields !== undefined) {
+                        const encoded = workerWire(fields, 'encode', 4096);
+                        detail = JSON.stringify(encoded).slice(0, 2048);
+                    }
+                }
+                catch {
+                    detail = '[diagnostic fields omitted]';
+                }
+                diagnostic(`${level}: ${String(message).slice(0, 2048)} ${detail}`);
+            } },
+        signal, configuration: {},
+    };
+}
+let pathSequence = 0;
+/** fd3 is a host-only reply channel, never caller grants or unrestricted fs. */
+function resolveHostPath(invokeId, candidate, signal) {
+    if (typeof candidate !== 'string' || Buffer.byteLength(candidate) > 16 * 1024 || signal.aborted)
+        throw new Error('path access denied: invalid or aborted path request');
+    const id = `path-${++pathSequence}`;
+    send({ kind: 'resolvePath', id, invokeId, candidate });
+    const deadline = Date.now() + pathTimeout + 250;
+    const chunks = [];
+    let bytes = 0;
+    // Read one byte at a time to avoid consuming a subsequent synchronous reply.
+    const byte = Buffer.alloc(1);
+    while (true) {
+        if (Date.now() >= deadline)
+            throw new Error('path access denied: host path broker deadline elapsed');
+        let count;
+        try {
+            count = readSync(3, byte, 0, 1, null);
+        }
+        catch (error) {
+            if (error.code === 'EAGAIN') {
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+                continue;
+            }
+            throw new Error(`path access denied: broker unavailable: ${String(error)}`);
+        }
+        if (count === 0)
+            throw new Error('path access denied: broker closed');
+        if (byte[0] === 10)
+            break;
+        if (++bytes > maxLine)
+            fatal('path response exceeded byte limit');
+        chunks.push(Buffer.from(byte));
+    }
+    const response = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    workerFrame(response, ['kind', 'id', 'invokeId', 'path', 'error']);
+    if (response['kind'] !== 'resolvePathResult' || response['id'] !== id || response['invokeId'] !== invokeId
+        || (Object.hasOwn(response, 'path') === Object.hasOwn(response, 'error')))
+        fatal('malformed host path response');
+    if (typeof response['error'] === 'string')
+        throw new Error(response['error']);
+    if (typeof response['path'] !== 'string' || response['path'].length === 0 || Buffer.byteLength(response['path']) > 16 * 1024)
+        fatal('malformed canonical host path');
+    return response['path'];
+}
+function invocationContext(invocationId, signal) {
+    return {
+        invocationId, signal,
+        limits: { maxInputBytes: maxInput, maxAudioSeconds: 300, maxResultBytes: maxLine },
+        resolvePath(candidate) { return resolveHostPath(invocationId, candidate, signal); },
+    };
+}
+/** Stable keys mean semantically identical explicit JSON configs share a provider. */
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (isWorkerObject(value))
+        return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+async function main() {
+    const entry = argument('--entry');
+    const extensionId = argument('--extension-id');
+    const generation = Number(argument('--generation'));
+    if (!Number.isSafeInteger(generation) || generation < 0)
+        throw new Error('invalid generation');
+    const disposed = new AbortController();
+    const providers = new Map();
+    const selected = new Map();
+    const inFlight = new Map();
+    let extension;
+    let mapping;
+    try {
+        mapping = modelMapping(entry, extensionId);
+        const module = await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href));
+        const declared = module.default;
+        if (declared === null || typeof declared !== 'object' || declared.apiVersion !== 1 || typeof declared.create !== 'function')
+            throw new Error('entry must export ToolModeExtensionV1');
+        extension = await declared.create(bridgeContext(extensionId, generation, disposed.signal));
+    }
+    catch (error) {
+        fatal(`extension activation failed: ${String(error)}`);
+    }
+    send({ kind: 'ready' });
+    const providerFor = (modelId, configuration) => {
+        if (!mapping.models.has(modelId))
+            throw new Error(`unknown model ${modelId}`);
+        const config = configuration === undefined ? undefined : canonical(configuration);
+        const key = config === undefined ? selected.get(modelId) ?? JSON.stringify([modelId, '{}']) : JSON.stringify([modelId, config]);
+        let created = providers.get(key);
+        if (created === undefined) {
+            if (providers.size >= 128)
+                throw new Error('worker provider limit exceeded');
+            created = Promise.resolve().then(() => extension.createProvider({ modelId, configuration: configuration ?? {} }));
+            providers.set(key, created);
+        }
+        selected.set(modelId, key);
+        return created;
+    };
+    const serve = async (message, controller) => {
+        const id = message['id'];
+        const kind = message['kind'];
+        try {
+            const implementationId = message['implementationId'];
+            const modelId = kind === 'invoke' ? mapping.implementations.get(implementationId) : message['modelId'];
+            if (modelId === undefined)
+                throw new Error(`unknown implementation ${implementationId}`);
+            const provider = await providerFor(modelId, message['configuration']);
+            let result;
+            if (kind === 'inspect') {
+                result = { type: 'inspect', inspection: await provider.inspect(controller.signal) };
+            }
+            else if (kind === 'load') {
+                const handles = new Map(message['assets'].map(asset => [asset.id, { path: asset.path, digest: asset.digest }]));
+                await provider.load({ assets: { assetIds: [...handles.keys()], get(assetId) { return handles.get(assetId); } }, signal: controller.signal });
+                result = { type: 'load' };
+            }
+            else if (kind === 'unload') {
+                await provider.unload(controller.signal);
+                result = { type: 'unload' };
+            }
+            else {
+                const value = await provider.invoke({ implementationId, input: message['input'], context: invocationContext(id, controller.signal) });
+                if (!isWorkerObject(value) || ArrayBuffer.isView(value))
+                    throw new Error('worker result must be an object');
+                result = { type: 'invoke', value };
+            }
+            send({ id, kind: 'result', result: workerWire(result, 'encode', maxLine) });
+        }
+        catch (error) {
+            send({ id, kind: 'error', message: controller.signal.aborted ? 'the invocation was cancelled' : String(error).slice(0, 4096) });
+        }
+        finally {
+            inFlight.delete(id);
+        }
+    };
+    let shuttingDown;
+    const shutdown = () => {
+        if (shuttingDown !== undefined)
+            return shuttingDown;
+        disposed.abort('shutdown');
+        for (const { controller } of inFlight.values())
+            controller.abort('shutdown');
+        shuttingDown = (async () => {
+            await Promise.allSettled([...inFlight.values()].map(item => item.task));
+            await Promise.allSettled([...providers.values()].map(async (created) => {
+                const provider = await created;
+                try {
+                    await provider.unload(disposed.signal);
+                }
+                finally {
+                    await provider.dispose();
+                }
+            }));
+            await extension.dispose('shutdown');
+            process.exit(0);
+        })();
+        return shuttingDown;
+    };
+    const handle = async (line) => {
+        const parsed = JSON.parse(line);
+        if (!isWorkerObject(parsed) || typeof parsed['kind'] !== 'string')
+            throw new Error('protocol frame must be an object with string kind');
+        const kind = parsed['kind'];
+        switch (kind) {
+            case 'inspect':
+            case 'load':
+            case 'unload':
+            case 'invoke': {
+                workerFrame(parsed, ['kind', 'id', ...(kind === 'invoke' ? ['implementationId', 'input'] : ['modelId']), 'configuration', ...(kind === 'load' ? ['assets'] : [])]);
+                if (disposed.signal.aborted || !workerId(parsed['id']) || inFlight.has(parsed['id']) || inFlight.size >= 1024
+                    || !workerId(kind === 'invoke' ? parsed['implementationId'] : parsed['modelId']))
+                    throw new Error('malformed request identity');
+                if (Buffer.byteLength(JSON.stringify(parsed), 'utf8') > maxInput)
+                    throw new Error('input exceeds byte limit');
+                const message = workerWire(parsed, 'decode', maxInput);
+                if (message['configuration'] !== undefined && (!isWorkerObject(message['configuration']) || ArrayBuffer.isView(message['configuration'])))
+                    throw new Error('configuration must be an object');
+                if (kind === 'invoke' && (!isWorkerObject(message['input']) || ArrayBuffer.isView(message['input'])))
+                    throw new Error('input must be an object');
+                if (kind === 'load') {
+                    const assets = message['assets'];
+                    if (!Array.isArray(assets) || assets.length > 10_000 || !assets.every(asset => isWorkerObject(asset)
+                        && Object.keys(asset).length === 3 && workerId(asset['id']) && typeof asset['path'] === 'string' && typeof asset['digest'] === 'string')
+                        || new Set(assets.map(asset => asset['id'])).size !== assets.length)
+                        throw new Error('malformed prepared assets');
+                }
+                const controller = new AbortController();
+                // Queue serve after registration: pre-aborted messages see the controller.
+                const task = Promise.resolve().then(() => serve(message, controller));
+                inFlight.set(parsed['id'], { controller, task });
+                void task.catch(error => fatal(String(error)));
+                break;
+            }
+            case 'cancel':
+                workerFrame(parsed, ['kind', 'invokeId']);
+                if (!workerId(parsed['invokeId']))
+                    throw new Error('malformed cancel');
+                inFlight.get(parsed['invokeId'])?.controller.abort();
+                break;
+            case 'dispose':
+                workerFrame(parsed, ['kind', 'reason']);
+                if (parsed['reason'] !== 'shutdown')
+                    throw new Error('malformed dispose');
+                await shutdown();
+                break;
+            default: throw new Error('unknown protocol kind');
+        }
+    };
+    let buffer = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        let newline = buffer.indexOf('\n');
+        while (newline !== -1) {
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            if (Buffer.byteLength(line, 'utf8') > maxLine)
+                fatal('protocol line exceeded byte limit');
+            void handle(line).catch(error => fatal(`malformed host protocol: ${String(error)}`));
+            newline = buffer.indexOf('\n');
+        }
+        if (Buffer.byteLength(buffer, 'utf8') > maxLine)
+            fatal('protocol line exceeded byte limit');
+    });
+    process.stdin.on('end', () => { void shutdown().catch(error => fatal(String(error))); });
+}
+void main().catch(error => fatal(String(error)));
+//# sourceMappingURL=worker-child.js.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/worker.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The managed extension worker (EXT-20, the SDK half).
+ *
+ * An extension's executable entry runs OUTSIDE the host, in a managed Node
+ * child process with a scrubbed startup environment and a bounded
+ * line-delimited JSON protocol. This module is the host-side of that bridge;
+ * {@link ./worker/worker-child.ts} is the child.
+ *
+ * What "managed" means here, concretely:
+ *
+ * - **Scrubbed environment.** The child env is built from an explicit
+ *   ALLOWLIST (the platform basics a Node child needs: PATH, SystemRoot,
+ *   TEMP/TMP, PATHEXT, COMSPEC, WINDIR) plus names the operator explicitly
+ *   passed through — NEVER `process.env` wholesale, so a credential or a
+ *   planted marker in the host environment does not leak into extension code.
+ * - **Bounded protocol.** One JSON message per line; lines over
+ *   `maxLineBytes` and inputs over `maxInputBytes` are refused, and a child
+ *   that violates the framing is killed and faulted rather than trusted.
+ * - **Timeouts on every phase.** Spawn must answer `ready` within
+ *   `readyTimeoutMs`; a cancelled invoke must settle within `killTimeoutMs` or
+ *   the child is killed; a dispose that outlives the grace is killed.
+ * - **One process per extension identity**, reused across invocations, with a
+ *   restart-on-exit policy: a child that exits (crash or protocol violation)
+ *   faults its in-flight calls and the NEXT invoke spawns a fresh one.
+ *
+ * **The boundary, documented:** a worker failure fails the CALL with the SDK's
+ * management-error vocabulary (EXTENSION_FAULT / INVALID_EXTENSION), never the
+ * host process — the extension runs in another process by design, and this
+ * module never lets a child's exit, hang or protocol violation propagate as an
+ * uncaught failure in the caller.
+ *
+ * Distinct process lifetime per extension generation is the caller's
+ * discipline (EXT-20): the host half disposes the old worker and creates a new
+ * one when the activation generation advances. `generation` is recorded here
+ * so diagnostics can name which generation a worker served.
+ *
+ * @module @try-works/tool-mode-extension-sdk/worker
+ */
+import type { JsonObject, PreparedAssetMapV1, ProviderInspectionV1 } from './runtime.ts';
+/** Default bounds; every one is overridable for a tighter deployment. */
+export interface WorkerLimits {
+    /** Longest protocol line admitted, either direction. Default 1 MiB. */
+    readonly maxLineBytes?: number;
+    /** Largest serialized input admitted. Default 4 MiB. */
+    readonly maxInputBytes?: number;
+    /** How long spawn may take to answer `ready`. Default 30 s. */
+    readonly readyTimeoutMs?: number;
+    /** How long a cancelled or disposing child may outlive the request. Default 5 s. */
+    readonly killTimeoutMs?: number;
+    /** Deadline for one request-scoped path broker reply. Default 5 s. */
+    readonly resolvePathTimeoutMs?: number;
+}
+/** Options for {@link ManagedExtensionWorker.create}. */
+export interface ManagedWorkerOptions {
+    /** The extension identity the worker serves; one process per identity. */
+    readonly extensionId: string;
+    /** Absolute path of the built `./tool-mode` entry (plain Node ESM). */
+    readonly entryPath: string;
+    /** The activation generation this worker serves (EXT-20 lifetime discipline). */
+    readonly generation: number;
+    /** Explicit environment names to pass through, on top of the allowlist. */
+    readonly envPassthrough?: readonly string[];
+    /** The Node executable; defaults to the caller's own. */
+    readonly nodePath?: string;
+    /** Bounds and deadlines. */
+    readonly limits?: WorkerLimits;
+    /** Where child stderr diagnostics go; defaults to stderr. */
+    readonly diagnostics?: (line: string) => void;
+}
+/**
+ * Build the scrubbed child environment (EXT-20).
+ *
+ * The allowlist is the platform's Node bootstrap minimum; the operator's
+ * explicit `passthrough` names are the only additions. Everything else the
+ * parent holds — credentials, markers, DSH internals — is absent in the child.
+ * @param env - the parent environment to scrub.
+ * @param passthrough - explicit names to carry over.
+ * @returns the child environment.
+ */
+export declare function scrubbedEnv(env?: NodeJS.ProcessEnv, passthrough?: readonly string[]): Record<string, string>;
+/** A protocol object is never null, an array, or a scalar. */
+export declare function isWorkerObject(value: unknown): value is Record<string, unknown>;
+/** Lossless bounded wire codec. Other non-JSON/typed values fail explicitly. */
+export declare function workerWire(value: unknown, direction: 'encode' | 'decode', maxBytes: number): unknown;
+/** Explicit host-selected, serialized configuration only; never pass grants or env. */
+export interface WorkerRequestOptions {
+    readonly configuration?: Readonly<JsonObject>;
+    readonly signal?: AbortSignal;
+}
+/** Shared envelope guard; every protocol frame is bounded before this runs. */
+export declare function workerFrame(value: unknown, fields: readonly string[]): asserts value is Record<string, unknown>;
+export declare function workerId(value: unknown): value is string;
+/**
+ * One managed extension worker process.
+ *
+ * Spawn is LAZY: the first invocation starts the child, and later invocations
+ * reuse it. A child that exits is replaced on the next invocation; the
+ * in-flight calls at exit time fault with EXTENSION_FAULT.
+ */
+export declare class ManagedExtensionWorker {
+    #private;
+    readonly extensionId: string;
+    readonly generation: number;
+    private constructor();
+    /** Build a worker; nothing is spawned until the first invocation. */
+    static create(options: ManagedWorkerOptions): ManagedExtensionWorker;
+    /** Whether the worker process is currently alive. */
+    get alive(): boolean;
+    /** The worker's pid, when it has one. */
+    get pid(): number | undefined;
+    /** How many invocations are in flight. */
+    get inFlight(): number;
+    /**
+     * Run one invocation in the managed process.
+     *
+     * The caller's abort cancels the invocation BY MESSAGE; a child that does
+     * not settle within `killTimeoutMs` after cancellation is killed and the
+     * call fails with EXTENSION_FAULT — a hung extension can never hang the
+     * caller. There is no normal inference deadline here; a caller-owned request
+     * timeout can abort its signal. Killing this shared process also faults all
+     * noncancelled in-flight calls, without labelling them caller cancellations.
+     * Every failure here is a ManagementError with the SDK's own vocabulary;
+     * nothing propagates from the child as a raw throw.
+     * @param request - which deployment to call, with what input.
+     * @returns the extension's payload.
+     * @throws ManagementError on worker fault, timeout, protocol violation or a
+     *   refused input.
+     */
+    invoke(request: {
+        readonly implementationId: string;
+        readonly input: JsonObject;
+        readonly signal?: AbortSignal;
+        readonly configuration?: Readonly<JsonObject>;
+        /** Trusted host authority for THIS request only. Omitted means deny. */
+        readonly resolvePath?: (candidate: string) => string | Promise<string>;
+    }): Promise<JsonObject>;
+    /** Inspect the exact manifest model, entirely in the managed process. */
+    inspect(modelId: string, options?: WorkerRequestOptions): Promise<ProviderInspectionV1>;
+    /** Load ONLY handles explicitly prepared and verified by the host. No auto-load. */
+    load(modelId: string, options: WorkerRequestOptions & {
+        readonly assets: Readonly<PreparedAssetMapV1>;
+    }): Promise<void>;
+    /** Release a selected model provider's loaded resources without disposing it. */
+    unload(modelId: string, options?: WorkerRequestOptions): Promise<void>;
+    /**
+     * Dispose the worker: ask the child to stop, then kill it after the grace.
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=worker.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"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"}