@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/question/tests/zz-ig3.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { QuestionList } from "../question-list.ts";
+import { SingleSelect } from "../selection-mode.ts";
+import type { KeybindingsManager, Theme } from "@selesai/code";
+import type { ResolvedShortcut } from "../types.ts";
+
+const fakeTheme = { fg: (_n: string, s: string) => s, bold: (s: string) => s } as unknown as Theme;
+const fakeKeybindings = (actions: string[] = []): KeybindingsManager =>
+	({ matches: (_d: string, a: string) => actions.includes(a), getKeys: () => [] }) as unknown as KeybindingsManager;
+const disabledShortcut: ResolvedShortcut = { disabled: true, spec: null, matches: ((_d: string) => false) as (d: string) => false };
+
+describe("ig3", () => {
+	it("confirm option", () => {
+		const list = new QuestionList([{ value: "a", label: "A" }], SingleSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+		let submitted = false;
+		list.onSubmit = () => (submitted = true);
+		list.handleInput("\r");
+		expect(submitted).toBe(true);
+	});
+});

package/dist/extensions/question/tests/zz-probe.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import questionExtension from "../index.ts";
+
+const theme = { fg: (_n: string, s: string) => s, bg: (_n: string, s: string) => s, bold: (s: string) => s };
+const tui = { requestRender() {}, terminal: { rows: 24 } };
+const keybindings = { matches: () => false, getKeys: () => ["Enter"] };
+
+async function runWizard(params: unknown) {
+	let tool: any;
+	let component: any;
+	let done!: (value: unknown) => void;
+	questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+	const execution = tool.execute("call", params, undefined, undefined, {
+		mode: "tui",
+		ui: { custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => { done = resolve; component = factory(tui, theme, keybindings, done); }) },
+	} as any);
+	return { component: () => component, execution };
+}
+
+describe("probe", () => {
+	it("text question focused false", async () => {
+		const { component, execution } = await runWizard({ questions: [{ type: "text", question: "Type" }] });
+		component().focused = false;
+		component().handleInput("a");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+});

package/dist/extensions/rtk.test.ts

@@ -11,7 +11,7 @@ vi.mock("@selesai/code", async (importOriginal) => ({
 	ensureTool: ensureToolMock,
 }));
 
-import rtkExtension from "./rtk.ts";
+import rtkExtension, { parseSemver } from "./rtk.ts";
 
 // The fake-binary tests need a POSIX shell shim. Windows CI cannot spawn
 // .cmd shims without a shell, and the real flow uses the managed rtk.exe
@@ -138,4 +138,183 @@ posixOnly("rtk extension", () => {
 			rmSync(wrongDir, { recursive: true, force: true });
 		}
 	});
+
+	it("parseSemver returns null for non-version strings", () => {
+		expect(parseSemver("no version here")).toBeNull();
+		expect(parseSemver("")).toBeNull();
+	});
+
+	it("parseSemver parses X.Y.Z from arbitrary text", () => {
+		expect(parseSemver("rtk 0.42.0")).toEqual([0, 42, 0]);
+		expect(parseSemver("  v1.2.3 ")).toEqual([1, 2, 3]);
+	});
+
+	it("disables the extension when --version fails", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		// Override exec so --version fails.
+		pi.exec = vi.fn(async () => ({ code: 1, stdout: "", stderr: "not found", killed: false }));
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed --version")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("disables the extension when the version is unparseable", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		pi.exec = vi.fn(async () => ({ code: 0, stdout: "garbage output", stderr: "", killed: false }));
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("could not parse version")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("disables the extension when the version output is empty", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		pi.exec = vi.fn(async () => ({ code: 0, stdout: "   ", stderr: "", killed: false }));
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("<empty output>")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("disables the extension when the version is too old", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		pi.exec = vi.fn(async () => ({ code: 0, stdout: "rtk 0.22.0", stderr: "", killed: false }));
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("too old")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("warns and skips when ensureTool fails", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		ensureToolMock.mockRejectedValue(new Error("download failed"));
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("managed installation failed")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("warns with the stringified error when ensureTool rejects a non-Error", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		ensureToolMock.mockRejectedValue("plain string failure");
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("plain string failure")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("warns and skips when ensureTool returns nothing", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		ensureToolMock.mockResolvedValue(undefined);
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("unavailable")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("warns and skips when probeRtk throws", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		pi.exec = vi.fn(async () => {
+			throw new Error("spawn ENOENT");
+		});
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("verification failed")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("warns with the stringified error when probeRtk throws a non-Error", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		ensureToolMock.mockResolvedValue("rtk");
+		pi.exec = vi.fn(async () => {
+			throw "string failure";
+		});
+		rtkExtension(pi);
+		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("string failure")));
+		expect(handlers.has("tool_call")).toBe(false);
+	});
+
+	it("ignores non-bash tool calls and empty commands", async () => {
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		const handler = await getToolCall(handlers);
+
+		const nonBash: any = { type: "tool_call", toolName: "edit", toolCallId: "c1", input: { path: "a.ts" } };
+		await handler(nonBash, { signal: undefined });
+		expect(nonBash.input.path).toBe("a.ts");
+
+		const nonString: any = { type: "tool_call", toolName: "bash", toolCallId: "c2", input: { command: 42 } };
+		await handler(nonString, { signal: undefined });
+		expect(nonString.input.command).toBe(42);
+
+		const empty: any = { type: "tool_call", toolName: "bash", toolCallId: "c3", input: { command: "   " } };
+		await handler(empty, { signal: undefined });
+		expect(empty.input.command).toBe("   ");
+	});
+
+	it("passes through when RTK_DISABLED is set mid-run", async () => {
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		const handler = await getToolCall(handlers);
+
+		process.env.RTK_DISABLED = "1";
+		try {
+			const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
+			await handler(event, { signal: undefined });
+			expect(event.input.command).toBe("git status");
+		} finally {
+			delete process.env.RTK_DISABLED;
+		}
+	});
+
+	it("passes through when rewrite is killed or returns an unexpected code", async () => {
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		const handler = await getToolCall(handlers);
+
+		// The probe (--version + gain) already ran against the real fake binary,
+		// so the mock's responses are consumed by the rewrite call only.
+		// Killed rewrite.
+		pi.exec = vi.fn().mockResolvedValueOnce({ code: 0, stdout: "", stderr: "", killed: true });
+		const event1: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
+		await handler(event1, { signal: undefined });
+		expect(event1.input.command).toBe("git status");
+
+		// Unexpected exit code (2).
+		pi.exec = vi.fn().mockResolvedValueOnce({ code: 2, stdout: "", stderr: "err", killed: false });
+		const event2: any = { type: "tool_call", toolName: "bash", toolCallId: "c2", input: { command: "git status" } };
+		await handler(event2, { signal: undefined });
+		expect(event2.input.command).toBe("git status");
+	});
+
+	it("passes through when rewrite returns empty stdout", async () => {
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		const handler = await getToolCall(handlers);
+
+		pi.exec = vi.fn().mockResolvedValueOnce({ code: 0, stdout: "   ", stderr: "", killed: false });
+		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
+		await handler(event, { signal: undefined });
+		expect(event.input.command).toBe("git status");
+	});
+
+	it("fails open when the tool_call handler throws", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+		const handler = await getToolCall(handlers);
+
+		pi.exec = vi.fn().mockRejectedValueOnce(new Error("boom"));
+		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
+		await handler(event, { signal: undefined });
+		expect(event.input.command).toBe("git status");
+		expect(warn).toHaveBeenCalledWith(expect.stringContaining("unexpected error"), expect.any(Error));
+	});
 });

package/dist/extensions/tokenin-onboarding.ts

@@ -369,6 +369,9 @@ async function runOnboarding(pi: ExtensionAPI, ctx: ExtensionContext): Promise<v
 		if (!storedKey && typeof legacyModelsKey === "string") {
 			setStoredTokenInApiKey(ctx.modelRegistry.authStorage, legacyModelsKey);
 			saveTokenInAccount(legacyModelsKey, { baseUrl: getTokenInBaseUrl(models), setActive: true });
+			// legacyModelsKey is only non-empty when models.json parsed successfully,
+			// so the file always exists here.
+			/* v8 ignore next 1 */
 			if (existsSync(modelsPath)) writeModelsJson(removeTokenInApiKey(models), modelsPath);
 		}
 		markOnboardingComplete();