@superdoc-dev/sdk 1.0.0-alpha.2 → 1.0.0-alpha.22

package/dist/runtime/host.js

@@ -0,0 +1,347 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { buildOperationArgv, resolveInvocation, } from './transport-common.js';
+import { SuperDocCliError } from './errors.js';
+const HOST_PROTOCOL_VERSION = '1.0';
+const REQUIRED_FEATURES = ['cli.invoke', 'host.shutdown'];
+const CHANGE_MODES = ['direct', 'tracked'];
+const JSON_RPC_TIMEOUT_CODE = -32011;
+/**
+ * Transport that communicates with a long-lived CLI host process over JSON-RPC stdio.
+ */
+export class HostTransport {
+    cliBin;
+    env;
+    startupTimeoutMs;
+    shutdownTimeoutMs;
+    requestTimeoutMs;
+    watchdogTimeoutMs;
+    maxQueueDepth;
+    defaultChangeMode;
+    user;
+    child = null;
+    stdoutReader = null;
+    pending = new Map();
+    nextRequestId = 1;
+    connecting = null;
+    stopping = false;
+    constructor(options) {
+        this.cliBin = options.cliBin;
+        this.env = options.env;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? 5_000;
+        this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? 5_000;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+        this.watchdogTimeoutMs = options.watchdogTimeoutMs ?? 30_000;
+        this.maxQueueDepth = options.maxQueueDepth ?? 100;
+        if (options.defaultChangeMode != null && !CHANGE_MODES.includes(options.defaultChangeMode)) {
+            throw new SuperDocCliError('defaultChangeMode must be "direct" or "tracked".', {
+                code: 'INVALID_ARGUMENT',
+                details: { defaultChangeMode: options.defaultChangeMode },
+            });
+        }
+        this.defaultChangeMode = options.defaultChangeMode;
+        this.user = options.user;
+    }
+    async connect() {
+        await this.ensureConnected();
+    }
+    async dispose() {
+        if (!this.child)
+            return;
+        this.stopping = true;
+        const child = this.child;
+        try {
+            await this.sendJsonRpcRequest('host.shutdown', {}, this.shutdownTimeoutMs);
+        }
+        catch {
+            // ignore and force shutdown below
+        }
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                child.kill('SIGKILL');
+                resolve();
+            }, this.shutdownTimeoutMs);
+            child.once('close', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+        this.cleanupProcess(null);
+        this.stopping = false;
+    }
+    async invoke(operation, params = {}, options = {}) {
+        await this.ensureConnected();
+        const argv = buildOperationArgv(operation, params, options, this.requestTimeoutMs, this.defaultChangeMode, this.user);
+        const stdinBase64 = options.stdinBytes ? Buffer.from(options.stdinBytes).toString('base64') : '';
+        const watchdogTimeout = this.resolveWatchdogTimeout(options.timeoutMs);
+        const response = await this.sendJsonRpcRequest('cli.invoke', {
+            argv,
+            stdinBase64,
+        }, watchdogTimeout);
+        if (typeof response !== 'object' || response == null || Array.isArray(response)) {
+            throw new SuperDocCliError('Host returned invalid cli.invoke result.', {
+                code: 'HOST_PROTOCOL_ERROR',
+                details: { result: response },
+            });
+        }
+        const resultRecord = response;
+        return resultRecord.data;
+    }
+    async ensureConnected() {
+        if (this.child && !this.child.killed) {
+            return;
+        }
+        if (this.connecting) {
+            await this.connecting;
+            return;
+        }
+        this.connecting = this.startHostProcess();
+        try {
+            await this.connecting;
+        }
+        finally {
+            this.connecting = null;
+        }
+    }
+    async startHostProcess() {
+        const { command, prefixArgs } = resolveInvocation(this.cliBin);
+        const args = [...prefixArgs, 'host', '--stdio'];
+        const child = spawn(command, args, {
+            env: {
+                ...process.env,
+                ...(this.env ?? {}),
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        const stdoutReader = createInterface({
+            input: child.stdout,
+            crlfDelay: Number.POSITIVE_INFINITY,
+        });
+        this.stdoutReader = stdoutReader;
+        stdoutReader.on('line', (line) => {
+            this.onStdoutLine(line);
+        });
+        child.stderr.on('data', () => {
+            // stderr intentionally ignored in host mode
+        });
+        child.on('error', (error) => {
+            this.handleDisconnect(new SuperDocCliError('Host process failed.', {
+                code: 'HOST_DISCONNECTED',
+                details: {
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            }));
+        });
+        child.on('close', (code, signal) => {
+            if (this.stopping) {
+                this.cleanupProcess(null);
+                return;
+            }
+            this.handleDisconnect(new SuperDocCliError('Host process disconnected.', {
+                code: 'HOST_DISCONNECTED',
+                details: { exitCode: code, signal },
+            }));
+        });
+        try {
+            const capabilities = await this.sendJsonRpcRequest('host.capabilities', {}, this.startupTimeoutMs);
+            this.assertCapabilities(capabilities);
+        }
+        catch (error) {
+            const normalized = error instanceof SuperDocCliError
+                ? error
+                : new SuperDocCliError('Host handshake failed.', {
+                    code: 'HOST_HANDSHAKE_FAILED',
+                    details: {
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            this.handleDisconnect(normalized);
+            throw normalized;
+        }
+    }
+    assertCapabilities(response) {
+        if (typeof response !== 'object' || response == null || Array.isArray(response)) {
+            throw new SuperDocCliError('Host capabilities response is invalid.', {
+                code: 'HOST_HANDSHAKE_FAILED',
+                details: { response },
+            });
+        }
+        const record = response;
+        const protocolVersion = record.protocolVersion;
+        const features = record.features;
+        if (protocolVersion !== HOST_PROTOCOL_VERSION) {
+            throw new SuperDocCliError('Host protocol version is unsupported.', {
+                code: 'HOST_HANDSHAKE_FAILED',
+                details: {
+                    expected: HOST_PROTOCOL_VERSION,
+                    actual: protocolVersion,
+                },
+            });
+        }
+        if (!Array.isArray(features) || features.some((f) => typeof f !== 'string')) {
+            throw new SuperDocCliError('Host capabilities.features must be a string array.', {
+                code: 'HOST_HANDSHAKE_FAILED',
+                details: { features },
+            });
+        }
+        for (const requiredFeature of REQUIRED_FEATURES) {
+            if (!features.includes(requiredFeature)) {
+                throw new SuperDocCliError(`Host does not support required feature: ${requiredFeature}`, {
+                    code: 'HOST_HANDSHAKE_FAILED',
+                    details: { features },
+                });
+            }
+        }
+    }
+    resolveWatchdogTimeout(timeoutMsOverride) {
+        if (timeoutMsOverride != null) {
+            return Math.max(this.watchdogTimeoutMs, timeoutMsOverride + 1_000);
+        }
+        if (this.requestTimeoutMs != null) {
+            return Math.max(this.watchdogTimeoutMs, this.requestTimeoutMs + 1_000);
+        }
+        return this.watchdogTimeoutMs;
+    }
+    async sendJsonRpcRequest(method, params, watchdogTimeoutMs) {
+        const child = this.child;
+        if (!child || !child.stdin.writable) {
+            throw new SuperDocCliError('Host process is not available.', {
+                code: 'HOST_DISCONNECTED',
+            });
+        }
+        if (this.pending.size >= this.maxQueueDepth) {
+            throw new SuperDocCliError('Host request queue is full.', {
+                code: 'HOST_QUEUE_FULL',
+                details: { maxQueueDepth: this.maxQueueDepth },
+            });
+        }
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        const payload = JSON.stringify({
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        });
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new SuperDocCliError(`Host watchdog timed out waiting for ${method}.`, {
+                    code: 'HOST_TIMEOUT',
+                    details: { method, timeoutMs: watchdogTimeoutMs },
+                }));
+                this.handleDisconnect(new SuperDocCliError('Host watchdog timeout; host process will be restarted on next request.', {
+                    code: 'HOST_DISCONNECTED',
+                    details: { method, timeoutMs: watchdogTimeoutMs },
+                }));
+            }, watchdogTimeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            child.stdin.write(`${payload}\n`, (error) => {
+                if (!error)
+                    return;
+                const pending = this.pending.get(id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(id);
+                reject(new SuperDocCliError('Failed to write request to host process.', {
+                    code: 'HOST_DISCONNECTED',
+                    details: { method, message: error.message },
+                }));
+            });
+        });
+        return promise;
+    }
+    onStdoutLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof parsed !== 'object' || parsed == null || Array.isArray(parsed)) {
+            return;
+        }
+        const record = parsed;
+        if (record.jsonrpc !== '2.0') {
+            return;
+        }
+        // Notification (no id) — reserved for future eventing
+        if ('method' in record && !('id' in record)) {
+            return;
+        }
+        const idRaw = record.id;
+        if (typeof idRaw !== 'number') {
+            return;
+        }
+        const pending = this.pending.get(idRaw);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(idRaw);
+        if ('error' in record) {
+            pending.reject(this.mapJsonRpcError(record.error));
+            return;
+        }
+        pending.resolve(record.result);
+    }
+    mapJsonRpcError(rawError) {
+        if (typeof rawError !== 'object' || rawError == null || Array.isArray(rawError)) {
+            return new SuperDocCliError('Host returned an unknown JSON-RPC error.', {
+                code: 'HOST_PROTOCOL_ERROR',
+                details: { error: rawError },
+            });
+        }
+        const error = rawError;
+        const data = error.data;
+        const cliCode = typeof data?.cliCode === 'string' ? data.cliCode : undefined;
+        const cliMessage = typeof data?.message === 'string' ? data.message : undefined;
+        const exitCode = typeof data?.exitCode === 'number' ? data.exitCode : undefined;
+        if (cliCode) {
+            return new SuperDocCliError(cliMessage ?? error.message ?? 'Command failed.', {
+                code: cliCode,
+                details: data?.details,
+                exitCode,
+            });
+        }
+        if (error.code === JSON_RPC_TIMEOUT_CODE) {
+            return new SuperDocCliError(error.message, {
+                code: 'TIMEOUT',
+                details: data,
+            });
+        }
+        return new SuperDocCliError(error.message, {
+            code: 'COMMAND_FAILED',
+            details: data,
+        });
+    }
+    handleDisconnect(error) {
+        this.cleanupProcess(error);
+    }
+    cleanupProcess(error) {
+        const child = this.child;
+        if (child) {
+            child.removeAllListeners();
+            child.kill('SIGKILL');
+        }
+        this.child = null;
+        if (this.stdoutReader) {
+            this.stdoutReader.removeAllListeners();
+            this.stdoutReader.close();
+            this.stdoutReader = null;
+        }
+        const pendingEntries = Array.from(this.pending.values());
+        this.pending.clear();
+        const rejection = error ??
+            new SuperDocCliError('Host process was disposed while request was in flight.', {
+                code: 'HOST_DISCONNECTED',
+            });
+        for (const pending of pendingEntries) {
+            clearTimeout(pending.timer);
+            pending.reject(rejection);
+        }
+    }
+}

package/dist/runtime/process.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var host = require('./host.cjs');
+var embeddedCli = require('./embedded-cli.cjs');
+
+/**
+ * Internal runtime that delegates CLI invocations to a persistent host transport.
+ *
+ * Resolves the CLI binary and creates a {@link HostTransport} that communicates
+ * with a long-lived `superdoc host --stdio` process.
+ */
+class SuperDocRuntime {
+    transport;
+    constructor(options = {}) {
+        const cliBin = options.env?.SUPERDOC_CLI_BIN ?? process.env.SUPERDOC_CLI_BIN ?? embeddedCli.resolveEmbeddedCliBinary();
+        this.transport = new host.HostTransport({
+            cliBin,
+            ...options,
+        });
+    }
+    async connect() {
+        await this.transport.connect();
+    }
+    async dispose() {
+        await this.transport.dispose();
+    }
+    async invoke(operation, params = {}, options = {}) {
+        return this.transport.invoke(operation, params, options);
+    }
+}
+
+exports.SuperDocRuntime = SuperDocRuntime;

package/dist/runtime/process.d.ts

@@ -0,0 +1,16 @@
+import type { InvokeOptions, OperationParamSpec, OperationSpec, SuperDocClientOptions } from './transport-common.js';
+/**
+ * Internal runtime that delegates CLI invocations to a persistent host transport.
+ *
+ * Resolves the CLI binary and creates a {@link HostTransport} that communicates
+ * with a long-lived `superdoc host --stdio` process.
+ */
+export declare class SuperDocRuntime {
+    private readonly transport;
+    constructor(options?: SuperDocClientOptions);
+    connect(): Promise<void>;
+    dispose(): Promise<void>;
+    invoke<TData = unknown>(operation: OperationSpec, params?: Record<string, unknown>, options?: InvokeOptions): Promise<TData>;
+}
+export type { InvokeOptions, OperationParamSpec, OperationSpec, SuperDocClientOptions };
+//# sourceMappingURL=process.d.ts.map

package/dist/runtime/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/runtime/process.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAErH;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;gBAE9B,OAAO,GAAE,qBAA0B;IASzC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,MAAM,CAAC,KAAK,GAAG,OAAO,EAC1B,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACpC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,KAAK,CAAC;CAGlB;AAED,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,aAAa,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/runtime/process.js

@@ -0,0 +1,27 @@
+import { HostTransport } from './host.js';
+import { resolveEmbeddedCliBinary } from './embedded-cli.js';
+/**
+ * Internal runtime that delegates CLI invocations to a persistent host transport.
+ *
+ * Resolves the CLI binary and creates a {@link HostTransport} that communicates
+ * with a long-lived `superdoc host --stdio` process.
+ */
+export class SuperDocRuntime {
+    transport;
+    constructor(options = {}) {
+        const cliBin = options.env?.SUPERDOC_CLI_BIN ?? process.env.SUPERDOC_CLI_BIN ?? resolveEmbeddedCliBinary();
+        this.transport = new HostTransport({
+            cliBin,
+            ...options,
+        });
+    }
+    async connect() {
+        await this.transport.connect();
+    }
+    async dispose() {
+        await this.transport.dispose();
+    }
+    async invoke(operation, params = {}, options = {}) {
+        return this.transport.invoke(operation, params, options);
+    }
+}

package/dist/runtime/transport-common.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+function hasExtension(filePath, extension) {
+    return filePath.toLowerCase().endsWith(extension);
+}
+function resolveInvocation(cliBin) {
+    if (hasExtension(cliBin, '.js')) {
+        return { command: 'node', prefixArgs: [cliBin] };
+    }
+    if (hasExtension(cliBin, '.ts')) {
+        return { command: 'bun', prefixArgs: [cliBin] };
+    }
+    return { command: cliBin, prefixArgs: [] };
+}
+/**
+ * Build the CLI argument vector for an operation invocation.
+ *
+ * Key design choices vs old SDK:
+ * - changeMode injection BEFORE argv loop, not after. changeMode is already a
+ *   param in operationSpec.params (envelope param for mutations). Appending after
+ *   the loop would duplicate it.
+ * - Booleans encoded as `--flag true`/`--flag false` explicitly, matching current CLI.
+ */
+function buildOperationArgv(operation, params, options, runtimeTimeoutMs, defaultChangeMode, user) {
+    // Inject defaultChangeMode into params BEFORE encoding — single source of truth.
+    let normalizedParams = defaultChangeMode != null && params.changeMode == null && operation.params.some((p) => p.name === 'changeMode')
+        ? { ...params, changeMode: defaultChangeMode }
+        : params;
+    // Inject user identity for doc.open when not already specified.
+    if (user != null && operation.operationId === 'doc.open') {
+        if (normalizedParams.userName == null && user.name) {
+            normalizedParams = { ...normalizedParams, userName: user.name };
+        }
+        if (normalizedParams.userEmail == null && user.email) {
+            normalizedParams = { ...normalizedParams, userEmail: user.email };
+        }
+    }
+    const argv = [...operation.commandTokens];
+    for (const spec of operation.params) {
+        const value = normalizedParams[spec.name];
+        if (value == null)
+            continue;
+        const flag = `--${spec.flag ?? spec.name}`;
+        switch (spec.kind) {
+            case 'doc':
+                argv.push(String(value));
+                break;
+            case 'flag':
+                if (spec.type === 'boolean') {
+                    // Explicit true/false — matches current CLI operation-executor.ts.
+                    argv.push(flag, value === true ? 'true' : 'false');
+                }
+                else if (spec.type === 'string[]') {
+                    if (Array.isArray(value)) {
+                        for (const entry of value)
+                            argv.push(flag, String(entry));
+                    }
+                }
+                else {
+                    argv.push(flag, String(value));
+                }
+                break;
+            case 'jsonFlag':
+                argv.push(flag, JSON.stringify(value));
+                break;
+        }
+    }
+    const timeoutMs = options.timeoutMs ?? runtimeTimeoutMs;
+    if (timeoutMs != null) {
+        argv.push('--timeout-ms', String(timeoutMs));
+    }
+    argv.push('--output', 'json');
+    return argv;
+}
+
+exports.buildOperationArgv = buildOperationArgv;
+exports.resolveInvocation = resolveInvocation;

package/dist/runtime/transport-common.d.ts

@@ -0,0 +1,49 @@
+export type ParamType = 'string' | 'number' | 'boolean' | 'json' | 'string[]';
+export type ParamKind = 'doc' | 'flag' | 'jsonFlag';
+export interface OperationParamSpec {
+    readonly name: string;
+    readonly kind: ParamKind;
+    readonly flag?: string;
+    readonly type: ParamType;
+    readonly required?: boolean;
+}
+export interface OperationSpec {
+    readonly operationId: string;
+    readonly commandTokens: readonly string[];
+    readonly params: readonly OperationParamSpec[];
+}
+export interface InvokeOptions {
+    timeoutMs?: number;
+    stdinBytes?: Uint8Array;
+}
+export type ChangeMode = 'direct' | 'tracked';
+export interface UserIdentity {
+    name: string;
+    email?: string;
+}
+export interface SuperDocClientOptions {
+    env?: Record<string, string | undefined>;
+    startupTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    watchdogTimeoutMs?: number;
+    maxQueueDepth?: number;
+    defaultChangeMode?: ChangeMode;
+    user?: UserIdentity;
+}
+export interface CliInvocation {
+    command: string;
+    prefixArgs: string[];
+}
+export declare function resolveInvocation(cliBin: string): CliInvocation;
+/**
+ * Build the CLI argument vector for an operation invocation.
+ *
+ * Key design choices vs old SDK:
+ * - changeMode injection BEFORE argv loop, not after. changeMode is already a
+ *   param in operationSpec.params (envelope param for mutations). Appending after
+ *   the loop would duplicate it.
+ * - Booleans encoded as `--flag true`/`--flag false` explicitly, matching current CLI.
+ */
+export declare function buildOperationArgv(operation: OperationSpec, params: Record<string, unknown>, options: InvokeOptions, runtimeTimeoutMs: number | undefined, defaultChangeMode?: ChangeMode, user?: UserIdentity): string[];
+//# sourceMappingURL=transport-common.d.ts.map

package/dist/runtime/transport-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-common.d.ts","sourceRoot":"","sources":["../../src/runtime/transport-common.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,CAAC;AAC9E,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,UAAU,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAChD;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,UAAU,CAAC;IAC/B,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAMD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAU/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,aAAa,EACtB,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,iBAAiB,CAAC,EAAE,UAAU,EAC9B,IAAI,CAAC,EAAE,YAAY,GAClB,MAAM,EAAE,CAsDV"}

package/dist/runtime/transport-common.js

@@ -0,0 +1,72 @@
+function hasExtension(filePath, extension) {
+    return filePath.toLowerCase().endsWith(extension);
+}
+export function resolveInvocation(cliBin) {
+    if (hasExtension(cliBin, '.js')) {
+        return { command: 'node', prefixArgs: [cliBin] };
+    }
+    if (hasExtension(cliBin, '.ts')) {
+        return { command: 'bun', prefixArgs: [cliBin] };
+    }
+    return { command: cliBin, prefixArgs: [] };
+}
+/**
+ * Build the CLI argument vector for an operation invocation.
+ *
+ * Key design choices vs old SDK:
+ * - changeMode injection BEFORE argv loop, not after. changeMode is already a
+ *   param in operationSpec.params (envelope param for mutations). Appending after
+ *   the loop would duplicate it.
+ * - Booleans encoded as `--flag true`/`--flag false` explicitly, matching current CLI.
+ */
+export function buildOperationArgv(operation, params, options, runtimeTimeoutMs, defaultChangeMode, user) {
+    // Inject defaultChangeMode into params BEFORE encoding — single source of truth.
+    let normalizedParams = defaultChangeMode != null && params.changeMode == null && operation.params.some((p) => p.name === 'changeMode')
+        ? { ...params, changeMode: defaultChangeMode }
+        : params;
+    // Inject user identity for doc.open when not already specified.
+    if (user != null && operation.operationId === 'doc.open') {
+        if (normalizedParams.userName == null && user.name) {
+            normalizedParams = { ...normalizedParams, userName: user.name };
+        }
+        if (normalizedParams.userEmail == null && user.email) {
+            normalizedParams = { ...normalizedParams, userEmail: user.email };
+        }
+    }
+    const argv = [...operation.commandTokens];
+    for (const spec of operation.params) {
+        const value = normalizedParams[spec.name];
+        if (value == null)
+            continue;
+        const flag = `--${spec.flag ?? spec.name}`;
+        switch (spec.kind) {
+            case 'doc':
+                argv.push(String(value));
+                break;
+            case 'flag':
+                if (spec.type === 'boolean') {
+                    // Explicit true/false — matches current CLI operation-executor.ts.
+                    argv.push(flag, value === true ? 'true' : 'false');
+                }
+                else if (spec.type === 'string[]') {
+                    if (Array.isArray(value)) {
+                        for (const entry of value)
+                            argv.push(flag, String(entry));
+                    }
+                }
+                else {
+                    argv.push(flag, String(value));
+                }
+                break;
+            case 'jsonFlag':
+                argv.push(flag, JSON.stringify(value));
+                break;
+        }
+    }
+    const timeoutMs = options.timeoutMs ?? runtimeTimeoutMs;
+    if (timeoutMs != null) {
+        argv.push('--timeout-ms', String(timeoutMs));
+    }
+    argv.push('--output', 'json');
+    return argv;
+}