@code-yeongyu/senpi 2026.7.11 → 2026.7.13

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/worker-core.js

@@ -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;
 		}

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

@@ -1,24 +1,41 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
+// allow: SIZE_OK — private runtime state and installed globals must stay in one worker module.
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
 
+const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
+const INTERNAL_URL = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/iu;
+const BASE64_STRICT_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/u;
+
 export class JsWorkerRuntime {
 	#cwd;
 	#parallelPoolWidth;
+	#localRoots;
 	#env = new Map();
 	#hooks = null;
 
 	constructor(options) {
 		this.#cwd = options.cwd;
 		this.#parallelPoolWidth = options.parallelPoolWidth;
+		this.#localRoots = { ...(options.localRoots ?? {}) };
+		if (options.artifactsDir && !this.#localRoots.local) this.#localRoots.local = join(options.artifactsDir, "local");
 		this.#installGlobals();
 	}
 
 	async run(code, cellId, hooks) {
 		this.#hooks = hooks;
 		try {
-			return await awaitMaybePromise(indirectEval(wrapUserCode(code), cellId));
+			let prelude = "";
+			let cellCode = code;
+			if (code.startsWith(PREPARED_CELL_PREFIX)) {
+				const prepared = JSON.parse(code.slice(PREPARED_CELL_PREFIX.length));
+				if (!isPlainObject(prepared) || typeof prepared.prelude !== "string" || typeof prepared.code !== "string") throw new Error("Invalid prepared JavaScript cell payload");
+				({ prelude, code: cellCode } = prepared);
+			}
+			if (prelude) indirectEval(prelude, `${cellId}:prelude`);
+			return await awaitMaybePromise(indirectEval(wrapUserCode(cellCode), cellId));
 		} finally {
 			this.#hooks = null;
 		}
@@ -30,8 +47,10 @@ export class JsWorkerRuntime {
 		globalThis.log = message => this.#hooks?.emit({ type: "log", message: String(message) });
 		globalThis.phase = title => this.#hooks?.emit({ type: "phase", title: String(title) });
 		globalThis.env = (key, value) => this.#envHelper(key, value);
-		globalThis.read = async (path, offset = 1, limit) => await this.#read(path, offset, limit);
+		globalThis.read = async (path, options, ...rest) => await this.#read(path, helperOptions("read", options, rest));
 		globalThis.write = async (path, content) => await this.#write(path, content);
+		globalThis.output = async (...args) => await this.#output(args);
+		globalThis.agent = async (prompt, options, ...rest) => await this.#agent(prompt, options, rest);
 		globalThis.parallel = async thunks => await this.#parallel(thunks);
 		globalThis.pipeline = async (items, ...stages) => await this.#pipeline(items, stages);
 		globalThis.completion = async (prompt, opts) => await this.#callTool("completion", { prompt, opts });
@@ -40,21 +59,34 @@ export class JsWorkerRuntime {
 			{
 				get: (_target, prop) => {
 					if (typeof prop !== "string") return undefined;
-					return async args => await this.#callTool(prop, args);
+					return async args => await this.#callTool(prop, args ?? {});
 				},
 			},
 		);
 		const originalLog = console.log.bind(console);
 		const originalError = console.error.bind(console);
-		console.log = (...values) => {
-			this.#emitText("stdout", `${values.map(formatValue).join(" ")}\n`);
-		};
-		console.error = (...values) => {
-			this.#emitText("stderr", `${values.map(formatValue).join(" ")}\n`);
+		const originalStdoutWrite = process.stdout.write;
+		const originalStderrWrite = process.stderr.write;
+		const routeWrite = (stream, originalWrite, streamName) => {
+			const write = originalWrite.bind(stream);
+			return (chunk, encoding, callback) => {
+				if (!this.#hooks) return write(chunk, encoding, callback);
+				const callbackValue = typeof encoding === "function" ? encoding : callback;
+				const encodingValue = typeof encoding === "string" ? encoding : undefined;
+				this.#emitText(streamName, chunkToString(chunk, encodingValue));
+				if (typeof callbackValue === "function") callbackValue();
+				return true;
+			};
 		};
+		process.stdout.write = routeWrite(process.stdout, originalStdoutWrite, "stdout");
+		process.stderr.write = routeWrite(process.stderr, originalStderrWrite, "stderr");
+		console.log = (...values) => this.#emitText("stdout", `${values.map(formatValue).join(" ")}\n`);
+		console.error = (...values) => this.#emitText("stderr", `${values.map(formatValue).join(" ")}\n`);
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;
 			console.error = originalError;
+			process.stdout.write = originalStdoutWrite;
+			process.stderr.write = originalStderrWrite;
 		};
 	}
 
@@ -62,73 +94,307 @@ export class JsWorkerRuntime {
 		this.#hooks?.emit({ type: "text", stream, data });
 	}
 
+	#emitStatus(event) {
+		this.#hooks?.emit({ type: "status", event });
+	}
+
 	#display(value) {
-		if (value && typeof value === "object" && typeof value.mimeType === "string" && typeof value.dataBase64 === "string") {
-			this.#hooks?.emit({ type: "display", mimeType: value.mimeType, dataBase64: value.dataBase64 });
+		if (value && typeof value === "object") {
+			if (value.type === "markdown" && typeof value.text === "string") {
+				this.#hooks?.emit({ type: "display", mimeType: "text/markdown", dataBase64: encodeBase64(value.text) });
+				return;
+			}
+			if (value.type === "image" && typeof value.mimeType === "string") {
+				const dataBase64 = imageBase64(value.data);
+				if (dataBase64 !== undefined) {
+					this.#hooks?.emit({ type: "display", mimeType: value.mimeType, dataBase64 });
+					return;
+				}
+				this.#emitText(
+					"stdout",
+					`[display: image dropped — \`data\` must be a base64 string, Uint8Array/Buffer, or ArrayBuffer; got ${describeImageData(value.data)}]\n`,
+				);
+				return;
+			}
+			if (typeof value.mimeType === "string" && typeof value.dataBase64 === "string") {
+				this.#hooks?.emit({ type: "display", mimeType: value.mimeType, dataBase64: value.dataBase64 });
+				return;
+			}
+			try {
+				this.#hooks?.emit({ type: "display", mimeType: "application/json", dataBase64: encodeBase64(JSON.stringify(value)) });
+			} catch (error) {
+				if (!(error instanceof TypeError)) throw error;
+				this.#emitText("stdout", `${inspect(value, { colors: false, depth: 5 })}\n`);
+			}
 			return;
 		}
-		this.#hooks?.emit({
-			type: "display",
-			mimeType: "application/json",
-			dataBase64: Buffer.from(JSON.stringify(value), "utf8").toString("base64"),
-		});
+		this.#emitText("stdout", `${String(value)}\n`);
 	}
 
 	#envHelper(key, value) {
-		if (key === undefined) return { ...process.env, ...Object.fromEntries(this.#env) };
+		if (key === undefined || key === null || key === "") {
+			const merged = Object.fromEntries(Object.entries({ ...process.env, ...Object.fromEntries(this.#env) }).sort());
+			this.#emitStatus({ op: "env", count: Object.keys(merged).length, keys: Object.keys(merged).slice(0, 20) });
+			return merged;
+		}
+		const name = String(key);
 		if (value !== undefined) {
 			const stringValue = String(value);
-			this.#env.set(String(key), stringValue);
+			this.#env.set(name, stringValue);
+			this.#emitStatus({ op: "env", key: name, value: stringValue, action: "set" });
 			return stringValue;
 		}
-		return this.#env.get(String(key)) ?? process.env[String(key)];
+		const result = this.#env.get(name) ?? process.env[name];
+		this.#emitStatus({ op: "env", key: name, value: result, action: "get" });
+		return result;
 	}
 
-	async #read(rawPath, offset, limit) {
-		const text = await readFile(this.#resolvePath(String(rawPath)), "utf8");
-		if (offset <= 1 && limit === undefined) return text;
-		const lines = text.split(/\r?\n/u);
-		return lines.slice(Math.max(0, offset - 1), limit === undefined ? undefined : offset - 1 + limit).join("\n");
+	async #read(rawPath, options) {
+		const path = this.#resolvePath(String(rawPath), "read");
+		const info = await stat(path);
+		if (info.isDirectory()) throw new Error(`Directory paths are not supported by read(): ${path}`);
+		let text = await readFile(path, "utf8");
+		const offset = typeof options.offset === "number" ? options.offset : 1;
+		const limit = typeof options.limit === "number" ? options.limit : undefined;
+		if (offset > 1 || limit !== undefined) {
+			const lines = text.split(/\r?\n/u);
+			const start = Math.max(0, offset - 1);
+			text = lines.slice(start, limit === undefined ? undefined : start + limit).join("\n");
+		}
+		this.#emitStatus({ op: "read", path, bytes: info.size, chars: text.length });
+		return text;
 	}
 
 	async #write(rawPath, content) {
-		const path = this.#resolvePath(String(rawPath));
+		const path = this.#resolvePath(String(rawPath), "write");
+		const data = await writeData(content);
 		await mkdir(dirname(path), { recursive: true });
-		await writeFile(path, String(content));
+		await writeFile(path, data);
+		this.#emitStatus({ op: "write", path, bytes: typeof data === "string" ? Buffer.byteLength(data) : data.byteLength });
+		return path;
+	}
+
+	#resolvePath(rawPath, operation) {
+		const match = INTERNAL_URL.exec(rawPath);
+		if (!match) return isAbsolute(rawPath) ? normalize(rawPath) : resolve(this.#cwd, rawPath);
+		const scheme = match[1].toLowerCase();
+		const root = this.#localRoots[scheme];
+		if (!root) throw new Error(`Protocol paths are not supported by ${operation}(): ${rawPath}`);
+		let relative;
+		try {
+			relative = decodeURIComponent(match[2].replaceAll("\\", "/"));
+		} catch (error) {
+			if (error instanceof URIError) throw new Error(`Invalid URL encoding in ${scheme}:// path: ${rawPath}`);
+			throw error;
+		}
+		if (isAbsolute(relative) || relative.split("/").includes("..")) {
+			throw new Error(`Path traversal is not allowed in ${scheme}:// URLs: ${rawPath}`);
+		}
+		const rootPath = resolve(root);
+		const path = resolve(rootPath, relative);
+		if (path !== rootPath && !path.startsWith(`${rootPath}${sep}`)) throw new Error(`${scheme}:// path escapes its root`);
 		return path;
 	}
 
-	#resolvePath(path) {
-		return isAbsolute(path) ? path : resolve(this.#cwd, path);
+	async #output(args) {
+		let ids = args;
+		let options = {};
+		const last = args.at(-1);
+		if (isPlainObject(last)) {
+			ids = args.slice(0, -1);
+			options = last;
+		}
+		return await this.#callTool(reservedTool("__senpi_reserved_output_tool__", "output"), {
+			ids: ids.map(String),
+			...options,
+		});
+	}
+
+	async #agent(prompt, options, rest) {
+		const parsed = optionsArg({
+			name: "agent",
+			value: options,
+			rest,
+			keys: ["agent", "model", "label", "schema", "isolated", "apply", "merge"],
+			example: "{ agent, model, label, schema, isolated, apply, merge, handle }",
+		});
+		const { handle, ...callArgs } = parsed;
+		const response = await this.#callTool(reservedTool("__senpi_reserved_agent_tool__", "agent"), {
+			prompt: String(prompt),
+			...callArgs,
+			handle: Boolean(handle),
+		});
+		const responseRecord = isPlainObject(response) ? response : {};
+		const text = Object.hasOwn(responseRecord, "text") ? responseRecord.text : response;
+		const output = Object.hasOwn(callArgs, "schema")
+			? Object.hasOwn(responseRecord, "data")
+				? responseRecord.data
+				: JSON.parse(String(text))
+			: text;
+		if (!handle) return output;
+		const details = isPlainObject(responseRecord.details) ? responseRecord.details : responseRecord;
+		const id = details.id;
+		if (id === undefined || id === null) return { text, output: text, handle: null, id: null, agent: null };
+		const node = {
+			text,
+			output: text,
+			handle: details.handle ?? `agent://${id}`,
+			id,
+			agent: details.agent ?? callArgs.agent ?? null,
+		};
+		if (Object.hasOwn(callArgs, "schema")) node.data = output;
+		for (const key of ["isolated", "patchPath", "branchName", "nestedPatches", "changesApplied", "isolationSummary"]) {
+			if (details[key] !== undefined) node[key] = details[key];
+		}
+		return node;
 	}
 
 	async #callTool(toolName, args) {
-		if (!this.#hooks) throw new Error("tool call outside active JS cell");
-		return await this.#hooks.callTool(toolName, args);
+		const hooks = this.#hooks;
+		if (!hooks) throw new Error("tool call outside active JS cell");
+		if (
+			typeof globalThis.__senpi_timeout_pause_op__ !== "string" ||
+			typeof globalThis.__senpi_timeout_resume_op__ !== "string"
+		) {
+			throw new Error("timeout bridge is unavailable");
+		}
+		this.#emitStatus({ op: globalThis.__senpi_timeout_pause_op__ });
+		try {
+			return await hooks.callTool(toolName, args);
+		} finally {
+			this.#emitStatus({ op: globalThis.__senpi_timeout_resume_op__ });
+		}
 	}
 
 	async #parallel(thunks) {
-		const results = new Array(thunks.length);
+		const list = Array.from(thunks ?? []);
+		if (list.length === 0) return [];
+		const configuredWidth = Number.isFinite(this.#parallelPoolWidth) ? Math.trunc(this.#parallelPoolWidth) : 1;
+		const workerCount = Math.min(Math.max(1, configuredWidth), list.length);
+		const results = new Array(list.length);
 		let next = 0;
-		const workers = Array.from({ length: Math.min(this.#parallelPoolWidth, thunks.length) }, async () => {
-			while (next < thunks.length) {
+		let firstError;
+		let firstErrorIndex = list.length;
+		let hasError = false;
+		const worker = async () => {
+			while (true) {
 				const index = next;
 				next += 1;
-				results[index] = await thunks[index]();
+				if (index >= list.length) return;
+				try {
+					const thunk = list[index];
+					if (typeof thunk !== "function") throw new TypeError("parallel() expects an iterable of functions");
+					results[index] = await thunk(index);
+				} catch (error) {
+					if (!hasError || index < firstErrorIndex) {
+						hasError = true;
+						firstErrorIndex = index;
+						firstError = error;
+					}
+				}
 			}
-		});
-		await Promise.all(workers);
+		};
+		await Promise.all(Array.from({ length: workerCount }, worker));
+		if (hasError) throw firstError;
 		return results;
 	}
 
 	async #pipeline(items, stages) {
-		let current = items;
-		for (const stage of stages) current = await this.#parallel(current.map(item => async () => await stage(item)));
+		let current = Array.from(items ?? []);
+		for (const stage of stages) {
+			if (typeof stage !== "function") throw new TypeError("pipeline() stages must be functions");
+			current = await this.#parallel(current.map(item => async () => await stage(item)));
+		}
 		return current;
 	}
 }
 
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function optionsArg(options) {
+	const { name, value, rest, keys, example } = options;
+	if (isPlainObject(value)) {
+		if (rest.some(item => item !== undefined && item !== null)) throw new TypeError(`${name}() options cannot mix object and positional forms`);
+		return value;
+	}
+	const values = [value, ...rest];
+	for (let index = keys.length; index < values.length; index += 1) {
+		if (values[index] !== undefined && values[index] !== null) throw new TypeError(`${name}() accepts ${example}`);
+	}
+	return Object.fromEntries(keys.flatMap((key, index) => values[index] === undefined || values[index] === null ? [] : [[key, values[index]]]));
+}
+
+function helperOptions(name, value, rest) {
+	return optionsArg({ name, value, rest, keys: ["offset", "limit"], example: "{ offset, limit }" });
+}
+
+function reservedTool(globalName, helperName) {
+	const value = globalThis[globalName];
+	if (typeof value !== "string") throw new Error(`${helperName}() bridge is unavailable`);
+	return value;
+}
+
+async function writeData(value) {
+	if (typeof value === "string" || value instanceof Uint8Array) return value;
+	if (value instanceof Blob) return new Uint8Array(await value.arrayBuffer());
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	throw new TypeError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
+}
+
+function imageBase64(data) {
+	if (typeof data === "string") {
+		if (isStrictBase64(data)) return data;
+		if (!DECIMAL_CSV_RE.test(data)) return undefined;
+		const parts = data.split(",");
+		const bytes = new Uint8Array(parts.length);
+		for (let index = 0; index < parts.length; index += 1) {
+			const byte = Number(parts[index]);
+			if (!Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
+			bytes[index] = byte;
+		}
+		return Buffer.from(bytes).toString("base64");
+	}
+	if (data instanceof Uint8Array) return Buffer.from(data).toString("base64");
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("base64");
+	if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
+	if (isPlainObject(data) && data.type === "Buffer" && Array.isArray(data.data)) {
+		const bytes = new Uint8Array(data.data.length);
+		for (let index = 0; index < data.data.length; index += 1) {
+			const byte = data.data[index];
+			if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
+			bytes[index] = byte;
+		}
+		return Buffer.from(bytes).toString("base64");
+	}
+	return undefined;
+}
+
+function isStrictBase64(value) {
+	return value.length > 0 && value.length % 4 === 0 && BASE64_STRICT_RE.test(value);
+}
+
+function describeImageData(data) {
+	if (data === null) return "null";
+	if (data instanceof Uint8Array) return "Uint8Array";
+	if (data instanceof ArrayBuffer) return "ArrayBuffer";
+	if (ArrayBuffer.isView(data)) return data.constructor.name;
+	if (typeof data === "string") return `string(${data.length})`;
+	return typeof data;
+}
+
+function chunkToString(chunk, encoding) {
+	if (typeof chunk === "string") return chunk;
+	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString(encoding ?? "utf8");
+	return String(chunk);
+}
+
+function encodeBase64(value) {
+	return Buffer.from(value, "utf8").toString("base64");
+}
+
 function formatValue(value) {
-	if (typeof value === "string") return value;
-	return inspect(value, { colors: false, depth: 5 });
+	return typeof value === "string" ? value : inspect(value, { colors: false, depth: 5 });
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/py/kernel.ts

@@ -135,8 +135,9 @@ export class PythonKernel {
 		if (!pending || !this.#pending.has(pending.input.cellId)) return;
 		this.#active = pending;
 		pending.startedAt = performance.now();
-		const timeoutMs = pending.input.timeoutMs ?? 30_000;
-		pending.timeoutTimer = setTimeout(() => this.#timeoutRun(pending, timeoutMs), timeoutMs);
+		const timeoutMs = pending.input.timeoutMs;
+		if (timeoutMs !== undefined)
+			pending.timeoutTimer = setTimeout(() => this.#timeoutRun(pending, timeoutMs), timeoutMs);
 		try {
 			this.#transport?.run(pending.input);
 		} catch (error) {