@code-yeongyu/senpi-codemode 2026.10.7 → 2026.10.9

package/src/tool/magic-cell-host.ts

@@ -0,0 +1,65 @@
+import type { PythonEnvironments } from "../environments/python-environments.ts";
+import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
+import { MagicCellError, parseMagicCell } from "./magic-cells.ts";
+import type { EvalLanguage, HostCellExecutor } from "./types.ts";
+
+export type MagicCellPlan =
+	| { readonly kind: "ordinary" }
+	| { readonly kind: "host"; readonly executor: HostCellExecutor }
+	| { readonly kind: "refused"; readonly message: string }
+	| { readonly kind: "load"; readonly target: string };
+
+export function planMagicCell(
+	language: EvalLanguage,
+	code: string,
+	environments: PythonEnvironments | undefined,
+): MagicCellPlan {
+	let magic: ReturnType<typeof parseMagicCell>;
+	try {
+		magic = parseMagicCell(language, code);
+	} catch (error) {
+		if (error instanceof MagicCellError) return { kind: "refused", message: error.message };
+		throw error;
+	}
+	if (magic === undefined) return { kind: "ordinary" };
+	if (magic.kind === "load") return { kind: "load", target: magic.target };
+	if (environments === undefined) {
+		return {
+			kind: "refused",
+			message: "environment_installer_unavailable: this session has no Python interpreter to install packages for",
+		};
+	}
+	if (magic.kind === "environment") {
+		const mode = magic.mode;
+		return {
+			kind: "host",
+			executor: async () => {
+				const root = await environments.setMode(mode);
+				return { ok: true, valueRepr: `environment: ${mode} (${root})` };
+			},
+		};
+	}
+	const requirements = magic.args;
+	return {
+		kind: "host",
+		// Install time is parked time for the run budget, the same accounting as a bridge call.
+		executor: async ({ signal, emit }) => {
+			emit({ type: "status", event: { op: TIMEOUT_PAUSE_OP } });
+			try {
+				const receipt = await environments.install(requirements, signal, (stream, data) =>
+					emit({ type: "text", stream, data }),
+				);
+				const packages = receipt.resolved.length > 0 ? receipt.resolved.join(", ") : "nothing new";
+				return {
+					ok: true,
+					valueRepr: `installed ${packages} into ${receipt.mode} (revision ${receipt.revision}); already-imported modules stay cached until reset`,
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return { ok: false, error: { message } };
+			} finally {
+				emit({ type: "status", event: { op: TIMEOUT_RESUME_OP } });
+			}
+		},
+	};
+}

package/src/tool/magic-cells.ts

@@ -0,0 +1,65 @@
+import type { EvalLanguage } from "./types.ts";
+
+export type MagicCell =
+	| { readonly kind: "pip"; readonly args: string }
+	| { readonly kind: "environment"; readonly mode: "managed" | "project" }
+	| { readonly kind: "load"; readonly target: string };
+
+const HOST_MAGICS = ["pip", "environment", "load"] as const;
+const LOAD_LANGUAGES: ReadonlySet<EvalLanguage> = new Set(["py", "js"]);
+const COMMENT_PREFIX: Partial<Record<EvalLanguage, string>> = { py: "#", js: "//" };
+type HostMagic = (typeof HOST_MAGICS)[number];
+
+export class MagicCellError extends Error {
+	readonly name = "MagicCellError";
+}
+
+function joinContinuations(lines: readonly string[]): string[] {
+	const joined: string[] = [];
+	let pending: string | undefined;
+	for (const line of lines) {
+		const current = pending === undefined ? line : `${pending} ${line.trim()}`;
+		if (current.trimEnd().endsWith("\\")) pending = current.trimEnd().slice(0, -1).trimEnd();
+		else {
+			joined.push(current);
+			pending = undefined;
+		}
+	}
+	if (pending !== undefined) joined.push(pending);
+	return joined;
+}
+
+function hostMagicOf(language: EvalLanguage, line: string): HostMagic | undefined {
+	const match = /^%([A-Za-z]+)(?:\s|$)/.exec(line.trim());
+	const name = match?.[1];
+	const magic = HOST_MAGICS.find((candidate) => candidate === name);
+	if (magic === "load") return LOAD_LANGUAGES.has(language) ? magic : undefined;
+	return language === "py" ? magic : undefined;
+}
+
+/**
+ * A cell whose first code line (blank and comment lines skipped) is a host magic runs on the host instead of
+ * the interpreter: `%pip` and `%environment` in Python, `%load` in Python and JavaScript. In Python a trailing
+ * backslash continues the line. Any other cell is ordinary code, so a magic-looking line later in the cell
+ * (say, inside a string) is left alone. A magic followed by more code is refused, because the host step must
+ * finish before the code that depends on it runs.
+ */
+export function parseMagicCell(language: EvalLanguage, code: string): MagicCell | undefined {
+	const comment = COMMENT_PREFIX[language];
+	// Comment lines go before Python's backslash continuations are joined: Python never continues a comment line.
+	const raw = code.split("\n").filter((line) => comment === undefined || !line.trim().startsWith(comment));
+	const lines = (language === "py" ? joinContinuations(raw) : raw).filter((line) => line.trim() !== "");
+	const first = lines[0] ?? "";
+	const magic = hostMagicOf(language, first);
+	if (magic === undefined) return undefined;
+	if (lines.length > 1)
+		throw new MagicCellError(`put %${magic} on its own cell, then run the code that uses it in the next cell`);
+	const args = first.trim().slice(`%${magic}`.length).trim();
+	if (magic === "pip") return { kind: "pip", args };
+	if (magic === "load") {
+		if (args === "") throw new MagicCellError("%load takes one argument: the path of the file to run");
+		return { kind: "load", target: args };
+	}
+	if (args === "managed" || args === "project") return { kind: "environment", mode: args };
+	throw new MagicCellError("%environment takes one argument: managed or project");
+}

package/src/tool/run-eval-cell.ts

@@ -23,6 +23,8 @@ import { EvalKernelResetRefusedError } from "./eval-kernel-reset-refused-error.t
 import { evalTimeoutBehavior } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
+import { loadCell } from "./load-cell.ts";
+import { planMagicCell } from "./magic-cell-host.ts";
 import type { EvalKernel, EvalToolDetails } from "./types.ts";
 
 export async function runEvalCell(
@@ -205,11 +207,21 @@ async function executeCell(
 		const pending = handler.handle(message);
 		void pending.catch((error: unknown) => execution.cancel(error));
 	};
+	let releaseCellKernelTools: (() => void) | undefined;
 	try {
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
 		// Computed before the handler so its construction-time snapshot captures this cell's capability.
 		// Worker messages later restore that snapshot before calling host tools (#1754, #2512).
 		const kernelTools = kernelToolsFor(kernel);
+		// Subprocess kernels call the host over the bridge, outside this async context. Their calls carry a fresh secret
+		// minted for this run and sent only to this cell's kernel, never the model-visible cell id, so code in another
+		// kernel cannot name this cell into its tools. JS calls already run inside this cell's scope (#1754).
+		const bridgeCellToken =
+			kernelTools === undefined || invocation.input.language === "js" ? undefined : randomUUID();
+		releaseCellKernelTools =
+			kernelTools === undefined || bridgeCellToken === undefined
+				? undefined
+				: options.kernelManager.bindCellKernelTools?.(bridgeCellToken, kernelTools);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
 			const queue = kernel.queueSnapshot();
 			state.queuedBehind = [...(queue.activeCellId === null ? [] : [queue.activeCellId]), ...queue.queuedCellIds];
@@ -249,10 +261,26 @@ async function executeCell(
 			}
 			if (invocation.input.reset) await execution.wait(kernel.reset());
 			execution.setKernel(kernel);
+			const magic = planMagicCell(invocation.input.language, invocation.input.code, options.pythonEnvironments);
+			// Resolved when the cell's turn comes in the kernel's queue: a %load reads the file the cells ahead of it
+			// wrote, and a refusal settles in queue order like any cell.
+			const loadOptions = { cwd: invocation.ctx.cwd, artifactsDir: options.artifactsDir };
+			const resolveAtStart =
+				magic.kind === "load"
+					? () => loadCell(magic.target, loadOptions)
+					: magic.kind === "refused"
+						? () => ({ ok: false as const, message: magic.message })
+						: undefined;
+			const environments = invocation.input.language === "py" ? options.pythonEnvironments : undefined;
+			const envRoot = environments === undefined ? undefined : () => environments.activeRoot ?? "";
 			const result = await execution.wait(
 				kernel.run({
 					cellId: invocation.cellId,
 					code: invocation.input.code,
+					...(resolveAtStart === undefined ? {} : { resolveAtStart }),
+					...(magic.kind === "host" ? { host: magic.executor } : {}),
+					...(envRoot === undefined ? {} : { envRoot }),
+					...(bridgeCellToken === undefined ? {} : { bridgeCellToken }),
 					kernelPreludes: options.kernelPreludes?.(),
 					onMessage,
 					onStarted: () => {
@@ -285,6 +313,8 @@ async function executeCell(
 		if (error instanceof Error && error.name === "TimeoutError") throw await describeTimeoutState(error, execution);
 		throw error;
 	} finally {
+		// First, so nothing below can skip it: from here on a host call carrying this run's secret gets no kernel tools.
+		releaseCellKernelTools?.();
 		state.active = false;
 		bridgeAbortController.abort();
 		execution.finish();

package/src/tool/types.ts

@@ -8,6 +8,7 @@ import {
 	DEFAULT_RUN_BUDGET_SECONDS,
 	defaultCodemodeSettings,
 } from "../config/settings.ts";
+import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import type { TruncationMeta } from "../output/output-meta.ts";
 
 export const evalLanguageOrder = ["js", "py", "rb", "jl"] as const;
@@ -167,8 +168,29 @@ export interface EvalKernelRunInput {
 	readonly onMessage?: (message: KernelToHostMessage) => void;
 	/** Globals of the tools active when the cell was submitted; kernels without preludes ignore them. */
 	readonly kernelPreludes?: readonly KernelPreludeContribution[];
+	/**
+	 * Python only: read when the cell starts running (not when it was queued), so a cell queued behind `%pip`
+	 * sees the revision it published. `""` means no environment: the previous revision leaves the import path.
+	 */
+	readonly envRoot?: () => string;
+	/** The file a `%load` cell runs: tracebacks name it and its relative imports resolve from its directory. */
+	readonly sourceFile?: string;
+	/**
+	 * Called when the cell's turn comes in the kernel's queue, never earlier: what to run instead of `code` (a `%load`
+	 * cell's file), or a refusal that settles the cell as failed in queue order.
+	 */
+	readonly resolveAtStart?: () => CellSourceAtStart;
+	/**
+	 * Subprocess kernels attach this to the cell's host calls, and the host gives those calls the cell's kernel tools.
+	 * A fresh secret per run, sent only to the kernel that runs the cell; never a model-visible id.
+	 */
+	readonly bridgeCellToken?: string;
 }
 
+export type CellSourceAtStart =
+	| { readonly ok: true; readonly code: string; readonly sourceFile?: string }
+	| { readonly ok: false; readonly message: string };
+
 export interface KernelInterruptHandle {
 	/** Resolves once the kernel knows whether user state survived the interrupt. */
 	readonly stateRetained: Promise<boolean>;
@@ -205,6 +227,11 @@ export interface EvalKernelManager {
 	 * Identity-checked, so releasing a superseded listener never unbinds a newer cell's listener.
 	 */
 	releaseKernelListener?(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): void;
+	/**
+	 * Binds a running cell's kernel-tools capability to the host calls that carry `token` (subprocess kernels reach
+	 * the host over the bridge, outside the cell's async context). The returned release runs when the cell settles.
+	 */
+	bindCellKernelTools?(token: string, capability: KernelToolsCapability): () => void;
 }
 
 export type ExecuteTool = (