@code-yeongyu/senpi 2026.7.10 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/local-module-loader.ts

@@ -0,0 +1,108 @@
+import { join, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { BridgeConnectionConfig } from "../../bridge/protocol.ts";
+import {
+	RESERVED_AGENT_TOOL,
+	RESERVED_OUTPUT_TOOL,
+	TIMEOUT_PAUSE_OP,
+	TIMEOUT_RESUME_OP,
+} from "../../bridge/reserved.ts";
+import type { JavaScriptKernelOptions as BaseJavaScriptKernelOptions } from "./kernel-contract.ts";
+import { rewriteImports } from "./rewrite-imports.ts";
+
+const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
+
+export interface LocalModuleLoaderOptions {
+	readonly cwd: string;
+	readonly localRoots?: Readonly<Record<string, string>>;
+	readonly artifactsDir?: string;
+}
+
+export type JavaScriptKernelOptions = BaseJavaScriptKernelOptions & LocalModuleLoaderOptions;
+
+export function localBridgeConnection(options: LocalModuleLoaderOptions): BridgeConnectionConfig {
+	return {
+		port: 1,
+		token: "local",
+		...(options.localRoots ? { localRoots: { ...options.localRoots } } : {}),
+		...(options.artifactsDir ? { artifactsDir: options.artifactsDir } : {}),
+	};
+}
+
+type RuntimeModuleContext = {
+	readonly cwdUrl: string;
+	readonly localRootUrls: Readonly<Record<string, string>>;
+	readonly reservedAgentTool: string;
+	readonly reservedOutputTool: string;
+	readonly timeoutPauseOp: string;
+	readonly timeoutResumeOp: string;
+};
+
+function directoryUrl(directory: string): string {
+	return pathToFileURL(`${resolve(directory)}${sep}`).href;
+}
+
+function runtimeContext(options: LocalModuleLoaderOptions): RuntimeModuleContext {
+	const roots: Record<string, string> = {};
+	for (const [scheme, root] of Object.entries(options.localRoots ?? {})) {
+		roots[scheme.toLowerCase()] = directoryUrl(root);
+	}
+	if (options.artifactsDir && roots["local"] === undefined) {
+		roots["local"] = directoryUrl(join(options.artifactsDir, "local"));
+	}
+	return {
+		cwdUrl: directoryUrl(options.cwd),
+		localRootUrls: roots,
+		reservedAgentTool: RESERVED_AGENT_TOOL,
+		reservedOutputTool: RESERVED_OUTPUT_TOOL,
+		timeoutPauseOp: TIMEOUT_PAUSE_OP,
+		timeoutResumeOp: TIMEOUT_RESUME_OP,
+	};
+}
+
+function loaderPrelude(context: RuntimeModuleContext): string {
+	const serialized = JSON.stringify(context);
+	return [
+		`globalThis.__senpi_module_context__ = ${serialized};`,
+		"globalThis.__senpi_reserved_agent_tool__ = globalThis.__senpi_module_context__.reservedAgentTool;",
+		"globalThis.__senpi_reserved_output_tool__ = globalThis.__senpi_module_context__.reservedOutputTool;",
+		"globalThis.__senpi_timeout_pause_op__ = globalThis.__senpi_module_context__.timeoutPauseOp;",
+		"globalThis.__senpi_timeout_resume_op__ = globalThis.__senpi_module_context__.timeoutResumeOp;",
+		"globalThis.__senpi_import__ = async (source, options) => {",
+		"  const context = globalThis.__senpi_module_context__;",
+		"  const specifier = String(source);",
+		"  const match = /^([a-z][a-z0-9+.-]*):\\/\\/(.*)$/i.exec(specifier);",
+		"  let target = specifier;",
+		"  if (match) {",
+		"    const scheme = match[1].toLowerCase();",
+		"    const root = context.localRootUrls[scheme];",
+		"    if (!root) throw new Error('Unsupported module protocol: ' + specifier);",
+		"    let relative;",
+		"    try { relative = decodeURIComponent(match[2].replaceAll('\\\\', '/')); }",
+		"    catch { throw new Error('Invalid module URL encoding: ' + specifier); }",
+		"    if (relative.startsWith('/') || relative.split('/').includes('..')) {",
+		"      throw new Error('Module path escapes ' + scheme + ':// root: ' + specifier);",
+		"    }",
+		"    target = new URL(relative, root).href;",
+		"  } else if (specifier.startsWith('./') || specifier.startsWith('../') || specifier === '.' || specifier === '..') {",
+		"    target = new URL(specifier, context.cwdUrl).href;",
+		"  } else if (specifier.startsWith('/') || /^[A-Za-z]:[\\\\/]/.test(specifier)) {",
+		"    const urlModule = await import('node:url');",
+		"    target = urlModule.pathToFileURL(specifier).href;",
+		"  }",
+		"  return options === undefined ? import(target) : import(target, options);",
+		"};",
+	].join("\n");
+}
+
+export class LocalModuleLoader {
+	readonly #prelude: string;
+
+	constructor(options: LocalModuleLoaderOptions) {
+		this.#prelude = loaderPrelude(runtimeContext(options));
+	}
+
+	prepareCell(code: string): string {
+		return `${PREPARED_CELL_PREFIX}${JSON.stringify({ prelude: this.#prelude, code: rewriteImports(code) })}`;
+	}
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/prelude.ts

@@ -1,13 +1,15 @@
 export const JAVASCRIPT_KERNEL_PRELUDE = [
 	"print(...values): write stdout text.",
-	"display(value): emit JSON or image display output.",
+	"display(value): emit JSON, image, or markdown display output.",
 	"log(message): emit a progress log line.",
 	"phase(title): emit a progress phase.",
 	"env(key?, value?): read, set, or list environment values.",
-	"read(path, offset?, limit?): read UTF-8 text with optional 1-indexed line slicing.",
-	"write(path, content): write UTF-8 text and return the resolved path.",
+	"read(path, options?): read UTF-8 text; plain paths use cwd and local:// uses the session local root.",
+	"write(path, content): write UTF-8 or binary data and return the resolved path.",
 	"tool.<name>(args): request a host tool call through the bridge.",
-	"completion(prompt, opts?): request a host completion bridge call.",
-	"parallel(thunks): run async thunks through the configured bounded pool.",
-	"pipeline(items, ...stages): map items through staged async transforms.",
+	"completion(prompt, options?): request a host completion bridge call.",
+	"output(...ids, options?): retrieve task output through the reserved output bridge.",
+	"agent(prompt, options?): delegate work through the reserved agent bridge.",
+	"parallel(thunks): run async thunks through the configured bounded pool; preserves order and rethrows the lowest-index error after all settle.",
+	"pipeline(items, ...stages): map items through staged async transforms with a barrier between stages.",
 ].join("\n");

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/rewrite-imports.ts

@@ -0,0 +1,164 @@
+import { parse } from "@babel/parser";
+import type { ImportDeclaration } from "@babel/types";
+
+const DYNAMIC_IMPORT_CALLEE =
+	'(typeof __senpi_import__ === "function" ? __senpi_import__ : (specifier, options) => import(specifier, options))';
+
+type AstNode = {
+	readonly type: string;
+	readonly start: number;
+	readonly end: number;
+	readonly value: Readonly<Record<string, unknown>>;
+};
+
+type TextEdit = {
+	readonly start: number;
+	readonly end: number;
+	readonly text: string;
+};
+
+class UnexpectedImportSpecifierError extends Error {
+	readonly name = "UnexpectedImportSpecifierError";
+}
+
+function assertNever(_value: never): never {
+	throw new UnexpectedImportSpecifierError("Unsupported import specifier");
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function nodeFrom(value: unknown): AstNode | undefined {
+	if (!isRecord(value)) return undefined;
+	const type = value["type"];
+	const start = value["start"];
+	const end = value["end"];
+	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
+	return { type, start, end, value };
+}
+
+function parseProgram(code: string): ReturnType<typeof parse> | undefined {
+	try {
+		return parse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+			allowNewTargetOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			allowUndeclaredExports: true,
+			errorRecovery: true,
+			plugins: ["typescript", "importAttributes"],
+		});
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+function walkNodes(root: unknown, visit: (node: AstNode) => void): void {
+	const stack: unknown[] = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (Array.isArray(current)) {
+			for (let index = current.length - 1; index >= 0; index -= 1) stack.push(current[index]);
+			continue;
+		}
+		if (!isRecord(current)) continue;
+		const node = nodeFrom(current);
+		if (node) visit(node);
+		for (const [key, value] of Object.entries(current)) {
+			if (key === "loc" || key === "extra" || key === "range" || key.endsWith("Comments")) continue;
+			if (value !== null && typeof value === "object") stack.push(value);
+		}
+	}
+}
+
+function importOptions(node: ImportDeclaration): string | undefined {
+	if (!node.attributes || node.attributes.length === 0) return undefined;
+	const pairs = node.attributes.map((attribute) => {
+		const key = attribute.key.type === "Identifier" ? attribute.key.name : JSON.stringify(attribute.key.value);
+		return `${key}: ${JSON.stringify(attribute.value.value)}`;
+	});
+	return `{ with: { ${pairs.join(", ")} } }`;
+}
+
+function importCall(source: string, options: string | undefined): string {
+	const sourceLiteral = JSON.stringify(source);
+	return options ? `__senpi_import__(${sourceLiteral}, ${options})` : `__senpi_import__(${sourceLiteral})`;
+}
+
+function rewriteImportDeclaration(node: ImportDeclaration): string {
+	const call = importCall(node.source.value, importOptions(node));
+	let defaultName: string | undefined;
+	let namespaceName: string | undefined;
+	const namedBindings: Array<readonly [imported: string, local: string]> = [];
+
+	for (const specifier of node.specifiers) {
+		switch (specifier.type) {
+			case "ImportDefaultSpecifier":
+				defaultName = specifier.local.name;
+				break;
+			case "ImportNamespaceSpecifier":
+				namespaceName = specifier.local.name;
+				break;
+			case "ImportSpecifier": {
+				const imported =
+					specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+				namedBindings.push([imported, specifier.local.name]);
+				break;
+			}
+			default:
+				assertNever(specifier);
+		}
+	}
+
+	if (namedBindings.length > 0) {
+		const named = namedBindings
+			.map(([imported, local]) => (imported === local ? imported : `${imported}: ${local}`))
+			.join(", ");
+		const bindings = defaultName ? `default: ${defaultName}, ${named}` : named;
+		return `const { ${bindings} } = await ${call};`;
+	}
+	if (namespaceName && defaultName) {
+		return `const ${namespaceName} = await ${call}; const ${defaultName} = ${namespaceName}.default;`;
+	}
+	if (namespaceName) return `const ${namespaceName} = await ${call};`;
+	if (defaultName) return `const ${defaultName} = (await ${call}).default;`;
+	return `await ${call};`;
+}
+
+function dynamicImportEdit(node: AstNode): TextEdit | undefined {
+	if (node.type !== "CallExpression") return undefined;
+	const callee = nodeFrom(node.value["callee"]);
+	if (callee?.type !== "Import") return undefined;
+	return { start: callee.start, end: callee.end, text: DYNAMIC_IMPORT_CALLEE };
+}
+
+function applyEdits(code: string, edits: readonly TextEdit[]): string {
+	if (edits.length === 0) return code;
+	const descending = edits.toSorted((left, right) => right.start - left.start);
+	let output = code;
+	for (const edit of descending) {
+		output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+	}
+	return output;
+}
+
+export function rewriteImports(code: string): string {
+	if (!code.includes("import")) return code;
+	const ast = parseProgram(code);
+	if (!ast) return code;
+	const edits: TextEdit[] = [];
+
+	for (const node of ast.program.body) {
+		if (node.type !== "ImportDeclaration" || typeof node.start !== "number" || typeof node.end !== "number") continue;
+		edits.push({ start: node.start, end: node.end, text: rewriteImportDeclaration(node) });
+	}
+	walkNodes(ast.program, (node) => {
+		const edit = dynamicImportEdit(node);
+		if (edit) edits.push(edit);
+	});
+	return applyEdits(code, edits);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/run-queue.ts

@@ -0,0 +1,82 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { JavaScriptRunInput } from "./kernel-contract.ts";
+
+type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
+
+export interface PendingJavaScriptRun {
+	readonly input: JavaScriptRunInput;
+	readonly resolve: (message: ResultMessage) => void;
+	readonly reject: (error: Error) => void;
+	startedAtMs: number | null;
+	settled: boolean;
+}
+
+export class JavaScriptRunQueue {
+	#queue: PendingJavaScriptRun[] = [];
+	#active: PendingJavaScriptRun | null = null;
+
+	get active(): PendingJavaScriptRun | null {
+		return this.#active;
+	}
+
+	get hasWaiting(): boolean {
+		return this.#queue.length > 0;
+	}
+
+	enqueue(input: JavaScriptRunInput): Promise<ResultMessage> {
+		return new Promise((resolve, reject) => {
+			this.#queue.push({ input, resolve, reject, startedAtMs: null, settled: false });
+		});
+	}
+
+	startNext(startedAtMs: number): PendingJavaScriptRun | null {
+		if (this.#active) return null;
+		const next = this.#queue.shift() ?? null;
+		if (next) next.startedAtMs = startedAtMs;
+		this.#active = next;
+		return next;
+	}
+
+	durationMs(run: PendingJavaScriptRun, finishedAtMs: number): number {
+		if (run.startedAtMs === null) return 0;
+		return Math.max(0, Math.round(finishedAtMs - run.startedAtMs));
+	}
+
+	takeInterruptTarget(): PendingJavaScriptRun | null {
+		if (!this.#active) return this.#queue.shift() ?? null;
+		const active = this.#active;
+		this.#active = null;
+		return active;
+	}
+
+	releaseActive(run: PendingJavaScriptRun): boolean {
+		if (this.#active !== run) return false;
+		this.#active = null;
+		return true;
+	}
+
+	settle(run: PendingJavaScriptRun, result: ResultMessage): void {
+		if (run.settled) return;
+		run.settled = true;
+		run.resolve(result);
+	}
+
+	settleAll(message: string): void {
+		const active = this.#active;
+		this.#active = null;
+		if (active) this.settle(active, stoppedResult(active.input.cellId, message));
+		for (const queued of this.#queue.splice(0)) this.settle(queued, stoppedResult(queued.input.cellId, message));
+	}
+
+	rejectWaiting(error: Error): void {
+		for (const queued of this.#queue.splice(0)) {
+			if (queued.settled) continue;
+			queued.settled = true;
+			queued.reject(error);
+		}
+	}
+}
+
+export function stoppedResult(cellId: string, message: string): ResultMessage {
+	return { type: "result", cellId, ok: false, error: { message }, durationMs: 0 };
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/worker-core.js

@@ -3,7 +3,6 @@ import { JsWorkerRuntime } from "./worker-runtime.js";
 export function createWorkerCore(transport, options) {
 	let runtime = null;
 	const pendingTools = new Map();
-	const started = Date.now();
 
 	function emit(message) {
 		transport.send(message);
@@ -14,14 +13,15 @@ export function createWorkerCore(transport, options) {
 			emit({ type: "result", cellId: message.cellId, ok: false, error: { message: "JS runtime not initialized" }, durationMs: 0 });
 			return;
 		}
+		const startedAtMs = performance.now();
 		try {
 			const value = await runtime.run(message.code, message.cellId, {
 				emit,
 				callTool: async (toolName, args) => await callTool(toolName, args),
 			});
-			emit({ type: "result", cellId: message.cellId, ok: true, valueRepr: valueRepr(value), durationMs: Date.now() - started });
+			emit({ type: "result", cellId: message.cellId, ok: true, valueRepr: valueRepr(value), durationMs: durationMs(startedAtMs) });
 		} catch (error) {
-			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: Date.now() - started });
+			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: durationMs(startedAtMs) });
 		}
 	}
 
@@ -34,7 +34,12 @@ export function createWorkerCore(transport, options) {
 
 	function onMessage(message) {
 		if (message.type === "init") {
-			runtime = new JsWorkerRuntime({ cwd: options.cwd, parallelPoolWidth: options.parallelPoolWidth });
+			runtime = new JsWorkerRuntime({
+				cwd: options.cwd,
+				parallelPoolWidth: options.parallelPoolWidth,
+				localRoots: message.connection.localRoots,
+				artifactsDir: message.connection.artifactsDir,
+			});
 			emit({ type: "ready" });
 			return;
 		}
@@ -65,6 +70,10 @@ export function createWorkerCore(transport, options) {
 	};
 }
 
+function durationMs(startedAtMs) {
+	return Math.max(0, Math.round(performance.now() - startedAtMs));
+}
+
 function valueRepr(value) {
 	if (value === undefined) return undefined;
 	return JSON.stringify(value);

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/worker-host.ts

@@ -0,0 +1,117 @@
+import { Worker } from "node:worker_threads";
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { WorkerLike } from "./inline-worker.ts";
+import type { JavaScriptKernelMode } from "./kernel-contract.ts";
+
+export class WorkerStartupCancelledError extends Error {
+	readonly name = "WorkerStartupCancelledError";
+
+	constructor() {
+		super("JavaScript worker startup was cancelled");
+	}
+}
+
+export class JavaScriptWorkerExitedError extends Error {
+	readonly name = "JavaScriptWorkerExitedError";
+	readonly exitCode: number;
+
+	constructor(exitCode: number) {
+		super(`JavaScript worker exited with code ${exitCode}`);
+		this.exitCode = exitCode;
+	}
+}
+
+export function spawnNodeWorker(
+	url: URL,
+	cwd: string,
+	parallelPoolWidth: number,
+	mode: JavaScriptKernelMode = "worker",
+): WorkerLike {
+	return wrapNodeWorker(
+		new Worker(url, {
+			workerData: { cwd, parallelPoolWidth },
+		}),
+		mode,
+	);
+}
+
+export function waitForReady(worker: WorkerLike, signal: AbortSignal): Promise<void> {
+	return new Promise((resolve, reject) => {
+		let offMessage = (): void => {};
+		let offError = (): void => {};
+		const cleanup = (): void => {
+			offMessage();
+			offError();
+			signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = (): void => {
+			cleanup();
+			reject(new WorkerStartupCancelledError());
+		};
+		offMessage = worker.onMessage((message) => {
+			if (message.type === "ready") {
+				cleanup();
+				resolve();
+			} else if (message.type === "init-failed") {
+				cleanup();
+				reject(errorFromBridge(message.error));
+			}
+		});
+		offError = worker.onError((error) => {
+			cleanup();
+			reject(error);
+		});
+		if (signal.aborted) onAbort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+export function errorFromBridge(error: {
+	readonly message: string;
+	readonly name?: string;
+	readonly stack?: string;
+}): Error {
+	const result = new Error(error.message);
+	if (error.name) result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	return result;
+}
+
+export function bridgeError(error: Error): {
+	readonly message: string;
+	readonly name?: string;
+	readonly stack?: string;
+} {
+	return { message: error.message, name: error.name, stack: error.stack };
+}
+
+function wrapNodeWorker(worker: Worker, mode: JavaScriptKernelMode): WorkerLike {
+	return {
+		mode,
+		postMessage: (message) => worker.postMessage(message),
+		onMessage(handler) {
+			const listener = (message: KernelToHostMessage): void => handler(message);
+			worker.on("message", listener);
+			return () => worker.off("message", listener);
+		},
+		onError(handler) {
+			let reported = false;
+			const report = (error: Error): void => {
+				if (reported) return;
+				reported = true;
+				handler(error);
+			};
+			const onError = (error: Error): void => report(error);
+			const onExit = (code: number): void => report(new JavaScriptWorkerExitedError(code));
+			worker.on("error", onError);
+			worker.on("exit", onExit);
+			return () => {
+				worker.off("error", onError);
+				worker.off("exit", onExit);
+			};
+		},
+		async terminate() {
+			await worker.terminate();
+		},
+	};
+}