@selesai/code 0.8.4 → 0.8.6

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();