@voiden/runner 0.1.0-beta.0

package/dist/blockSchemaRegistry.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Block Schema Registry — headless equivalent of TipTap node registration.
+ *
+ * In the electron app, plugins call context.registerVoidenExtension(tiptapNode)
+ * where the TipTap node's addAttributes() defines the block schema (attribute
+ * names and their default values).  The editor uses that schema to normalise
+ * every block before handing it to request-building logic.
+ *
+ * In voiden-runner there is no TipTap / DOM, but we need the same normalisation
+ * so that:
+ *   • Missing attrs are filled with their declared defaults (no more defensive
+ *     `?.` chains scattered through every buildRequest implementation)
+ *   • Block ownership is explicit — the runner knows which plugin owns which
+ *     block type, matching the manifest.json capabilities.blocks.owns contract
+ *
+ * Plugins call context.registerBlockSchema() in their runner.ts onload().
+ * The runner normalises parsed blocks via normalizeBlocks() before passing
+ * them to any registered request builder.
+ */
+/** Mirrors TipTap's Attribute definition — only the parts relevant headlessly. */
+export interface BlockAttrDef {
+    default?: any;
+}
+/** Headless equivalent of a TipTap Node definition. */
+export interface BlockSchemaDef {
+    /** Block type string, e.g. 'gqlquery'.  Matches the YAML `type:` field. */
+    name: string;
+    /** Map of attribute name → definition.  Only `default` is used at runtime. */
+    attrs: Record<string, BlockAttrDef>;
+}
+export declare function registerBlockSchema(def: BlockSchemaDef): void;
+/**
+ * Apply registered schemas to a single block.
+ * Fills in any attrs that are missing from the YAML with their declared defaults.
+ * Blocks whose type has no registered schema are returned unchanged.
+ */
+export declare function normalizeBlock(block: any): any;
+/**
+ * Normalise an array of blocks (a full section) against all registered schemas.
+ * Recurses into nested content arrays so child blocks (e.g. url inside request)
+ * are also normalised.
+ */
+export declare function normalizeBlocks(blocks: any[]): any[];
+export declare function clearSchemas(): void;
+/** Returns the registered schema for a block type, or undefined. */
+export declare function getBlockSchema(type: string): BlockSchemaDef | undefined;
+/** Returns all registered block type names — useful for debugging. */
+export declare function getRegisteredBlockTypes(): string[];
+//# sourceMappingURL=blockSchemaRegistry.d.ts.map

package/dist/blockSchemaRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockSchemaRegistry.d.ts","sourceRoot":"","sources":["../src/blockSchemaRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,kFAAkF;AAClF,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CACpC;AAID,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAe9C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAQpD;AAED,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED,sEAAsE;AACtE,wBAAgB,uBAAuB,IAAI,MAAM,EAAE,CAElD"}

package/dist/blockSchemaRegistry.js

@@ -0,0 +1,68 @@
+/**
+ * Block Schema Registry — headless equivalent of TipTap node registration.
+ *
+ * In the electron app, plugins call context.registerVoidenExtension(tiptapNode)
+ * where the TipTap node's addAttributes() defines the block schema (attribute
+ * names and their default values).  The editor uses that schema to normalise
+ * every block before handing it to request-building logic.
+ *
+ * In voiden-runner there is no TipTap / DOM, but we need the same normalisation
+ * so that:
+ *   • Missing attrs are filled with their declared defaults (no more defensive
+ *     `?.` chains scattered through every buildRequest implementation)
+ *   • Block ownership is explicit — the runner knows which plugin owns which
+ *     block type, matching the manifest.json capabilities.blocks.owns contract
+ *
+ * Plugins call context.registerBlockSchema() in their runner.ts onload().
+ * The runner normalises parsed blocks via normalizeBlocks() before passing
+ * them to any registered request builder.
+ */
+const schemas = new Map();
+export function registerBlockSchema(def) {
+    schemas.set(def.name, def);
+}
+/**
+ * Apply registered schemas to a single block.
+ * Fills in any attrs that are missing from the YAML with their declared defaults.
+ * Blocks whose type has no registered schema are returned unchanged.
+ */
+export function normalizeBlock(block) {
+    const schema = schemas.get(block.type);
+    if (!schema)
+        return block;
+    const normalizedAttrs = {};
+    // Apply declared defaults first, then overlay whatever the YAML provided
+    for (const [key, def] of Object.entries(schema.attrs)) {
+        normalizedAttrs[key] = def.default;
+    }
+    if (block.attrs && typeof block.attrs === 'object') {
+        Object.assign(normalizedAttrs, block.attrs);
+    }
+    return { ...block, attrs: normalizedAttrs };
+}
+/**
+ * Normalise an array of blocks (a full section) against all registered schemas.
+ * Recurses into nested content arrays so child blocks (e.g. url inside request)
+ * are also normalised.
+ */
+export function normalizeBlocks(blocks) {
+    return blocks.map(block => {
+        const normalized = normalizeBlock(block);
+        if (Array.isArray(normalized.content)) {
+            return { ...normalized, content: normalizeBlocks(normalized.content) };
+        }
+        return normalized;
+    });
+}
+export function clearSchemas() {
+    schemas.clear();
+}
+/** Returns the registered schema for a block type, or undefined. */
+export function getBlockSchema(type) {
+    return schemas.get(type);
+}
+/** Returns all registered block type names — useful for debugging. */
+export function getRegisteredBlockTypes() {
+    return Array.from(schemas.keys());
+}
+//# sourceMappingURL=blockSchemaRegistry.js.map

package/dist/blockSchemaRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockSchemaRegistry.js","sourceRoot":"","sources":["../src/blockSchemaRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAA;AAEjD,MAAM,UAAU,mBAAmB,CAAC,GAAmB;IACrD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;AAC5B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAU;IACvC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACtC,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IAEzB,MAAM,eAAe,GAAwB,EAAE,CAAA;IAE/C,yEAAyE;IACzE,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACtD,eAAe,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,OAAO,CAAA;IACpC,CAAC;IACD,IAAI,KAAK,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACnD,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IAC7C,CAAC;IAED,OAAO,EAAE,GAAG,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,CAAA;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,MAAa;IAC3C,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QACxB,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,CAAA;QACxC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YACtC,OAAO,EAAE,GAAG,UAAU,EAAE,OAAO,EAAE,eAAe,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;QACxE,CAAC;QACD,OAAO,UAAU,CAAA;IACnB,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,KAAK,EAAE,CAAA;AACjB,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AAC1B,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,uBAAuB;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA;AACnC,CAAC"}

package/dist/cliElectron.d.ts

@@ -0,0 +1,55 @@
+/**
+ * cliElectron
+ *
+ * Mirrors the shape of window.electron that sendRequestHybrid expects, but
+ * runs entirely in Node.js — no IPC, no Electron main process involved.
+ *
+ * Electron side:   sendRequestHybrid(..., window.electron)
+ * CLI side:        sendRequestHybrid(..., createCliElectron(env))
+ *
+ * request.sendSecure  → delegates to executeSecureRequest from @voiden/executors
+ *                        (same variable replacement + body building + HTTP execution)
+ * env.replaceVariables → replaceEnvVars() from the --env file
+ * state.get           → returns a stub (no active project in CLI)
+ * runtime.*           → stubs for UI-only hooks (preSend vars, linked blocks, etc.)
+ */
+import type { RestApiRequestState } from '@voiden/sdk';
+export declare function createCliElectron(env: Record<string, string>, runtimeVars?: Record<string, any>): {
+    isApp: boolean;
+    request: {
+        /**
+         * Drop-in replacement for window.electron.request.sendSecure.
+         * Injects __cliEnv so sendSecure can access the env map without
+         * changing the RestApiRequestState interface.
+         */
+        sendSecure: (requestState: RestApiRequestState, signalState?: any) => Promise<any>;
+    };
+    env: {
+        /** Drop-in for window.electron.env.replaceVariables (used in auth header building) */
+        replaceVariables: (text: string) => Promise<string>;
+    };
+    state: {
+        /** No active project in headless mode — callers guard with optional chaining */
+        get: () => Promise<{
+            activeDirectory: undefined;
+        }>;
+    };
+    runtime: {
+        /**
+         * preSendProcessHook equivalent — in UI this replaces {{process.xxx}} from
+         * .voiden/.process.env.json.  In CLI we have no project dir, so just return
+         * the state as-is.  Pass --env to cover the same variables.
+         */
+        preSendProcess: (state: RestApiRequestState) => Promise<any>;
+        /** replaceProcessVariablesInText equivalent — identity in CLI */
+        replaceVar: (text: string) => Promise<string>;
+        /** expandLinkedBlocksInDoc equivalent — no linked blocks in CLI */
+        expandLinkedBlocks: (json: any) => Promise<any>;
+        /** getRuntimeVariablesMap equivalent — no capture config in CLI */
+        getRuntimeVariables: (_json: any) => Promise<never[]>;
+        /** saveRuntimeVariables equivalent — no project dir to save to in CLI */
+        saveRuntimeVariables: () => Promise<void>;
+    };
+};
+export type CliElectron = ReturnType<typeof createCliElectron>;
+//# sourceMappingURL=cliElectron.d.ts.map

package/dist/cliElectron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliElectron.d.ts","sourceRoot":"","sources":["../src/cliElectron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AA8EtD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;;;QAK9F;;;;WAIG;mCACwB,mBAAmB,gBAAgB,GAAG;;;QAKjE,sFAAsF;iCAC7D,MAAM;;;QAI/B,gFAAgF;;;;;;QAKhF;;;;WAIG;gCACqB,mBAAmB;QAG3C,iEAAiE;2BAC9C,MAAM;QAEzB,mEAAmE;mCACxC,GAAG;QAE9B,mEAAmE;qCACtC,GAAG;QAEhC,yEAAyE;;;EAI9E;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/cliElectron.js

@@ -0,0 +1,120 @@
+/**
+ * cliElectron
+ *
+ * Mirrors the shape of window.electron that sendRequestHybrid expects, but
+ * runs entirely in Node.js — no IPC, no Electron main process involved.
+ *
+ * Electron side:   sendRequestHybrid(..., window.electron)
+ * CLI side:        sendRequestHybrid(..., createCliElectron(env))
+ *
+ * request.sendSecure  → delegates to executeSecureRequest from @voiden/executors
+ *                        (same variable replacement + body building + HTTP execution)
+ * env.replaceVariables → replaceEnvVars() from the --env file
+ * state.get           → returns a stub (no active project in CLI)
+ * runtime.*           → stubs for UI-only hooks (preSend vars, linked blocks, etc.)
+ */
+import { replaceEnvVars, executeSecureRequest } from '@voiden/executors';
+import { readFile } from 'node:fs/promises';
+import { applyProcessVarsToState } from './runtimeVars.js';
+// ─── Core sendSecure — delegates to the shared executor ───────────────────────
+async function sendSecure(requestState, _signalState) {
+    const env = requestState.__cliEnv ?? {};
+    const adapter = {
+        replaceVar: (text) => Promise.resolve(replaceEnvVars(text, env)),
+        readFile: (filePath) => readFile(filePath),
+        // isElectron defaults to true — executeSecureRequest returns a handoff for
+        // WS/gRPC (same as the Electron app). The socket plugin's onProcessResponse
+        // hook handles the actual connection after receiving the handoff response.
+    };
+    try {
+        const result = await executeSecureRequest(requestState, adapter);
+        // WS / gRPC / GraphQL-subscription: executeSecureRequest returns a handoff
+        // (same as in the Electron app). The socket plugin's onProcessResponse hook
+        // handles the actual connection and updates the response.
+        if (result.kind === 'handoff') {
+            return {
+                // PipelineResponse shape (executor casts adapterResponse as PipelineResponse
+                // for isSpecialProtocol requests)
+                statusCode: 0,
+                statusMessage: 'Handoff',
+                headers: [],
+                contentType: null,
+                body: null,
+                url: result.resolvedUrl,
+                elapsedTime: 0,
+                bytesContent: 0,
+                protocol: result.protocol,
+                requestMeta: {
+                    method: requestState.method,
+                    url: result.resolvedUrl,
+                    headers: Object.entries(result.resolvedHeaders).map(([key, value]) => ({ key, value })),
+                    httpVersion: result.protocol.toUpperCase(),
+                },
+                // Plugin reads handoff data from here in its onProcessResponse handler
+                metadata: {
+                    handoff: {
+                        protocol: result.protocol,
+                        url: result.resolvedUrl,
+                        headers: result.resolvedHeaders,
+                        grpc: result.requestState?.grpc,
+                        body: result.resolvedBody,
+                    },
+                },
+            };
+        }
+        return {
+            status: result.status,
+            statusText: result.statusText,
+            headers: result.headers,
+            body: result.body,
+            protocol: result.protocol,
+            operationType: result.operationType,
+            requestMeta: result.requestMeta,
+        };
+    }
+    catch (error) {
+        return {
+            statusText: error?.message || 'Request failed',
+            error: error?.message || 'Request failed',
+        };
+    }
+}
+// ─── Public factory ───────────────────────────────────────────────────────────
+export function createCliElectron(env, runtimeVars = {}) {
+    return {
+        isApp: false,
+        request: {
+            /**
+             * Drop-in replacement for window.electron.request.sendSecure.
+             * Injects __cliEnv so sendSecure can access the env map without
+             * changing the RestApiRequestState interface.
+             */
+            sendSecure: (requestState, signalState) => sendSecure({ ...requestState, __cliEnv: env }, signalState),
+        },
+        env: {
+            /** Drop-in for window.electron.env.replaceVariables (used in auth header building) */
+            replaceVariables: (text) => Promise.resolve(replaceEnvVars(text, env)),
+        },
+        state: {
+            /** No active project in headless mode — callers guard with optional chaining */
+            get: () => Promise.resolve({ activeDirectory: undefined }),
+        },
+        runtime: {
+            /**
+             * preSendProcessHook equivalent — in UI this replaces {{process.xxx}} from
+             * .voiden/.process.env.json.  In CLI we have no project dir, so just return
+             * the state as-is.  Pass --env to cover the same variables.
+             */
+            preSendProcess: (state) => Promise.resolve(applyProcessVarsToState(state, runtimeVars)),
+            /** replaceProcessVariablesInText equivalent — identity in CLI */
+            replaceVar: (text) => Promise.resolve(text),
+            /** expandLinkedBlocksInDoc equivalent — no linked blocks in CLI */
+            expandLinkedBlocks: (json) => Promise.resolve(json),
+            /** getRuntimeVariablesMap equivalent — no capture config in CLI */
+            getRuntimeVariables: (_json) => Promise.resolve([]),
+            /** saveRuntimeVariables equivalent — no project dir to save to in CLI */
+            saveRuntimeVariables: () => Promise.resolve(),
+        },
+    };
+}
+//# sourceMappingURL=cliElectron.js.map

package/dist/cliElectron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliElectron.js","sourceRoot":"","sources":["../src/cliElectron.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAGxE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAE1D,iFAAiF;AAEjF,KAAK,UAAU,UAAU,CACvB,YAAiC,EACjC,YAAoC;IAEpC,MAAM,GAAG,GAA4B,YAAoB,CAAC,QAAQ,IAAI,EAAE,CAAA;IAExE,MAAM,OAAO,GAAyB;QACpC,UAAU,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACxE,QAAQ,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAClD,2EAA2E;QAC3E,4EAA4E;QAC5E,2EAA2E;KAC5E,CAAA;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,OAAO,CAAC,CAAA;QAEhE,2EAA2E;QAC3E,4EAA4E;QAC5E,0DAA0D;QAC1D,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO;gBACL,6EAA6E;gBAC7E,kCAAkC;gBAClC,UAAU,EAAK,CAAC;gBAChB,aAAa,EAAE,SAAS;gBACxB,OAAO,EAAQ,EAAE;gBACjB,WAAW,EAAI,IAAI;gBACnB,IAAI,EAAW,IAAI;gBACnB,GAAG,EAAY,MAAM,CAAC,WAAW;gBACjC,WAAW,EAAI,CAAC;gBAChB,YAAY,EAAG,CAAC;gBAChB,QAAQ,EAAO,MAAM,CAAC,QAAQ;gBAC9B,WAAW,EAAE;oBACX,MAAM,EAAO,YAAY,CAAC,MAAM;oBAChC,GAAG,EAAU,MAAM,CAAC,WAAW;oBAC/B,OAAO,EAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;oBAC3F,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE;iBAC3C;gBACD,uEAAuE;gBACvE,QAAQ,EAAE;oBACR,OAAO,EAAE;wBACP,QAAQ,EAAE,MAAM,CAAC,QAAQ;wBACzB,GAAG,EAAO,MAAM,CAAC,WAAW;wBAC5B,OAAO,EAAG,MAAM,CAAC,eAAe;wBAChC,IAAI,EAAM,MAAM,CAAC,YAAY,EAAE,IAAI;wBACnC,IAAI,EAAM,MAAM,CAAC,YAAY;qBAC9B;iBACF;aACF,CAAA;QACH,CAAC;QAED,OAAO;YACL,MAAM,EAAS,MAAM,CAAC,MAAM;YAC5B,UAAU,EAAK,MAAM,CAAC,UAAU;YAChC,OAAO,EAAQ,MAAM,CAAC,OAAO;YAC7B,IAAI,EAAW,MAAM,CAAC,IAAI;YAC1B,QAAQ,EAAO,MAAM,CAAC,QAAQ;YAC9B,aAAa,EAAE,MAAM,CAAC,aAAa;YACnC,WAAW,EAAI,MAAM,CAAC,WAAW;SAClC,CAAA;IAEH,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO;YACL,UAAU,EAAE,KAAK,EAAE,OAAO,IAAI,gBAAgB;YAC9C,KAAK,EAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB;SAC/C,CAAA;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AAEjF,MAAM,UAAU,iBAAiB,CAAC,GAA2B,EAAE,cAAmC,EAAE;IAClG,OAAO;QACL,KAAK,EAAE,KAAK;QAEZ,OAAO,EAAE;YACP;;;;eAIG;YACH,UAAU,EAAE,CAAC,YAAiC,EAAE,WAAiB,EAAE,EAAE,CACnE,UAAU,CAAC,EAAE,GAAG,YAAY,EAAE,QAAQ,EAAE,GAAG,EAAS,EAAE,WAAW,CAAC;SACrE;QAED,GAAG,EAAE;YACH,sFAAsF;YACtF,gBAAgB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;SAC/E;QAED,KAAK,EAAE;YACL,gFAAgF;YAChF,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;SAC3D;QAED,OAAO,EAAE;YACP;;;;eAIG;YACH,cAAc,EAAE,CAAC,KAA0B,EAAE,EAAE,CAC7C,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,KAAK,EAAE,WAAW,CAAwB,CAAC;YAErF,iEAAiE;YACjE,UAAU,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;YAEnD,mEAAmE;YACnE,kBAAkB,EAAE,CAAC,IAAS,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;YAExD,mEAAmE;YACnE,mBAAmB,EAAE,CAAC,KAAU,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAExD,yEAAyE;YACzE,oBAAoB,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;SAC9C;KACF,CAAA;AACH,CAAC"}

package/dist/headlessContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * createHeadlessPluginContext
+ *
+ * Returns a plugin context that can be passed to a core-extension's plugin.ts
+ * `onload()` in a headless Node.js environment (voiden-runner CLI).
+ *
+ * • All UI-related methods (registerVoidenExtension, registerSidebarTab, …)
+ *   are no-ops — plugin.ts guards UI setup behind `if (context.ui?.components)`.
+ * • pipeline.registerHook wires directly into the shared hookRegistry from
+ *   @voiden/executors so that hooks fire when executeRequestPipeline runs.
+ * • onBuildRequest / onProcessResponse wire into the shared requestOrchestrator
+ *   from @voiden/executors — the same orchestration path used by the Electron app.
+ *   If a plugin is disabled its handlers are never registered, so requests
+ *   that require that plugin fail gracefully (same behaviour as the app).
+ */
+import type { RunnerContext } from '@voiden/sdk/runner';
+export declare function createHeadlessPluginContext(extensionId: string, verbose?: boolean): RunnerContext;
+//# sourceMappingURL=headlessContext.d.ts.map

package/dist/headlessContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headlessContext.d.ts","sourceRoot":"","sources":["../src/headlessContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EAAE,aAAa,EAA+C,MAAM,oBAAoB,CAAA;AAEpG,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,OAAe,GACvB,aAAa,CA0Ef"}

package/dist/headlessContext.js

@@ -0,0 +1,85 @@
+/**
+ * createHeadlessPluginContext
+ *
+ * Returns a plugin context that can be passed to a core-extension's plugin.ts
+ * `onload()` in a headless Node.js environment (voiden-runner CLI).
+ *
+ * • All UI-related methods (registerVoidenExtension, registerSidebarTab, …)
+ *   are no-ops — plugin.ts guards UI setup behind `if (context.ui?.components)`.
+ * • pipeline.registerHook wires directly into the shared hookRegistry from
+ *   @voiden/executors so that hooks fire when executeRequestPipeline runs.
+ * • onBuildRequest / onProcessResponse wire into the shared requestOrchestrator
+ *   from @voiden/executors — the same orchestration path used by the Electron app.
+ *   If a plugin is disabled its handlers are never registered, so requests
+ *   that require that plugin fail gracefully (same behaviour as the app).
+ */
+import { hookRegistry, requestOrchestrator, executeWebSocket, executeGrpc } from '@voiden/executors';
+import { registerBlockSchema } from './blockSchemaRegistry.js';
+export function createHeadlessPluginContext(extensionId, verbose = false) {
+    return {
+        // ── Pipeline hook registration (for hook plugins: scripting, auth, etc.) ─
+        pipeline: {
+            registerHook: (stage, handler, priority) => {
+                hookRegistry.registerHook(extensionId, stage, handler, priority ?? 100);
+            },
+        },
+        // ── Request builder registration (for parser plugins: graphql, sockets, rest) ─
+        // Parser plugins call this in their runner.ts onload() to register their
+        // block→request conversion function with the shared orchestrator.
+        // The SDK expects (request, blocks), but orchestrator uses (request, editor).
+        onBuildRequest: (handler) => {
+            requestOrchestrator.onBuildRequest(async (request, editor) => {
+                const blocks = editor.getJSON()?.content ?? [];
+                return (await handler(request, blocks)) ?? request;
+            });
+        },
+        // Backward-compat alias: old compiled dist/*/runner.js files call
+        // context.registerRequestBuilder(fn) where fn takes (blocks[]) directly.
+        registerRequestBuilder: (fn) => {
+            requestOrchestrator.onBuildRequest(async (request, editor) => {
+                const blocks = editor.getJSON()?.content ?? [];
+                const built = await fn(blocks);
+                return built ?? request;
+            });
+        },
+        // ── Response handler registration ──────────────────────────────────────
+        onProcessResponse: (handler) => {
+            requestOrchestrator.onProcessResponse(async (response, editor, request) => {
+                const blocks = editor.getJSON()?.content ?? [];
+                await handler(response, blocks, request);
+            });
+        },
+        // ── Block schema registration (headless equivalent of registerVoidenExtension) ─
+        registerBlockSchema: (def) => {
+            registerBlockSchema(def);
+        },
+        // ── Protocol executors (for socket plugins) ───────────────────────────
+        protocols: {
+            executeWebSocket: (req) => executeWebSocket(req),
+            executeGrpc: (req) => executeGrpc(req),
+        },
+        // ── Verbosity ────────────────────────────────────────────────────────
+        verbose,
+        // ── Reporting ────────────────────────────────────────────────────────
+        report: {
+            add: (_entry) => {
+                // Runner implementation handles report aggregation via metadata.reportEntries
+                // for now. This can be expanded to a dedicated report collector.
+            },
+            getEntries: () => [],
+        },
+        // ── UI stubs (all no-ops to satisfy type system if needed) ───────────
+        ...{
+            registerVoidenExtension: () => { },
+            registerCodemirrorExtension: () => { },
+            registerLinkableNodeTypes: () => { },
+            registerNodeDisplayNames: () => { },
+            registerSidebarTab: () => { },
+            addVoidenSlashGroup: () => { },
+            exposeHelpers: () => { },
+            paste: { registerBlockOwner: () => { } },
+            project: { openFile: () => { } },
+        },
+    };
+}
+//# sourceMappingURL=headlessContext.js.map

package/dist/headlessContext.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}