@nubase/terminal 0.0.0-stage → 0.1.1

package/out/main/index.js

@@ -0,0 +1,3240 @@
+import { createRequire } from "node:module";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { BaseWindow, BrowserWindow, Menu, WebContentsView, app, dialog, ipcMain, nativeImage, net, protocol, safeStorage, shell } from "electron";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { accessSync, chmodSync, constants, createReadStream, existsSync, mkdirSync, statSync, watch } from "node:fs";
+import { cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { Readable } from "node:stream";
+import * as sdkHost from "@nubase/sdk/host";
+import { defineHostExtension } from "@nubase/sdk/host";
+import yauzl from "yauzl";
+import { DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, createAgentSession } from "@earendil-works/pi-coding-agent";
+//#region src/common/fileUrl.ts
+/** Streams local files to the renderer, so images, media and PDFs load by URL at any size. */
+var FILE_PROTOCOL = "nubase-file";
+var HOST = "local";
+var fromFileUrl = (url) => {
+	const parsed = new URL(url);
+	if (parsed.protocol !== `nubase-file:` || parsed.hostname !== HOST) return;
+	const path = decodeURIComponent(parsed.pathname);
+	return /^\/[a-zA-Z]:\//.test(path) ? path.slice(1) : path;
+};
+//#endregion
+//#region src/common/host-contract.ts
+var INVOKE_CHANNEL = "nubase:invoke";
+var EVENT_CHANNEL = "nubase:event";
+var EXTENSION_PROTOCOL = "nubase-ext";
+//#endregion
+//#region src/main/menu.ts
+/**
+* A minimal menu: keeps the OS edit shortcuts (copy/paste) working while
+* leaving shortcuts like ⌘W to Nubase's own keybinding system.
+*/
+var installApplicationMenu = (actions) => {
+	Menu.setApplicationMenu(Menu.buildFromTemplate([
+		...process.platform === "darwin" ? [{
+			label: app.name,
+			submenu: [
+				{ role: "about" },
+				{ type: "separator" },
+				{ role: "hide" },
+				{ role: "hideOthers" },
+				{ role: "unhide" },
+				{ type: "separator" },
+				{ role: "quit" }
+			]
+		}] : [],
+		{
+			label: "File",
+			submenu: [{
+				label: "Open Folder…",
+				click: () => actions.openFolder()
+			}]
+		},
+		{
+			label: "Edit",
+			submenu: [
+				{ role: "undo" },
+				{ role: "redo" },
+				{ type: "separator" },
+				{ role: "cut" },
+				{ role: "copy" },
+				{ role: "paste" },
+				{ role: "selectAll" }
+			]
+		},
+		{
+			label: "View",
+			submenu: [
+				{ role: "toggleDevTools" },
+				{ type: "separator" },
+				{ role: "resetZoom" },
+				{ role: "zoomIn" },
+				{ role: "zoomOut" },
+				{ type: "separator" },
+				{ role: "togglefullscreen" }
+			]
+		},
+		{ role: "windowMenu" }
+	]));
+};
+//#endregion
+//#region src/main/paths.ts
+/** Override with NUBASE_HOME to run against a scratch directory. */
+var nubaseHome = process.env.NUBASE_HOME ?? join(homedir(), ".nubase");
+var HOME_WORKSPACE_ID = "home";
+var paths = {
+	home: nubaseHome,
+	settings: join(nubaseHome, "settings.json"),
+	/** Open folder tabs, in order, and the active one. */
+	workspaces: join(nubaseHome, "workspaces.json"),
+	/** The layout before folder tabs existed; migrated into the `~` tab. */
+	legacyLayout: join(nubaseHome, "workspaces", "default", "layout.json"),
+	storage: join(nubaseHome, "storage"),
+	secrets: join(nubaseHome, "secrets.json"),
+	extensions: join(nubaseHome, "extensions"),
+	agentDir: join(nubaseHome, "agent"),
+	logs: join(nubaseHome, "logs")
+};
+var workspaceIdOf = (folder) => folder === homedir() ? HOME_WORKSPACE_ID : createHash("sha1").update(folder).digest("hex").slice(0, 12);
+/** Per-machine state of one folder tab (layout, extension history). Never inside the folder itself. */
+var workspacePaths = (id) => {
+	const dir = join(nubaseHome, "workspaces", id);
+	return {
+		dir,
+		layout: join(dir, "layout.json"),
+		extensionsGitDir: join(dir, "extensions.git")
+	};
+};
+/** Shareable configuration a folder can carry in its own `.nubase`. */
+var folderPaths = (folder) => {
+	const dir = join(folder, ".nubase");
+	return {
+		dir,
+		settings: join(dir, "settings.json"),
+		extensions: join(dir, "extensions")
+	};
+};
+//#endregion
+//#region src/main/services/extensions/sharedModules.ts
+/**
+* Modules provided by the host at runtime instead of being bundled into each
+* extension. Sharing them guarantees a single React instance and a single
+* set of registries. Keep in sync with the renderer's module table.
+*/
+var UI_SHARED_MODULES = [
+	"react",
+	"react-dom",
+	"react-dom/client",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"@nubase/ui",
+	"@nubase/sdk",
+	"lucide-react"
+];
+var HOST_SHARED_MODULES = ["@nubase/sdk/host", "@nubase/sdk"];
+var UI_MODULES_GLOBAL = "__nubase_modules";
+var HOST_MODULES_GLOBAL = "__nubase_host_modules";
+//#endregion
+//#region src/main/services/extensions/ExtensionBuilder.ts
+var nodeRequire$1 = createRequire(import.meta.url);
+/**
+* Rewrites imports of shared modules to read them from a global the host
+* fills in. Shims are CommonJS so esbuild's interop maps named imports onto
+* properties, without having to know each module's export list.
+*/
+var sharedModulesPlugin = (modules, globalName) => ({
+	name: "nubase-shared-modules",
+	setup(build) {
+		const filter = new RegExp(`^(${modules.map((m) => m.replace(/[/.]/g, "\\$&")).join("|")})$`);
+		build.onResolve({ filter }, (args) => ({
+			path: args.path,
+			namespace: "nubase-shared"
+		}));
+		build.onLoad({
+			filter: /.*/,
+			namespace: "nubase-shared"
+		}, (args) => ({
+			contents: `module.exports = globalThis.${globalName}[${JSON.stringify(args.path)}];`,
+			loader: "js"
+		}));
+	}
+});
+var toDiagnostics = (messages, source, root) => messages.map((m) => ({
+	source,
+	message: m.text,
+	file: m.location?.file ? relative(root, join(root, m.location.file)) : void 0,
+	line: m.location?.line,
+	column: m.location?.column
+}));
+/** Builds extensions from source: bundles (esbuild), styles (Tailwind) and typechecks (tsc). */
+var ExtensionBuilder = class {
+	async build(dir, manifest) {
+		const esbuild = await import("esbuild");
+		const outputs = [];
+		const diagnostics = [];
+		const bundle = async (entry, options) => {
+			try {
+				const result = await esbuild.build({
+					absWorkingDir: dir,
+					entryPoints: [join(dir, entry)],
+					bundle: true,
+					write: false,
+					platform: options.platform,
+					format: options.format,
+					target: options.platform === "node" ? "node22" : "chrome130",
+					outfile: options.outfile,
+					jsx: "automatic",
+					sourcemap: "inline",
+					logLevel: "silent",
+					plugins: [options.plugin],
+					external: options.platform === "node" ? ["electron"] : [],
+					define: { "process.env.NODE_ENV": "\"production\"" }
+				});
+				outputs.push(...result.outputFiles);
+			} catch (error) {
+				const failure = error;
+				diagnostics.push(...failure.errors ? toDiagnostics(failure.errors, "esbuild", dir) : [{
+					source: "esbuild",
+					message: String(error)
+				}]);
+			}
+		};
+		if (manifest.ui) await bundle(manifest.ui, {
+			platform: "browser",
+			format: "esm",
+			outfile: join(dir, "dist", "ui.js"),
+			plugin: sharedModulesPlugin(UI_SHARED_MODULES, UI_MODULES_GLOBAL)
+		});
+		if (manifest.host) await bundle(manifest.host, {
+			platform: "node",
+			format: "cjs",
+			outfile: join(dir, "dist", "host.cjs"),
+			plugin: sharedModulesPlugin(HOST_SHARED_MODULES, HOST_MODULES_GLOBAL)
+		});
+		if (diagnostics.length > 0) return {
+			ok: false,
+			diagnostics
+		};
+		diagnostics.push(...await this.typecheck(dir));
+		if (diagnostics.length > 0) return {
+			ok: false,
+			diagnostics
+		};
+		let css;
+		if (manifest.ui) {
+			try {
+				css = await this.buildStyles(join(dir, dirname(manifest.ui)));
+			} catch (error) {
+				return {
+					ok: false,
+					diagnostics: [{
+						source: "tailwind",
+						message: error.message
+					}]
+				};
+			}
+			if (css) outputs.push({
+				path: join(dir, "dist", "ui.css"),
+				contents: css
+			});
+		}
+		const hash = createHash("sha256");
+		await mkdir(join(dir, "dist"), { recursive: true });
+		for (const output of outputs) {
+			hash.update(output.contents);
+			await writeFile(output.path, output.contents);
+		}
+		return {
+			ok: true,
+			buildId: hash.digest("hex").slice(0, 12),
+			hasUi: Boolean(manifest.ui),
+			hasHost: Boolean(manifest.host),
+			hasCss: Boolean(css)
+		};
+	}
+	/** Compiles only the Tailwind utilities the extension's sources use. */
+	async buildStyles(sourceDir) {
+		const { compile } = await import("@tailwindcss/node");
+		const { Scanner } = await import("@tailwindcss/oxide");
+		const compiler = await compile([
+			"@import \"tailwindcss/theme\" layer(theme);",
+			"@import \"tailwindcss/utilities\" layer(utilities);",
+			"@import \"tw-animate-css\";",
+			(await readFile(nodeRequire$1.resolve("@nubase/ui/theme.css"), "utf8")).split("\n").filter((line) => !line.startsWith("@import")).join("\n")
+		].join("\n"), {
+			base: dirname(nodeRequire$1.resolve("tailwindcss/package.json")),
+			onDependency: () => {}
+		});
+		const candidates = new Scanner({ sources: [{
+			base: sourceDir,
+			pattern: "**/*",
+			negated: false
+		}] }).scan();
+		return candidates.length > 0 ? compiler.build(candidates) : void 0;
+	}
+	async typecheck(dir) {
+		const configPath = join(dir, "tsconfig.json");
+		if (!existsSync(configPath)) return [];
+		const ts = (await import("typescript")).default;
+		const config = ts.readConfigFile(configPath, ts.sys.readFile);
+		if (config.error) return [{
+			source: "typescript",
+			message: ts.flattenDiagnosticMessageText(config.error.messageText, "\n")
+		}];
+		const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, dir);
+		const program = ts.createProgram({
+			rootNames: parsed.fileNames,
+			options: {
+				...parsed.options,
+				noEmit: true
+			}
+		});
+		return ts.getPreEmitDiagnostics(program).filter((d) => d.category === ts.DiagnosticCategory.Error).slice(0, 30).map((d) => {
+			const position = d.file && d.start !== void 0 ? d.file.getLineAndCharacterOfPosition(d.start) : void 0;
+			return {
+				source: "typescript",
+				message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+				file: d.file ? relative(dir, d.file.fileName) : void 0,
+				line: position ? position.line + 1 : void 0,
+				column: position ? position.character + 1 : void 0
+			};
+		});
+	}
+};
+/** Absolute paths to the type declarations extensions compile against. */
+var resolveTypePaths = () => {
+	const typesOf = (pkg, file) => {
+		try {
+			return [join(dirname(nodeRequire$1.resolve(`${pkg}/package.json`)), file)];
+		} catch {
+			return [];
+		}
+	};
+	return {
+		react: typesOf("@types/react", "index.d.ts"),
+		"react/jsx-runtime": typesOf("@types/react", "jsx-runtime.d.ts"),
+		"react-dom": typesOf("@types/react-dom", "index.d.ts"),
+		"react-dom/client": typesOf("@types/react-dom", "client.d.ts"),
+		"@nubase/ui": typesOf("@nubase/ui", "dist/index.d.ts"),
+		"@nubase/sdk": typesOf("@nubase/sdk", "dist/index.d.ts"),
+		"@nubase/sdk/host": typesOf("@nubase/sdk", "dist/host.d.ts"),
+		"lucide-react": typesOf("lucide-react", "dist/lucide-react.d.ts")
+	};
+};
+var resolveTypeRoots = () => {
+	try {
+		return [dirname(dirname(nodeRequire$1.resolve("@types/node/package.json")))];
+	} catch {
+		return [];
+	}
+};
+//#endregion
+//#region src/main/services/extensions/manifest.ts
+var ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+var ManifestError = class extends Error {};
+/** Reads the `nubase` field of `<dir>/package.json`. */
+var readManifest = async (dir) => {
+	let pkg;
+	try {
+		pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+	} catch (error) {
+		throw new ManifestError(`Cannot read package.json: ${error.message}`);
+	}
+	const nubase = pkg.nubase;
+	if (!nubase) throw new ManifestError("package.json has no \"nubase\" field");
+	if (!nubase.id || !ID_PATTERN.test(nubase.id)) throw new ManifestError(`"nubase.id" must be lowercase kebab-case (got ${JSON.stringify(nubase.id)})`);
+	if (!nubase.ui && !nubase.host) throw new ManifestError("\"nubase\" must declare a \"ui\" and/or \"host\" entry");
+	return {
+		id: nubase.id,
+		displayName: nubase.displayName ?? nubase.id,
+		description: nubase.description,
+		ui: nubase.ui,
+		host: nubase.host
+	};
+};
+var isValidExtensionId = (id) => ID_PATTERN.test(id);
+//#endregion
+//#region src/main/services/extensions/ExtensionSource.ts
+var nodeRequire = createRequire(import.meta.url);
+/**
+* One extensions directory: discovers, builds, watches and versions the
+* extensions in it. Builds happen once per directory no matter how many
+* folder tabs use it; each tab's ExtensionHost activates the results.
+*/
+var ExtensionSource = class {
+	entries = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	watcher;
+	pendingChanges = /* @__PURE__ */ new Map();
+	started;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	get key() {
+		return this.deps.key;
+	}
+	get kind() {
+		return this.deps.kind;
+	}
+	get dir() {
+		return this.deps.dir;
+	}
+	start() {
+		this.started ??= (async () => {
+			await this.deps.repo.ensure();
+			await this.discover();
+			this.watch();
+		})();
+		return this.started;
+	}
+	ids() {
+		return [...this.entries.keys()];
+	}
+	get(id) {
+		return this.entries.get(id);
+	}
+	/** True when the folder exists on disk, even if it was never built. */
+	contains(id) {
+		return this.entries.has(id) || existsSync(join(this.pathOf(id), "package.json"));
+	}
+	pathOf(id) {
+		return join(this.deps.dir, id);
+	}
+	toInfo(entry) {
+		return {
+			id: entry.id,
+			displayName: entry.displayName,
+			description: entry.description,
+			path: entry.dir,
+			builtin: false,
+			source: this.deps.kind,
+			status: entry.status,
+			diagnostics: entry.diagnostics,
+			buildId: entry.buildId,
+			uiBundleUrl: entry.uiBundleUrl,
+			uiStylesUrl: entry.uiStylesUrl
+		};
+	}
+	/** Called after every status change; `rebuild` waits for listeners to finish. */
+	onChanged(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	async rebuild(id) {
+		let entry = this.entries.get(id);
+		if (!entry) {
+			await this.discover(id);
+			entry = this.entries.get(id);
+			if (!entry) throw new Error(`No extension "${id}" in ${this.deps.dir}`);
+			return entry.building ?? entry;
+		}
+		if (entry.building) {
+			entry.rebuildQueued = true;
+			return entry.building;
+		}
+		const current = entry;
+		current.building = this.doBuild(current).finally(() => {
+			current.building = void 0;
+		});
+		const result = await current.building;
+		if (current.rebuildQueued) {
+			current.rebuildQueued = false;
+			return this.rebuild(id);
+		}
+		return result;
+	}
+	async revert(id) {
+		const commit = await this.deps.repo.revertExtension(id);
+		await this.rebuild(id);
+		return commit;
+	}
+	/** Loads the host half of the current build (cached per build). */
+	loadHost(id) {
+		const entry = this.entries.get(id);
+		if (!entry?.buildId || !entry.hasHost) throw new Error(`"${id}" has no built host half`);
+		if (entry.host?.buildId === entry.buildId) return entry.host.extension;
+		const hostFile = join(entry.dir, "dist", "host.cjs");
+		delete nodeRequire.cache[nodeRequire.resolve(hostFile)];
+		const loaded = nodeRequire(hostFile);
+		const extension = loaded?.default ?? loaded;
+		if (typeof extension?.activate !== "function") throw new Error("host entry must `export default defineHostExtension({ activate })`");
+		entry.host = {
+			buildId: entry.buildId,
+			extension
+		};
+		return extension;
+	}
+	/** Resolves `<id>/<file>` from a `nubase-ext://<key>/<id>/<file>` URL to a file in dist/. */
+	resolveAsset(path) {
+		const [id, ...rest] = decodeURIComponent(path).replace(/^\//, "").split("/");
+		if (!id || !this.entries.has(id)) return void 0;
+		const dist = join(this.pathOf(id), "dist");
+		const file = join(dist, ...rest);
+		return file.startsWith(dist + sep) ? file : void 0;
+	}
+	dispose() {
+		this.watcher?.close();
+		for (const timer of this.pendingChanges.values()) clearTimeout(timer);
+		this.listeners.clear();
+	}
+	async discover(onlyId) {
+		if (!existsSync(this.deps.dir)) return;
+		const entries = await readdir(this.deps.dir, { withFileTypes: true });
+		for (const dirent of entries) {
+			if (!dirent.isDirectory() || dirent.name.startsWith(".")) continue;
+			if (onlyId && dirent.name !== onlyId) continue;
+			if (this.entries.has(dirent.name)) continue;
+			const dir = join(this.deps.dir, dirent.name);
+			if (!existsSync(join(dir, "package.json"))) continue;
+			this.entries.set(dirent.name, {
+				id: dirent.name,
+				dir,
+				displayName: dirent.name,
+				status: "building",
+				diagnostics: [],
+				hasHost: false
+			});
+			await this.rebuild(dirent.name);
+		}
+	}
+	async doBuild(entry) {
+		const { id, dir } = entry;
+		entry.status = "building";
+		await this.notify(id);
+		let manifest;
+		try {
+			manifest = await readManifest(dir);
+			if (manifest.id !== id) throw new ManifestError(`"nubase.id" (${manifest.id}) must match the folder name (${id})`);
+		} catch (error) {
+			return this.fail(entry, [{
+				source: "esbuild",
+				file: "package.json",
+				message: error.message
+			}]);
+		}
+		entry.displayName = manifest.displayName;
+		entry.description = manifest.description;
+		const result = await this.deps.builder.build(dir, manifest);
+		if (!result.ok) return this.fail(entry, result.diagnostics);
+		const url = (file) => `${EXTENSION_PROTOCOL}://${this.deps.key}/${id}/${file}?v=${result.buildId}`;
+		entry.status = "active";
+		entry.diagnostics = [];
+		entry.buildId = result.buildId;
+		entry.hasHost = result.hasHost;
+		entry.uiBundleUrl = result.hasUi ? url("ui.js") : void 0;
+		entry.uiStylesUrl = result.hasCss ? url("ui.css") : void 0;
+		await this.deps.repo.commitExtension(id, `nubase: ${id} built successfully`).catch((error) => console.warn(`Could not commit ${id}`, error));
+		await this.notify(id);
+		return entry;
+	}
+	async fail(entry, diagnostics) {
+		entry.status = "build-failed";
+		entry.diagnostics = diagnostics;
+		await this.notify(entry.id);
+		return entry;
+	}
+	async notify(id) {
+		await Promise.all([...this.listeners].map(async (listener) => {
+			try {
+				await listener(id);
+			} catch (error) {
+				console.error(`Extension listener failed for ${id}`, error);
+			}
+		}));
+	}
+	watch() {
+		if (!existsSync(this.deps.dir)) return;
+		try {
+			this.watcher = watch(this.deps.dir, { recursive: true }, (_e, filename) => {
+				if (!filename) return;
+				const [id, ...rest] = relative(this.deps.dir, join(this.deps.dir, filename.toString())).split(sep);
+				if (!id || id.startsWith(".") || rest.length === 0) return;
+				if ([
+					"dist",
+					"node_modules",
+					".git"
+				].includes(rest[0] ?? "")) return;
+				clearTimeout(this.pendingChanges.get(id));
+				this.pendingChanges.set(id, setTimeout(() => {
+					this.pendingChanges.delete(id);
+					if (!existsSync(join(this.deps.dir, id, "package.json"))) return;
+					this.rebuild(id).catch((error) => console.error(`Rebuild of ${id} failed`, error));
+				}, 400));
+			});
+		} catch (error) {
+			console.warn(`Could not watch ${this.deps.dir}`, error);
+		}
+	}
+};
+//#endregion
+//#region src/main/services/extensions/git.ts
+var exec = promisify(execFile);
+/**
+* The extensions folder is a git repository. Every successful build is
+* committed, so a broken change can always be reverted to the last version
+* that built.
+*
+* A folder's own extensions live inside the user's project, so their
+* history goes to a separate `gitDir` under `~/.nubase` instead of a nested
+* `.git` the project would see.
+*/
+var ExtensionsRepo = class {
+	available = true;
+	constructor(dir, gitDir) {
+		this.dir = dir;
+		this.gitDir = gitDir;
+	}
+	async ensure() {
+		try {
+			if (!existsSync(this.gitDir ?? join(this.dir, ".git"))) {
+				await this.git("init", "-q");
+				await this.commitAll("nubase: initialize extensions repository");
+			}
+		} catch (error) {
+			this.available = false;
+			console.warn(`git unavailable; extension history disabled: ${error.message}`);
+		}
+	}
+	/** Commits the extension folder if it changed; returns the short hash. */
+	async commitExtension(id, message) {
+		if (!this.available) return void 0;
+		await this.git("add", "-A", "--", id);
+		if (!await this.git("diff", "--cached", "--quiet", "--", id).then(() => false, () => true)) return void 0;
+		await this.git("commit", "-q", "-m", message, "--", id);
+		return (await this.git("rev-parse", "--short", "HEAD")).trim();
+	}
+	/**
+	* Undoes the latest change to an extension. Uncommitted edits are discarded
+	* first (back to the last successful build); with none, the extension steps
+	* back one build — a version can build and still misbehave at runtime.
+	* Repeated calls walk further back through history.
+	*/
+	async revertExtension(id) {
+		if (!this.available) throw new Error("git is not available");
+		if (!(await this.git("ls-files", "--", id)).trim()) throw new Error(`"${id}" has never built successfully, so there is nothing to revert to`);
+		if ((await this.git("status", "--porcelain", "--", id)).trim()) {
+			await this.git("checkout", "HEAD", "--", id);
+			await this.git("clean", "-fdq", "--", id);
+			return `discarded unsaved changes; back to build ${(await this.git("log", "-1", "--format=%h", "--", id)).trim()}`;
+		}
+		const [, previous] = (await this.git("log", "-2", "--format=%h", "--", id)).trim().split("\n");
+		if (!previous) throw new Error(`"${id}" has no earlier version to revert to`);
+		await this.git("rm", "-rq", "--cached", "--ignore-unmatch", "--", id);
+		await this.git("clean", "-fdq", "--", id);
+		await this.git("checkout", previous, "--", id);
+		await this.git("add", "-A", "--", id);
+		await this.git("commit", "-q", "-m", `nubase: revert ${id} to ${previous}`, "--", id);
+		return `reverted to build ${previous}`;
+	}
+	async log(id, limit = 10) {
+		if (!this.available) return "";
+		return this.git("log", `-${limit}`, "--format=%h %ad %s", "--date=relative", "--", id);
+	}
+	async commitAll(message) {
+		await this.git("add", "-A");
+		await this.git("commit", "-q", "--allow-empty", "-m", message);
+	}
+	async git(...args) {
+		const identity = args[0] === "commit" ? [
+			"-c",
+			"user.name=Nubase",
+			"-c",
+			"user.email=nubase@localhost"
+		] : [];
+		const { stdout } = await exec("git", [
+			...this.gitDir ? [`--git-dir=${this.gitDir}`, `--work-tree=${this.dir}`] : [],
+			...identity,
+			...args
+		], {
+			cwd: this.dir,
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return stdout;
+	}
+};
+//#endregion
+//#region src/main/services/extensions/workspace.ts
+/**
+* Prepares the extensions folder: shared tsconfig (pointing at the types
+* this Nubase version ships), agent guidance and git ignores. Rewritten on
+* every start so it always matches the running app.
+*/
+var prepareExtensionsWorkspace = async (dir, resourcesDir, options = {}) => {
+	await mkdir(dir, { recursive: true });
+	const tsconfig = { compilerOptions: {
+		target: "ES2022",
+		module: "ESNext",
+		moduleResolution: "bundler",
+		jsx: "react-jsx",
+		lib: [
+			"ES2023",
+			"DOM",
+			"DOM.Iterable"
+		],
+		strict: true,
+		skipLibCheck: true,
+		noEmit: true,
+		isolatedModules: true,
+		esModuleInterop: true,
+		types: ["node"],
+		typeRoots: resolveTypeRoots(),
+		paths: resolveTypePaths()
+	} };
+	await writeFile(join(dir, "tsconfig.base.json"), `// Generated by Nubase on startup. Do not edit.\n${JSON.stringify(tsconfig, null, 2)}\n`);
+	await writeFile(join(dir, ".gitignore"), options.inProject ? "node_modules/\ndist/\ntsconfig.base.json\nAGENTS.md\n" : "node_modules/\ndist/\n");
+	await cp(join(resourcesDir, "skills", "nubase-extension-authoring", "SKILL.md"), join(dir, "AGENTS.md"));
+};
+/** Creates a new extension from the bundled template. */
+var scaffoldExtension = async (extensionsDir, templateDir, options) => {
+	if (!isValidExtensionId(options.id)) throw new Error(`Invalid id "${options.id}": use lowercase kebab-case, e.g. "jira-tickets"`);
+	const target = join(extensionsDir, options.id);
+	if (existsSync(target)) throw new Error(`An extension already exists at ${target}`);
+	const replacements = {
+		__ID__: options.id,
+		__DISPLAY_NAME__: options.displayName,
+		__DESCRIPTION__: options.description ?? "",
+		__WIDGET_ID__: `${options.id}.main`
+	};
+	const copy = async (from, to) => {
+		await mkdir(to, { recursive: true });
+		for (const entry of await readdir(from, { withFileTypes: true })) {
+			const name = entry.name.replace(/\.template$/, "");
+			if (!options.withHost && name === "host.ts") continue;
+			if (entry.isDirectory()) {
+				await copy(join(from, entry.name), join(to, name));
+				continue;
+			}
+			let content = await readFile(join(from, entry.name), "utf8");
+			for (const [token, value] of Object.entries(replacements)) content = content.replaceAll(token, value);
+			if (name === "package.json" && !options.withHost) {
+				const pkg = JSON.parse(content);
+				delete pkg.nubase.host;
+				content = `${JSON.stringify(pkg, null, 2)}\n`;
+			}
+			await writeFile(join(to, name), content);
+		}
+	};
+	await copy(templateDir, target);
+	return target;
+};
+//#endregion
+//#region src/main/services/fs/fileProtocol.ts
+var MIME_TYPES$1 = {
+	apng: "image/apng",
+	avif: "image/avif",
+	bmp: "image/bmp",
+	gif: "image/gif",
+	ico: "image/x-icon",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	png: "image/png",
+	svg: "image/svg+xml",
+	webp: "image/webp",
+	mp4: "video/mp4",
+	m4v: "video/mp4",
+	mov: "video/quicktime",
+	webm: "video/webm",
+	ogv: "video/ogg",
+	mkv: "video/x-matroska",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	oga: "audio/ogg",
+	opus: "audio/opus",
+	m4a: "audio/mp4",
+	aac: "audio/aac",
+	flac: "audio/flac",
+	weba: "audio/webm",
+	pdf: "application/pdf",
+	html: "text/html; charset=utf-8",
+	htm: "text/html; charset=utf-8",
+	css: "text/css; charset=utf-8",
+	js: "text/javascript; charset=utf-8",
+	mjs: "text/javascript; charset=utf-8",
+	json: "application/json; charset=utf-8",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8",
+	csv: "text/csv; charset=utf-8",
+	xml: "application/xml",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	woff: "font/woff",
+	woff2: "font/woff2"
+};
+var mimeTypeOf = (path) => MIME_TYPES$1[extname(path).slice(1).toLowerCase()] ?? "application/octet-stream";
+var parseRange = (header, size) => {
+	const match = header?.match(/^bytes=(\d*)-(\d*)$/);
+	if (!match) return void 0;
+	const [, from = "", to = ""] = match;
+	if (!from && !to) return "invalid";
+	const start = from ? Number(from) : Math.max(0, size - Number(to));
+	const end = from && to ? Math.min(Number(to), size - 1) : size - 1;
+	if (start > end || start >= size) return "invalid";
+	return {
+		start,
+		end
+	};
+};
+/** Serves `nubase-file://local/<path>` with Range support, so video can seek and large files stream. */
+var handleFileRequest = async (request) => {
+	if (request.method !== "GET" && request.method !== "HEAD") return new Response("Method not allowed", { status: 405 });
+	const path = fromFileUrl(request.url);
+	if (!path) return new Response("Not found", { status: 404 });
+	let size;
+	try {
+		const info = await stat(path);
+		if (!info.isFile()) return new Response("Not a file", { status: 404 });
+		size = info.size;
+	} catch {
+		return new Response("Not found", { status: 404 });
+	}
+	const headers = {
+		"Content-Type": mimeTypeOf(path),
+		"Accept-Ranges": "bytes",
+		"Access-Control-Allow-Origin": "*",
+		"Cache-Control": "no-store",
+		"X-Content-Type-Options": "nosniff"
+	};
+	const range = parseRange(request.headers.get("Range"), size);
+	if (range === "invalid") return new Response(null, {
+		status: 416,
+		headers: {
+			...headers,
+			"Content-Range": `bytes */${size}`
+		}
+	});
+	const { start, end } = range ?? {
+		start: 0,
+		end: size - 1
+	};
+	const length = size === 0 ? 0 : end - start + 1;
+	headers["Content-Length"] = String(length);
+	if (range) headers["Content-Range"] = `bytes ${start}-${end}/${size}`;
+	const body = request.method === "HEAD" || length === 0 ? null : Readable.toWeb(createReadStream(path, {
+		start,
+		end
+	}));
+	return new Response(body, {
+		status: range ? 206 : 200,
+		headers
+	});
+};
+//#endregion
+//#region src/main/services/fs/LocalFileSystem.ts
+var fileType = (entry) => {
+	if (entry.isFile()) return "file";
+	if (entry.isDirectory()) return "directory";
+	if (entry.isSymbolicLink()) return "symlink";
+	return "other";
+};
+/** FileSystem backed by the machine's disk. */
+var LocalFileSystem = class {
+	homeDir = homedir();
+	async readText(path) {
+		return readFile(resolve(path), "utf8");
+	}
+	async writeText(path, content) {
+		const target = resolve(path);
+		await mkdir(dirname(target), { recursive: true });
+		await writeFile(target, content, "utf8");
+	}
+	async stat(path) {
+		try {
+			const s = await stat(resolve(path));
+			return {
+				type: fileType(s),
+				size: s.size,
+				mtimeMs: s.mtimeMs
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			throw error;
+		}
+	}
+	async readDirectory(path) {
+		const dir = resolve(path);
+		return (await readdir(dir, { withFileTypes: true })).map((entry) => ({
+			name: entry.name,
+			path: join(dir, entry.name),
+			type: fileType(entry)
+		})).sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1);
+	}
+	async mkdir(path) {
+		await mkdir(resolve(path), { recursive: true });
+	}
+	async delete(path, options) {
+		await rm(resolve(path), { recursive: options?.recursive ?? false });
+	}
+	async rename(from, to) {
+		await rename(resolve(from), resolve(to));
+	}
+	watch(path, listener, options) {
+		const root = resolve(path);
+		const watcher = watch(root, { recursive: options?.recursive ?? false }, (eventType, filename) => {
+			const changed = filename ? join(root, filename.toString()) : root;
+			if (eventType === "change") {
+				listener({
+					type: "changed",
+					path: changed
+				});
+				return;
+			}
+			stat(changed).then(() => listener({
+				type: "created",
+				path: changed
+			}), () => listener({
+				type: "deleted",
+				path: changed
+			}));
+		});
+		watcher.on("error", () => watcher.close());
+		return { dispose: () => watcher.close() };
+	}
+};
+//#endregion
+//#region src/main/services/store/JsonFile.ts
+/**
+* A JSON document on disk. Writes are atomic, and external edits (by the
+* user or the agent) are reported through `onExternalChange`.
+*/
+var JsonFile = class {
+	lastWritten;
+	watcher;
+	constructor(path) {
+		this.path = path;
+	}
+	async read() {
+		try {
+			return JSON.parse(await readFile(this.path, "utf8"));
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+			if (error instanceof SyntaxError) {
+				console.error(`Ignoring invalid JSON in ${this.path}: ${error.message}`);
+				return;
+			}
+			throw error;
+		}
+	}
+	async write(value) {
+		const content = `${JSON.stringify(value, null, 2)}\n`;
+		this.lastWritten = content;
+		await mkdir(dirname(this.path), { recursive: true });
+		const temp = `${this.path}.${process.pid}.tmp`;
+		await writeFile(temp, content, "utf8");
+		await rename(temp, this.path);
+	}
+	/**
+	* With `createDir: false` a missing parent folder is not created; the
+	* file is picked up once someone creates the folder.
+	*/
+	onExternalChange(listener, options = {}) {
+		const dir = dirname(this.path);
+		if (options.createDir === false && !existsSync(dir)) {
+			const parent = dirname(dir);
+			if (!existsSync(parent)) return () => {};
+			this.watcher = watch(parent, (_event, filename) => {
+				if (filename?.toString() !== basename(dir) || !existsSync(dir)) return;
+				this.watcher?.close();
+				this.watchFile(listener);
+				this.read().then((value) => {
+					if (value !== void 0) listener(value);
+				});
+			});
+			return () => this.watcher?.close();
+		}
+		mkdirSync(dir, { recursive: true });
+		this.watchFile(listener);
+		return () => this.watcher?.close();
+	}
+	watchFile(listener) {
+		let timer;
+		const name = basename(this.path);
+		this.watcher = watch(dirname(this.path), (_event, filename) => {
+			if (filename?.toString() !== name) return;
+			clearTimeout(timer);
+			timer = setTimeout(async () => {
+				try {
+					const content = await readFile(join(dirname(this.path), name), "utf8");
+					if (content === this.lastWritten) return;
+					this.lastWritten = content;
+					listener(JSON.parse(content));
+				} catch {}
+			}, 100);
+		});
+	}
+};
+//#endregion
+//#region src/main/services/store/SecretStore.ts
+/**
+* Secrets encrypted with the OS keychain (Electron safeStorage) and kept in
+* a JSON file. Values never travel to the renderer or the model.
+*/
+var SecretStore = class {
+	file;
+	constructor(path) {
+		this.file = new JsonFile(path);
+	}
+	async get(key) {
+		const encoded = (await this.file.read())?.[key];
+		if (!encoded) return void 0;
+		const buffer = Buffer.from(encoded, "base64");
+		return safeStorage.isEncryptionAvailable() ? safeStorage.decryptString(buffer) : buffer.toString("utf8");
+	}
+	async set(key, value) {
+		const data = await this.file.read() ?? {};
+		data[key] = (safeStorage.isEncryptionAvailable() ? safeStorage.encryptString(value) : Buffer.from(value, "utf8")).toString("base64");
+		await this.file.write(data);
+	}
+	async delete(key) {
+		const data = await this.file.read() ?? {};
+		delete data[key];
+		await this.file.write(data);
+	}
+	async keys(prefix) {
+		return Object.keys(await this.file.read() ?? {}).filter((key) => key.startsWith(prefix));
+	}
+};
+//#endregion
+//#region src/main/services/store/SettingsService.ts
+var defaultSettings = {
+	theme: "dark",
+	keybindings: [],
+	disabledExtensions: [],
+	agent: {}
+};
+var SettingsService = class {
+	file;
+	current = defaultSettings;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(path) {
+		mkdirSync(dirname(path), { recursive: true });
+		this.file = new JsonFile(path);
+	}
+	async load() {
+		this.current = {
+			...defaultSettings,
+			...await this.file.read()
+		};
+		this.file.onExternalChange((value) => {
+			this.current = {
+				...defaultSettings,
+				...value
+			};
+			this.notify();
+		});
+		return this.current;
+	}
+	get() {
+		return this.current;
+	}
+	async update(patch) {
+		this.current = {
+			...this.current,
+			...patch
+		};
+		await this.file.write(this.current);
+		this.notify();
+		return this.current;
+	}
+	onChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	notify() {
+		for (const listener of this.listeners) listener(this.current);
+	}
+};
+//#endregion
+//#region src/main/services/store/StorageService.ts
+/** Per-scope (usually per-extension) key/value storage, one JSON file each. */
+var StorageService = class {
+	files = /* @__PURE__ */ new Map();
+	constructor(dir) {
+		this.dir = dir;
+	}
+	async get(scope, key) {
+		return (await this.file(scope).read())?.[key];
+	}
+	async set(scope, key, value) {
+		const file = this.file(scope);
+		const data = await file.read() ?? {};
+		if (value === void 0) delete data[key];
+		else data[key] = value;
+		await file.write(data);
+	}
+	file(scope) {
+		const safe = scope.replace(/[^\w.-]/g, "_");
+		let file = this.files.get(safe);
+		if (!file) {
+			file = new JsonFile(join(this.dir, `${safe}.json`));
+			this.files.set(safe, file);
+		}
+		return file;
+	}
+};
+//#endregion
+//#region src/builtin-extensions/files/host.ts
+var MAX_ENTRIES = 1e4;
+/** Reads only the zip's central directory, so listing a huge archive stays cheap. */
+var listZip = (path) => new Promise((resolve, reject) => {
+	yauzl.open(path, {
+		lazyEntries: true,
+		autoClose: true
+	}, (error, zip) => {
+		if (error || !zip) {
+			reject(error ?? /* @__PURE__ */ new Error("Could not open archive"));
+			return;
+		}
+		const entries = [];
+		zip.on("entry", (entry) => {
+			entries.push({
+				name: entry.fileName,
+				size: entry.uncompressedSize,
+				compressedSize: entry.compressedSize,
+				isDirectory: entry.fileName.endsWith("/"),
+				modified: entry.getLastModDate().getTime()
+			});
+			if (entries.length >= MAX_ENTRIES) {
+				zip.close();
+				resolve({
+					entries,
+					truncated: true
+				});
+				return;
+			}
+			zip.readEntry();
+		});
+		zip.on("end", () => resolve({
+			entries,
+			truncated: false
+		}));
+		zip.on("error", reject);
+		zip.readEntry();
+	});
+});
+var createFilesHost = () => defineHostExtension({ activate(ctx) {
+	return [ctx.rpc.handle("listZip", (path) => listZip(path))];
+} });
+//#endregion
+//#region src/builtin-extensions/manifest.ts
+/** Built-in extensions. Their ui halves load in the renderer, host halves in main. */
+var BUILTIN_EXTENSIONS = [
+	{
+		id: "workbench",
+		displayName: "Workbench",
+		description: "Dock, palette and core commands"
+	},
+	{
+		id: "chat",
+		displayName: "Agent Chat",
+		description: "Talk to the pi agent"
+	},
+	{
+		id: "files",
+		displayName: "Files",
+		description: "Browse and preview files"
+	},
+	{
+		id: "terminal",
+		displayName: "Terminal",
+		description: "Shell sessions"
+	},
+	{
+		id: "extensions",
+		displayName: "Extensions",
+		description: "Manage extensions"
+	},
+	{
+		id: "settings",
+		displayName: "Settings",
+		description: "Theme, keybindings and agent setup"
+	}
+];
+//#endregion
+//#region src/main/services/pty/PtyHost.ts
+var spawnHelperChecked = false;
+/**
+* npm installs node-pty's prebuilt macOS/Linux `spawn-helper` without its
+* execute bit, which makes every spawn fail with "posix_spawnp failed".
+*/
+var ensureSpawnHelperExecutable = () => {
+	if (spawnHelperChecked || process.platform === "win32") return;
+	spawnHelperChecked = true;
+	try {
+		const root = dirname(createRequire(import.meta.url).resolve("node-pty/package.json"));
+		const candidates = [join(root, "build", "Release", "spawn-helper"), join(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper")];
+		for (const file of candidates) {
+			if (!existsSync(file)) continue;
+			try {
+				accessSync(file, constants.X_OK);
+			} catch {
+				chmodSync(file, 493);
+			}
+		}
+	} catch {}
+};
+var PtyHost = class {
+	ptys = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async spawn(options) {
+		ensureSpawnHelperExecutable();
+		const pty = await import("node-pty");
+		const shell = process.env.SHELL ?? (process.platform === "win32" ? "powershell.exe" : "/bin/zsh");
+		const id = randomUUID();
+		const instance = pty.spawn(shell, ["-l"], {
+			name: "xterm-256color",
+			cols: options.cols,
+			rows: options.rows,
+			cwd: options.cwd ?? homedir(),
+			env: {
+				...process.env,
+				...this.options.env,
+				TERM_PROGRAM: "nubase",
+				COLORTERM: "truecolor"
+			}
+		});
+		instance.onData((data) => this.options.onData(id, data));
+		instance.onExit(({ exitCode }) => {
+			this.ptys.delete(id);
+			this.options.onExit(id, exitCode);
+		});
+		this.ptys.set(id, instance);
+		return id;
+	}
+	write(id, data) {
+		this.ptys.get(id)?.write(data);
+	}
+	resize(id, cols, rows) {
+		if (cols > 0 && rows > 0) this.ptys.get(id)?.resize(cols, rows);
+	}
+	kill(id) {
+		this.ptys.get(id)?.kill();
+		this.ptys.delete(id);
+	}
+	dispose() {
+		for (const id of [...this.ptys.keys()]) this.kill(id);
+	}
+};
+//#endregion
+//#region src/builtin-extensions/terminal/host.ts
+/** Shells for the terminal widget. Uses only the public host API plus node-pty. */
+var createTerminalHost = (env) => defineHostExtension({ activate(ctx) {
+	const ptys = new PtyHost({
+		env,
+		onData: (id, data) => ctx.rpc.emit("data", {
+			id,
+			data
+		}),
+		onExit: (id, exitCode) => ctx.rpc.emit("exit", {
+			id,
+			exitCode
+		})
+	});
+	return [
+		ctx.rpc.handle("spawn", (options) => ptys.spawn(options)),
+		ctx.rpc.handle("write", (id, data) => ptys.write(id, data)),
+		ctx.rpc.handle("resize", (id, cols, rows) => ptys.resize(id, cols, rows)),
+		ctx.rpc.handle("kill", (id) => ptys.kill(id)),
+		{ dispose: () => ptys.dispose() }
+	];
+} });
+//#endregion
+//#region src/main/rpc/electronTransport.ts
+var handlers = /* @__PURE__ */ new Map();
+var installed = false;
+/** One IPC handler for every view; each message goes to its sender's server. */
+var installRouter = () => {
+	if (installed) return;
+	installed = true;
+	ipcMain.handle(INVOKE_CHANNEL, (event, method, args) => {
+		const handler = handlers.get(event.sender);
+		if (!handler) throw new Error("Rejected IPC from an unknown sender");
+		return handler(method, args);
+	});
+};
+var createElectronTransport = (contents) => {
+	installRouter();
+	contents.once("destroyed", () => handlers.delete(contents));
+	return {
+		onInvoke(handler) {
+			handlers.set(contents, handler);
+		},
+		send(event, payload) {
+			if (!contents.isDestroyed()) contents.send(EVENT_CHANNEL, event, payload);
+		}
+	};
+};
+//#endregion
+//#region src/main/rpc/HostServer.ts
+var HostServer = class {
+	handlers = {};
+	pending = /* @__PURE__ */ new Map();
+	transport;
+	constructor() {
+		this.handlers["renderer.respond"] = (requestId, result) => {
+			const request = this.pending.get(requestId);
+			if (!request) return;
+			this.pending.delete(requestId);
+			clearTimeout(request.timer);
+			if (result.ok) request.resolve(result.value);
+			else request.reject(new Error(result.error));
+		};
+	}
+	connect(transport) {
+		this.transport = transport;
+		transport.onInvoke(async (method, args) => {
+			const handler = this.handlers[method];
+			if (!handler) throw new Error(`Unknown host method: ${method}`);
+			return handler(...args);
+		});
+	}
+	handle(handlers) {
+		Object.assign(this.handlers, handlers);
+	}
+	emit(event, payload) {
+		this.transport?.send(event, payload);
+	}
+	/** Asks the UI to do something only it can do (layout, dialogs, commands). */
+	requestRenderer(method, ...args) {
+		if (!this.transport) return Promise.reject(/* @__PURE__ */ new Error("No UI is connected"));
+		const requestId = randomUUID();
+		const interactive = method.startsWith("dialogs.");
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`UI did not answer ${method} in time`));
+			}, interactive ? 10 * 6e4 : 15e3);
+			this.pending.set(requestId, {
+				resolve,
+				reject,
+				timer
+			});
+			this.emit("renderer.request", {
+				requestId,
+				method,
+				args
+			});
+		});
+	}
+};
+//#endregion
+//#region src/main/services/agent/harness/AgentHarness.ts
+/** Thrown when a call needs a runtime or session that is not up yet. */
+var HarnessNotReadyError = class extends Error {
+	constructor() {
+		super("The agent is still starting");
+	}
+};
+//#endregion
+//#region src/main/services/agent/Transcript.ts
+/**
+* Projects a harness's event stream into a serializable list of ChatMessages.
+* The host owns this so every UI (and a future remote UI) renders the same
+* thing, whichever harness runs the agent.
+*/
+var Transcript = class {
+	messages = [];
+	toolParts = /* @__PURE__ */ new Map();
+	counter = 0;
+	constructor(onMessageChanged) {
+		this.onMessageChanged = onMessageChanged;
+	}
+	get all() {
+		return this.messages;
+	}
+	reset(history) {
+		this.messages = [];
+		this.toolParts.clear();
+		for (const message of history) if (message.role === "toolResult") this.applyToolResult(message.toolCallId, message.output, message.isError, void 0, false);
+		else this.startMessage(message, false);
+	}
+	apply(event) {
+		switch (event.type) {
+			case "message_start":
+				if (event.message.role !== "toolResult") this.startMessage(event.message, true);
+				break;
+			case "message_update": {
+				const { message } = event;
+				if (message.role === "toolResult") break;
+				const current = this.messages.at(-1);
+				if (current && current.role === message.role) {
+					this.fillParts(current, message);
+					this.onMessageChanged(current);
+				}
+				break;
+			}
+			case "tool_start":
+				this.updateTool(event.toolCallId, (part) => {
+					part.status = "running";
+					part.args = event.args ?? part.args;
+				});
+				break;
+			case "tool_update":
+				this.updateTool(event.toolCallId, (part) => {
+					part.output = event.output ?? part.output;
+				});
+				break;
+			case "tool_end":
+				this.applyToolResult(event.toolCallId, event.output, event.isError, event.durationMs, true);
+				break;
+		}
+	}
+	startMessage(message, notify) {
+		const chat = {
+			id: `m${this.counter++}`,
+			role: message.role,
+			parts: [],
+			timestamp: message.timestamp ?? Date.now()
+		};
+		this.fillParts(chat, message);
+		this.messages.push(chat);
+		if (notify) this.onMessageChanged(chat);
+	}
+	fillParts(chat, message) {
+		chat.parts = message.content.map((item) => {
+			if (item.type !== "toolCall") return item;
+			const existing = this.toolParts.get(item.id);
+			if (existing) {
+				existing.part.args = item.arguments;
+				existing.message = chat;
+				return existing.part;
+			}
+			const part = {
+				type: "toolCall",
+				toolCallId: item.id,
+				toolName: item.name,
+				args: item.arguments,
+				status: "pending"
+			};
+			this.toolParts.set(item.id, {
+				part,
+				message: chat
+			});
+			return part;
+		});
+		if (message.error) chat.error = message.error;
+	}
+	applyToolResult(toolCallId, output, isError, durationMs, notify) {
+		const entry = this.toolParts.get(toolCallId);
+		if (!entry) return;
+		entry.part.status = isError ? "error" : "done";
+		entry.part.output = output ?? entry.part.output;
+		entry.part.durationMs = durationMs ?? entry.part.durationMs;
+		if (notify) this.onMessageChanged(entry.message);
+	}
+	updateTool(toolCallId, update) {
+		const entry = this.toolParts.get(toolCallId);
+		if (!entry) return;
+		update(entry.part);
+		this.onMessageChanged(entry.message);
+	}
+};
+//#endregion
+//#region src/main/services/agent/AgentHost.ts
+/**
+* Exposes an agent through a small, serializable API, whichever harness runs
+* it. Owns the state, the transcript and the tools Nubase extensions
+* contribute; the harness only drives the agent loop.
+*/
+var AgentHost = class {
+	harness;
+	transcript;
+	tools = /* @__PURE__ */ new Map();
+	toolsDirty = false;
+	sessionOpen = false;
+	state;
+	pendingMessages = /* @__PURE__ */ new Map();
+	flushTimer;
+	constructor(options) {
+		this.options = options;
+		this.state = {
+			status: "starting",
+			cwd: options.cwd
+		};
+		this.transcript = new Transcript((message) => this.queueMessage(message));
+		this.harness = options.createHarness((event) => this.handleHarnessEvent(event));
+	}
+	async start() {
+		try {
+			this.sessionOpened(await this.harness.start());
+			await this.applyPendingToolChanges();
+		} catch (error) {
+			this.setState({
+				status: "error",
+				error: errorMessage(error)
+			});
+		}
+	}
+	getState() {
+		return this.state;
+	}
+	getMessages() {
+		return this.transcript.all;
+	}
+	registerTool(owner, tool) {
+		const entry = {
+			owner,
+			tool
+		};
+		this.tools.set(tool.name, entry);
+		this.markToolsDirty();
+		return { dispose: () => {
+			if (this.tools.get(tool.name) !== entry) return;
+			this.tools.delete(tool.name);
+			this.markToolsDirty();
+		} };
+	}
+	async prompt(text, images) {
+		this.requireSession();
+		if (this.harness.isRunning()) {
+			await this.ready(() => this.harness.send(text, images, "followUp"));
+			return;
+		}
+		await this.applyPendingToolChanges();
+		this.harness.send(text, images, "start").catch((error) => {
+			this.options.onEvent({
+				type: "notification",
+				message: errorMessage(error),
+				level: "error"
+			});
+			this.setState({ status: "idle" });
+		});
+	}
+	async steer(text, images) {
+		this.requireSession();
+		if (this.harness.isRunning()) await this.ready(() => this.harness.send(text, images, "steer"));
+		else await this.prompt(text, images);
+	}
+	async abort() {
+		await this.harness.abort();
+	}
+	async newSession() {
+		await this.openSession({ kind: "new" });
+	}
+	async switchSession(path) {
+		await this.openSession({
+			kind: "open",
+			path
+		});
+	}
+	listSessions() {
+		return this.harness.listSessions();
+	}
+	listModels() {
+		return this.harness.listModels();
+	}
+	async setModel(provider, id) {
+		await this.ready(() => this.harness.setModel(provider, id));
+		this.syncState();
+	}
+	listProviders() {
+		return this.harness.listProviders();
+	}
+	async login(providerId, method) {
+		await this.ready(() => this.harness.login(providerId, method));
+		if (!this.sessionOpen) await this.start();
+		this.syncState();
+	}
+	async logout(providerId) {
+		await this.harness.logout(providerId);
+		this.syncState();
+	}
+	dispose() {
+		this.harness.dispose();
+	}
+	handleHarnessEvent(event) {
+		this.transcript.apply(event);
+		switch (event.type) {
+			case "run_start":
+				this.setState({ status: "running" });
+				break;
+			case "run_settled":
+				this.setState({ status: "idle" });
+				this.applyPendingToolChanges();
+				break;
+			case "notice":
+				this.options.onEvent({
+					type: "notification",
+					message: event.message,
+					level: event.level
+				});
+				break;
+		}
+	}
+	async openSession(ref) {
+		this.sessionOpened(await this.harness.openSession(ref));
+		await this.applyPendingToolChanges();
+	}
+	sessionOpened(history) {
+		this.sessionOpen = true;
+		this.transcript.reset(history);
+		this.options.onEvent({
+			type: "messages",
+			messages: this.transcript.all
+		});
+		this.syncState("idle");
+	}
+	markToolsDirty() {
+		this.toolsDirty = true;
+		if (this.sessionOpen && !this.harness.isRunning()) this.applyPendingToolChanges();
+	}
+	/** Changing tools mid-run would disturb the agent, so changes wait for idle. */
+	async applyPendingToolChanges() {
+		if (!this.toolsDirty || !this.sessionOpen || this.harness.isRunning()) return;
+		this.toolsDirty = false;
+		try {
+			await this.harness.setTools([...this.tools.values()].map((t) => t.tool));
+		} catch (error) {
+			this.options.onEvent({
+				type: "notification",
+				message: `Reloading agent tools failed: ${errorMessage(error)}`,
+				level: "error"
+			});
+		}
+	}
+	syncState(status) {
+		const info = this.harness.describe();
+		this.setState({
+			status: status ?? this.state.status,
+			sessionId: info.sessionId,
+			sessionFile: info.sessionFile,
+			thinkingLevel: info.thinkingLevel,
+			model: info.model,
+			error: void 0
+		});
+	}
+	setState(patch) {
+		this.state = {
+			...this.state,
+			...patch
+		};
+		this.options.onEvent({
+			type: "state",
+			state: this.state
+		});
+	}
+	queueMessage(message) {
+		this.pendingMessages.set(message.id, message);
+		if (this.flushTimer) return;
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = void 0;
+			for (const pending of this.pendingMessages.values()) this.options.onEvent({
+				type: "message",
+				message: structuredClone(pending)
+			});
+			this.pendingMessages.clear();
+		}, 33);
+	}
+	requireSession() {
+		if (!this.sessionOpen) throw this.notReady();
+	}
+	/** Reports "not ready" with the startup error, when there is one. */
+	async ready(call) {
+		try {
+			return await call();
+		} catch (error) {
+			if (error instanceof HarnessNotReadyError) throw this.notReady();
+			throw error;
+		}
+	}
+	notReady() {
+		return new Error(this.state.error ?? "The agent is still starting");
+	}
+};
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
+//#region src/main/services/agent/harness/pi/piEvents.ts
+var resultText = (result) => {
+	if (typeof result === "string") return result;
+	const content = result?.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return void 0;
+	return content.map((part) => part.type === "text" ? part.text ?? "" : "[image]").join("\n");
+};
+var toContent = (content) => (typeof content === "string" ? [{
+	type: "text",
+	text: content
+}] : content ?? []).flatMap((item) => {
+	switch (item.type) {
+		case "text": return [{
+			type: "text",
+			text: item.text
+		}];
+		case "thinking": return [{
+			type: "thinking",
+			text: item.thinking
+		}];
+		case "image": return [{
+			type: "image",
+			data: item.data,
+			mimeType: item.mimeType
+		}];
+		case "toolCall": return [{
+			type: "toolCall",
+			id: item.id,
+			name: item.name,
+			arguments: item.arguments
+		}];
+		default: return [];
+	}
+});
+/** Pi's custom roles (bash executions, compaction summaries, …) are not shown. */
+var toNeutralMessage = (message) => {
+	if (message.role === "toolResult") {
+		if (!message.toolCallId) return void 0;
+		return {
+			role: "toolResult",
+			toolCallId: message.toolCallId,
+			output: resultText(message),
+			isError: message.isError
+		};
+	}
+	if (message.role !== "user" && message.role !== "assistant") return void 0;
+	return {
+		role: message.role,
+		content: toContent(message.content),
+		timestamp: message.timestamp,
+		error: message.stopReason === "error" && message.errorMessage ? message.errorMessage : void 0
+	};
+};
+/** Translates one pi AgentSessionEvent; returns undefined for events the UI ignores. */
+var toHarnessEvent = (event) => {
+	switch (event.type) {
+		case "agent_start": return { type: "run_start" };
+		case "agent_settled": return { type: "run_settled" };
+		case "auto_retry_start": return {
+			type: "notice",
+			message: `Retrying (${event.attempt}/${event.maxAttempts}): ${event.errorMessage}`,
+			level: "warning"
+		};
+		case "message_start":
+		case "message_update":
+		case "message_end": {
+			const message = toNeutralMessage(event.message);
+			if (!message || message.role === "toolResult") return void 0;
+			return {
+				type: event.type === "message_start" ? "message_start" : "message_update",
+				message
+			};
+		}
+		case "tool_execution_start": return {
+			type: "tool_start",
+			toolCallId: event.toolCallId,
+			args: event.args
+		};
+		case "tool_execution_update": return {
+			type: "tool_update",
+			toolCallId: event.toolCallId,
+			output: resultText(event.partialResult)
+		};
+		case "tool_execution_end": return {
+			type: "tool_end",
+			toolCallId: event.toolCallId,
+			output: resultText(event.result),
+			isError: Boolean(event.isError),
+			durationMs: event.durationMs
+		};
+		default: return;
+	}
+};
+//#endregion
+//#region src/main/services/agent/harness/pi/PiHarness.ts
+/**
+* Runs the pi agent in-process. Tools contributed by Nubase are bridged into
+* pi through one inline pi extension that is re-run whenever they change.
+*/
+var PiHarness = class {
+	id = "pi";
+	capabilities = {
+		steer: true,
+		multiProvider: true,
+		accountLogin: true
+	};
+	session;
+	modelRuntime;
+	settingsManager;
+	resourceLoader;
+	unsubscribe;
+	tools = [];
+	constructor(options) {
+		this.options = options;
+		mkdirSync(options.agentDir, { recursive: true });
+	}
+	get sessionsDir() {
+		return join(this.options.agentDir, "sessions");
+	}
+	async start() {
+		const { agentDir, cwd } = this.options;
+		this.modelRuntime = await ModelRuntime.create({
+			authPath: join(agentDir, "auth.json"),
+			modelsPath: join(agentDir, "models.json")
+		});
+		this.settingsManager = SettingsManager.create(cwd, agentDir);
+		this.resourceLoader = new DefaultResourceLoader({
+			cwd,
+			agentDir,
+			settingsManager: this.settingsManager,
+			additionalSkillPaths: this.options.skillPaths,
+			extensionFactories: [{
+				name: "nubase",
+				factory: this.bridgeExtension
+			}],
+			appendSystemPrompt: [this.options.appendSystemPrompt]
+		});
+		await this.resourceLoader.reload();
+		return this.openSession({ kind: "recent" });
+	}
+	async openSession(ref) {
+		const { cwd } = this.options;
+		const sessionManager = ref.kind === "recent" ? SessionManager.continueRecent(cwd, this.sessionsDir) : ref.kind === "new" ? SessionManager.create(cwd, this.sessionsDir) : SessionManager.open(ref.path, this.sessionsDir);
+		return this.openWith(sessionManager);
+	}
+	async send(text, images, mode) {
+		const session = this.requireSession();
+		const imageContent = images?.length ? images.map((image) => ({
+			type: "image",
+			data: image.data,
+			mimeType: image.mimeType
+		})) : void 0;
+		await session.prompt(text, {
+			images: imageContent,
+			...mode === "start" ? {} : { streamingBehavior: mode }
+		});
+	}
+	async abort() {
+		await this.session?.abort();
+	}
+	isRunning() {
+		return Boolean(this.session?.isStreaming);
+	}
+	async setTools(tools) {
+		this.tools = tools;
+		await this.session?.reload();
+	}
+	describe() {
+		const session = this.session;
+		const model = this.hasUsableModel() ? session?.model : void 0;
+		return {
+			sessionId: session?.sessionId,
+			sessionFile: session?.sessionFile,
+			thinkingLevel: session?.thinkingLevel,
+			model: model ? {
+				provider: model.provider,
+				id: model.id,
+				name: model.name ?? model.id
+			} : void 0
+		};
+	}
+	async listSessions() {
+		return (await SessionManager.list(this.options.cwd, this.sessionsDir)).map((s) => ({
+			id: s.id,
+			path: s.path,
+			name: s.name,
+			firstMessage: s.firstMessage,
+			modified: s.modified.getTime(),
+			messageCount: s.messageCount
+		})).sort((a, b) => b.modified - a.modified);
+	}
+	async listModels() {
+		if (!this.modelRuntime) return [];
+		return (await this.modelRuntime.getAvailable()).map((m) => ({
+			provider: m.provider,
+			id: m.id,
+			name: m.name ?? m.id
+		}));
+	}
+	async setModel(provider, id) {
+		const model = this.modelRuntime?.getModel(provider, id);
+		if (!model) throw new Error(`Unknown model ${provider}/${id}`);
+		await this.requireSession().setModel(model);
+	}
+	/** Providers the user can connect, with how they sign in and whether they are ready. */
+	listProviders() {
+		const runtime = this.modelRuntime;
+		if (!runtime) return [];
+		return runtime.getProviders().map((provider) => {
+			const status = runtime.getProviderAuthStatus(provider.id);
+			return {
+				id: provider.id,
+				name: provider.name,
+				configured: status.configured,
+				source: status.source,
+				accountLogin: provider.auth.oauth ? {
+					name: provider.auth.oauth.name,
+					subscription: Boolean(provider.auth.oauth.isSubscription)
+				} : void 0,
+				apiKeyLogin: Boolean(provider.auth.apiKey?.login)
+			};
+		}).filter((p) => p.accountLogin || p.apiKeyLogin || p.configured).sort((a, b) => a.name.localeCompare(b.name));
+	}
+	/** Runs pi's own sign-in flow for a provider, with Nubase dialogs as the UI. */
+	async login(providerId, method) {
+		const runtime = this.modelRuntime;
+		if (!runtime) throw new HarnessNotReadyError();
+		await runtime.login(providerId, method === "account" ? "oauth" : "api_key", this.createLoginInteraction());
+		await runtime.refresh({ providers: [providerId] }).catch(() => void 0);
+		await this.ensureUsableModel();
+	}
+	async logout(providerId) {
+		await this.modelRuntime?.logout(providerId);
+	}
+	dispose() {
+		this.unsubscribe?.();
+		this.session?.dispose();
+	}
+	async openWith(sessionManager) {
+		if (!this.modelRuntime || !this.resourceLoader || !this.settingsManager) throw new Error("Agent is not initialized");
+		this.unsubscribe?.();
+		this.session?.dispose();
+		const preferred = this.options.model ? this.modelRuntime.getModel(this.options.model.provider, this.options.model.id) : void 0;
+		const { session } = await createAgentSession({
+			cwd: this.options.cwd,
+			agentDir: this.options.agentDir,
+			modelRuntime: this.modelRuntime,
+			resourceLoader: this.resourceLoader,
+			settingsManager: this.settingsManager,
+			sessionManager,
+			...preferred ? { model: preferred } : {}
+		});
+		this.session = session;
+		await session.bindExtensions({
+			mode: "rpc",
+			uiContext: this.createUiContext()
+		});
+		this.unsubscribe = session.subscribe((event) => {
+			const translated = toHarnessEvent(event);
+			if (translated) this.options.emit(translated);
+		});
+		await this.ensureUsableModel();
+		return session.messages.flatMap((message) => {
+			const neutral = toNeutralMessage(message);
+			return neutral ? [neutral] : [];
+		});
+	}
+	bridgeExtension = (pi) => {
+		for (const tool of this.tools) pi.registerTool({
+			name: tool.name,
+			label: tool.label ?? tool.name,
+			description: tool.description,
+			parameters: tool.parameters,
+			execute: async (_toolCallId, params, signal, onUpdate) => {
+				const raw = await tool.execute(params, {
+					signal,
+					update: (text) => onUpdate?.({
+						content: [{
+							type: "text",
+							text
+						}],
+						details: void 0
+					})
+				});
+				const result = typeof raw === "string" ? { text: raw } : raw;
+				if (result.isError) throw new Error(result.text);
+				return {
+					content: [{
+						type: "text",
+						text: result.text
+					}, ...(result.images ?? []).map((image) => ({
+						type: "image",
+						data: image.data,
+						mimeType: image.mimeType
+					}))],
+					details: result.details ?? {}
+				};
+			}
+		});
+	};
+	createLoginInteraction() {
+		const { dialogs } = this.options;
+		const cancelled = () => /* @__PURE__ */ new Error("Login cancelled");
+		return {
+			prompt: async (prompt) => {
+				if (prompt.type === "select") {
+					const labels = prompt.options.map((o) => o.description ? `${o.label} — ${o.description}` : o.label);
+					const choice = await dialogs.select(prompt.message, labels);
+					const option = prompt.options[labels.indexOf(choice ?? "")];
+					if (!option) throw cancelled();
+					return option.id;
+				}
+				const value = await dialogs.input(prompt.message, {
+					placeholder: prompt.placeholder,
+					secret: prompt.type === "secret",
+					signal: prompt.signal
+				});
+				if (value === void 0) throw cancelled();
+				return value;
+			},
+			notify: (event) => {
+				switch (event.type) {
+					case "auth_url":
+						dialogs.openExternal(event.url);
+						dialogs.notify(event.instructions ?? "Continue signing in in your browser.", "info");
+						break;
+					case "device_code":
+						dialogs.openExternal(event.verificationUri);
+						dialogs.confirm(`Enter this code in your browser: ${event.userCode}`, `If the page did not open, go to ${event.verificationUri}`);
+						break;
+					case "info":
+					case "progress":
+						dialogs.notify(event.message, "info");
+						break;
+				}
+			}
+		};
+	}
+	/** pi extension UI requests, answered with Nubase dialogs. */
+	createUiContext() {
+		const { dialogs } = this.options;
+		return new Proxy({
+			select: (title, options) => dialogs.select(title, options),
+			confirm: (title, message) => dialogs.confirm(title, message),
+			input: (title, placeholder) => dialogs.input(title, { placeholder }),
+			notify: (message, type) => dialogs.notify(message, type === "error" ? "error" : "info"),
+			editor: (title, prefill) => dialogs.input(title, { placeholder: prefill })
+		}, { get: (target, prop) => prop in target ? target[prop] : () => prop === "onTerminalInput" ? () => {} : void 0 });
+	}
+	/** pi defaults to a model even without credentials; prefer one that can actually run. */
+	async ensureUsableModel() {
+		const session = this.session;
+		const runtime = this.modelRuntime;
+		if (!session || !runtime) return;
+		const current = session.model;
+		if (current && runtime.hasConfiguredAuth(current.provider)) return;
+		const fallback = (await runtime.getAvailable().catch(() => []))[0];
+		if (fallback) await session.setModel(fallback);
+	}
+	hasUsableModel() {
+		const model = this.session?.model;
+		return Boolean(model && this.modelRuntime?.hasConfiguredAuth(model.provider));
+	}
+	requireSession() {
+		if (!this.session) throw new HarnessNotReadyError();
+		return this.session;
+	}
+};
+//#endregion
+//#region src/main/services/agent/nubaseTools.ts
+var formatDiagnostics = (diagnostics) => diagnostics.map((d) => {
+	const where = d.file ? `${d.file}${d.line ? `:${d.line}:${d.column ?? 1}` : ""} ` : "";
+	return `- [${d.source}] ${where}${d.message}`;
+}).join("\n");
+var describe = (info) => `${info.id} (${info.displayName}) — ${info.status}${info.builtin ? ", built-in" : `, ${info.source}, ${info.path}`}`;
+var object = (properties, required = []) => ({
+	type: "object",
+	properties,
+	required,
+	additionalProperties: false
+});
+/**
+* Tools that let the agent change Nubase itself: create and build
+* extensions, arrange the dock, run UI commands, and look at the result.
+*/
+var createNubaseTools = (deps) => {
+	const { server, extensions } = deps;
+	const buildAndLoad = async (id) => {
+		const info = await extensions.rebuild(id);
+		if (info.status !== "active") return [
+			`Build of "${id}" FAILED (${info.status}). The previous working version (if any) is still loaded.`,
+			formatDiagnostics(info.diagnostics),
+			"Fix these errors and call nubase_build_extension again."
+		].join("\n");
+		const lines = [`Built "${id}" successfully (build ${info.buildId}).`];
+		if (info.buildId && info.uiBundleUrl) {
+			const loaded = await server.requestRenderer("extensions.ensureLoaded", id, info.buildId);
+			if (!loaded.ok) {
+				lines.push(`But loading it in the UI failed:\n${loaded.error}`);
+				return lines.join("\n");
+			}
+			lines.push(`Loaded in the UI. Widgets: ${loaded.widgets.join(", ") || "(none)"}. Commands: ${loaded.commands.join(", ") || "(none)"}.`);
+		}
+		return lines.join("\n");
+	};
+	return [
+		{
+			name: "nubase_list_extensions",
+			label: "List extensions",
+			description: "Lists Nubase extensions (built-in, global and folder-specific) with their status. User extensions are plain folders you can edit with the regular file tools. A folder extension with the same id as a global one replaces it in this folder.",
+			parameters: object({}),
+			execute: () => [
+				`Global extensions folder: ${deps.globalExtensionsDir}`,
+				deps.folderExtensionsDir ? `This folder's extensions folder: ${deps.folderExtensionsDir}` : "This is the ~ tab: only global extensions apply.",
+				...extensions.list().map((info) => describe(info) + (info.diagnostics.length ? `\n${formatDiagnostics(info.diagnostics)}` : ""))
+			].join("\n")
+		},
+		{
+			name: "nubase_create_extension",
+			label: "Create extension",
+			description: "Scaffolds a new Nubase extension (a TypeScript project with a widget) and builds it. By default it is global (available in every folder). Use scope \"folder\" only when the user asks for something specific to the current folder/project. Read the nubase-extension-authoring skill before editing it. Use withHost when the extension needs Node access: secrets, HTTP calls without CORS, or agent tools.",
+			parameters: object({
+				id: {
+					type: "string",
+					description: "lowercase kebab-case, e.g. jira-tickets"
+				},
+				displayName: { type: "string" },
+				description: { type: "string" },
+				withHost: {
+					type: "boolean",
+					description: "Also create src/host.ts (Node side)."
+				},
+				scope: {
+					type: "string",
+					enum: ["global", "folder"],
+					description: "global (default): ~/.nubase/extensions. folder: <folder>/.nubase/extensions, only for this folder."
+				}
+			}, ["id", "displayName"]),
+			execute: async (params) => {
+				const { scope = "global", ...options } = params;
+				if (scope === "folder" && !deps.folderExtensionsDir) return {
+					text: "The ~ tab has no folder of its own; use scope \"global\".",
+					isError: true
+				};
+				const path = await scaffoldExtension(scope === "folder" ? await deps.ensureFolderExtensions() : deps.globalExtensionsDir, deps.templateDir, {
+					...options,
+					withHost: options.withHost ?? false
+				});
+				const result = await buildAndLoad(params.id);
+				return [
+					`Created ${path}`,
+					`Files: package.json, tsconfig.json, src/ui.tsx${params.withHost ? ", src/host.ts" : ""}`,
+					`The starter widget id is "${params.id}.main". Edit the files, then call nubase_build_extension.`,
+					result
+				].join("\n");
+			}
+		},
+		{
+			name: "nubase_build_extension",
+			label: "Build extension",
+			description: "Builds an extension (bundle + typecheck + styles) and hot-reloads it in the running UI. Returns errors to fix, or the widgets and commands it registered. Saving files also triggers a rebuild, but call this to get the result.",
+			parameters: object({ id: { type: "string" } }, ["id"]),
+			execute: async ({ id }) => buildAndLoad(id)
+		},
+		{
+			name: "nubase_revert_extension",
+			label: "Revert extension",
+			description: "Undoes the latest change to an extension and reloads it: discards unsaved edits, or (if none) steps back one successful build. Call repeatedly to go further back. Every successful build is committed to git.",
+			parameters: object({ id: { type: "string" } }, ["id"]),
+			execute: async ({ id }) => `Reverted "${id}" to: ${await extensions.revert(id)}`
+		},
+		{
+			name: "nubase_extension_logs",
+			label: "Extension logs",
+			description: "Returns recent runtime errors and logs from extensions (render errors caught by widget error boundaries, console errors, host-side logs).",
+			parameters: object({ id: {
+				type: "string",
+				description: "Omit for all extensions."
+			} }),
+			execute: ({ id }) => {
+				const logs = extensions.getLogs(id).slice(-40);
+				if (logs.length === 0) return "No logs.";
+				return logs.map((l) => `${new Date(l.timestamp).toISOString()} [${l.level}] ${l.extensionId ?? "?"}${l.blockId ? ` block=${l.blockId}` : ""}: ${l.message}${l.stack ? `\n${l.stack.split("\n").slice(0, 6).join("\n")}` : ""}`).join("\n");
+			}
+		},
+		{
+			name: "nubase_get_layout",
+			label: "Get layout",
+			description: "Returns the dock layout (tabs, splits and blocks with their widget ids) and the widgets that can be opened.",
+			parameters: object({}),
+			execute: async () => {
+				const [layout, widgets] = await Promise.all([server.requestRenderer("layout.get"), server.requestRenderer("widgets.list")]);
+				return [
+					"Layout:",
+					JSON.stringify(layout, null, 2),
+					"Available widgets:",
+					...widgets.map((w) => `- ${w.id}: ${w.title}${w.description ? ` — ${w.description}` : ""} (${w.extensionId})`)
+				].join("\n");
+			}
+		},
+		{
+			name: "nubase_open_widget",
+			label: "Open widget",
+			description: "Opens a widget in a new dock block next to the focused one (or relative to a given block). Returns the block id.",
+			parameters: object({
+				widgetId: { type: "string" },
+				placement: {
+					type: "string",
+					enum: [
+						"right",
+						"below",
+						"left",
+						"above",
+						"replace"
+					]
+				},
+				relativeTo: {
+					type: "string",
+					description: "Block id; defaults to the focused block."
+				},
+				state: { description: "Initial widget state." }
+			}, ["widgetId"]),
+			execute: async (params) => {
+				const blockId = await server.requestRenderer("layout.openWidget", params.widgetId, params);
+				return `Opened ${params.widgetId} in block ${blockId}.`;
+			}
+		},
+		{
+			name: "nubase_close_block",
+			label: "Close block",
+			description: "Closes a dock block by id.",
+			parameters: object({ blockId: { type: "string" } }, ["blockId"]),
+			execute: async ({ blockId }) => {
+				await server.requestRenderer("layout.closeBlock", blockId);
+				return `Closed ${blockId}.`;
+			}
+		},
+		{
+			name: "nubase_list_commands",
+			label: "List commands",
+			description: "Lists UI commands (the same ones in the command palette).",
+			parameters: object({}),
+			execute: async () => (await server.requestRenderer("commands.list")).map((c) => `- ${c.id}: ${c.category ? `${c.category}: ` : ""}${c.title}`).join("\n")
+		},
+		{
+			name: "nubase_run_command",
+			label: "Run command",
+			description: "Runs a UI command by id, with optional arguments.",
+			parameters: object({
+				id: { type: "string" },
+				args: {}
+			}, ["id"]),
+			execute: async ({ id, args }) => {
+				const result = await server.requestRenderer("commands.execute", id, args);
+				return result === void 0 ? `Ran ${id}.` : JSON.stringify(result);
+			}
+		},
+		{
+			name: "nubase_screenshot",
+			label: "Screenshot",
+			description: "Takes a screenshot of one dock block (or the whole window) so you can check what a widget looks like. Use after building a widget.",
+			parameters: object({ blockId: {
+				type: "string",
+				description: "Omit for the whole window."
+			} }),
+			execute: async ({ blockId }) => {
+				const contents = deps.getWebContents();
+				if (!contents) return {
+					text: "No window is open.",
+					isError: true
+				};
+				const bounds = blockId ? await server.requestRenderer("block.bounds", blockId) : void 0;
+				if (blockId && !bounds) return {
+					text: `No block ${blockId}.`,
+					isError: true
+				};
+				let image = await contents.capturePage(bounds ? {
+					x: Math.round(bounds.x),
+					y: Math.round(bounds.y),
+					width: Math.round(bounds.width),
+					height: Math.round(bounds.height)
+				} : void 0);
+				if (image.getSize().width > 1400) image = image.resize({ width: 1400 });
+				return {
+					text: `Screenshot of ${blockId ? `block ${blockId}` : "the window"}.`,
+					images: [{
+						data: image.toPNG().toString("base64"),
+						mimeType: "image/png"
+					}]
+				};
+			}
+		}
+	];
+};
+//#endregion
+//#region src/main/services/agent/systemPrompt.ts
+var folderSection = (options) => options.isHome || !options.folderNubaseDir ? `
+You are in the ~ tab (the user's home folder). It is configured only by
+${options.nubaseHome}.` : `
+You are in the tab for the folder ${options.folder}. Its configuration is
+${options.nubaseHome} with ${options.folderNubaseDir} layered on top:
+- ${options.folderNubaseDir}/settings.json overrides keys of
+  ${options.nubaseHome}/settings.json for this folder only (e.g. a different
+  theme). Edit the root file for changes meant for every folder.
+- ${options.folderNubaseDir}/extensions/<id> replaces the global extension with
+  the same id, in this folder only.
+New extensions are global unless the user asks for one specific to this
+folder or project (then pass scope "folder" to nubase_create_extension).`;
+var nubaseSystemPrompt = (options) => `
+# Nubase
+
+You are running inside Nubase, a desktop AI harness whose UI you can change.
+Each top-level tab is a folder; this conversation belongs to one of them.
+The UI is a dock of blocks; every block shows a widget. Widgets, commands,
+keybindings and themes come from extensions: TypeScript projects in
+${options.globalExtensionsDir} (global) or in a folder's .nubase/extensions.
+Built-in widgets (chat, files, terminal, extensions, settings) use the same
+public API you do.
+${folderSection(options)}
+
+When the user asks for new UI — a widget, a dashboard, an integration with a
+service — build it as an extension:
+
+1. Read the nubase-extension-authoring skill before writing extension code.
+2. Use nubase_create_extension (or edit an existing extension).
+3. Edit the files with your file tools. Never edit dist/ or tsconfig.base.json.
+4. Call nubase_build_extension and fix every reported error until it builds.
+5. Open the widget with nubase_open_widget, then check it with nubase_screenshot.
+6. If something renders wrong, read nubase_extension_logs and iterate.
+
+Secrets (API tokens) belong in the extension's host half: call
+ctx.secrets.prompt(...) there. Never ask the user to paste secrets into chat.
+Every successful build is committed to git; nubase_revert_extension restores
+the last version that built.
+`;
+//#endregion
+//#region src/main/services/extensions/ExtensionHost.ts
+globalThis[HOST_MODULES_GLOBAL] = {
+	"@nubase/sdk/host": sdkHost,
+	"@nubase/sdk": sdkHost
+};
+var Scope = class {
+	items = [];
+	add(d) {
+		this.items.push(d);
+		return d;
+	}
+	dispose() {
+		for (const d of this.items.splice(0).reverse()) try {
+			d.dispose();
+		} catch (error) {
+			console.error("Error disposing extension resource", error);
+		}
+	}
+};
+var MAX_LOGS = 200;
+/**
+* The extensions one folder tab runs. Builds come from the sources (shared
+* between tabs); this activates the winning version of each id — the
+* folder's own over the global one — into this tab's agent and UI.
+*/
+var ExtensionHost = class {
+	records = /* @__PURE__ */ new Map();
+	sources;
+	logs = [];
+	unsubscribe = [];
+	syncing = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+		this.sources = [...deps.sources];
+	}
+	async start() {
+		for (const builtin of this.deps.builtins) {
+			const record = {
+				builtin,
+				rpc: /* @__PURE__ */ new Map(),
+				info: {
+					id: builtin.id,
+					displayName: builtin.displayName,
+					description: builtin.description,
+					path: "",
+					builtin: true,
+					source: "builtin",
+					status: "active",
+					diagnostics: []
+				}
+			};
+			this.records.set(builtin.id, record);
+			if (builtin.host) await this.activateHost(record, builtin.host);
+		}
+		if (!this.deps.safeMode) {
+			for (const source of this.sources) this.subscribe(source);
+			await Promise.all(this.sources.map((source) => source.start()));
+			await this.syncAll();
+		}
+		this.changed();
+	}
+	/** Adds the folder's own extensions once its `.nubase/extensions` exists. Takes precedence over the others. */
+	async addSource(source) {
+		if (this.sources.includes(source)) return;
+		this.sources.unshift(source);
+		if (this.deps.safeMode) return;
+		this.subscribe(source);
+		await source.start();
+		await this.syncAll();
+	}
+	list() {
+		return [...this.records.values()].map((r) => r.info);
+	}
+	get(id) {
+		return this.records.get(id)?.info;
+	}
+	/** The source an id resolves to (highest precedence that has it). */
+	sourceOf(id) {
+		return this.sources.find((source) => source.contains(id));
+	}
+	pathOf(id) {
+		const source = this.sourceOf(id);
+		if (!source) throw new Error(`No extension "${id}"`);
+		return source.pathOf(id);
+	}
+	/** Builds (or rebuilds) an extension and hot-reloads it if the build succeeds. */
+	async rebuild(id) {
+		const record = this.records.get(id);
+		if (record?.builtin) return record.info;
+		const source = this.sourceOf(id);
+		if (!source) throw new Error(`No extension "${id}" in ${this.sources.map((s) => s.dir).join(" or ")}`);
+		await source.rebuild(id);
+		await this.sync(id);
+		const info = this.records.get(id)?.info;
+		if (!info) throw new Error(`Extension "${id}" disappeared`);
+		return info;
+	}
+	async revert(id) {
+		const source = this.sourceOf(id);
+		if (!source) throw new Error(`No extension "${id}"`);
+		const commit = await source.revert(id);
+		await this.sync(id);
+		return commit;
+	}
+	async setEnabled(id) {
+		await this.sync(id);
+	}
+	/** Re-applies settings such as `disabledExtensions` to every extension. */
+	async refresh() {
+		await this.syncAll();
+	}
+	async call(id, method, args) {
+		const handler = this.records.get(id)?.rpc.get(method);
+		if (!handler) throw new Error(`Extension "${id}" has no host method "${method}"`);
+		return handler(...args);
+	}
+	reportLog(entry) {
+		this.logs.push(entry);
+		if (this.logs.length > MAX_LOGS) this.logs.splice(0, this.logs.length - MAX_LOGS);
+	}
+	getLogs(id, since) {
+		return this.logs.filter((l) => (!id || l.extensionId === id) && (!since || l.timestamp >= since));
+	}
+	dispose() {
+		for (const unsubscribe of this.unsubscribe.splice(0)) unsubscribe();
+		for (const record of this.records.values()) record.hostScope?.dispose();
+	}
+	subscribe(source) {
+		this.unsubscribe.push(source.onChanged((id) => this.sync(id)));
+	}
+	async syncAll() {
+		const ids = new Set(this.sources.flatMap((source) => source.ids()));
+		for (const record of this.records.values()) if (!record.builtin) ids.add(record.info.id);
+		await Promise.all([...ids].map((id) => this.sync(id)));
+	}
+	/** Serializes work per id: activation is async and sources notify often. */
+	sync(id) {
+		const next = (this.syncing.get(id) ?? Promise.resolve()).then(() => this.doSync(id));
+		const tracked = next.finally(() => {
+			if (this.syncing.get(id) === tracked) this.syncing.delete(id);
+		});
+		this.syncing.set(id, tracked);
+		return next;
+	}
+	async doSync(id) {
+		const existing = this.records.get(id);
+		if (existing?.builtin) return;
+		const source = this.sources.find((s) => s.get(id));
+		const entry = source?.get(id);
+		if (!source || !entry) {
+			if (existing) {
+				existing.hostScope?.dispose();
+				this.records.delete(id);
+				this.changed();
+			}
+			return;
+		}
+		const record = existing ?? {
+			rpc: /* @__PURE__ */ new Map(),
+			info: source.toInfo(entry)
+		};
+		this.records.set(id, record);
+		if (record.source !== source) {
+			this.deactivateHost(record);
+			record.source = source;
+		}
+		const info = source.toInfo(entry);
+		if (this.deps.isDisabled(id)) {
+			this.deactivateHost(record);
+			record.info = {
+				...info,
+				status: "disabled",
+				uiBundleUrl: void 0,
+				uiStylesUrl: void 0
+			};
+			this.changed();
+			return;
+		}
+		if (entry.status !== "active" || !entry.buildId) {
+			record.info = info;
+			this.changed();
+			return;
+		}
+		if (!entry.hasHost) this.deactivateHost(record);
+		else if (record.activeBuildId !== entry.buildId || !record.hostScope) {
+			this.deactivateHost(record);
+			try {
+				await this.activateHost(record, source.loadHost(id));
+			} catch (error) {
+				record.info = {
+					...info,
+					status: "activation-failed",
+					diagnostics: [{
+						source: "activation",
+						message: errorText(error)
+					}]
+				};
+				this.changed();
+				return;
+			}
+		}
+		record.activeBuildId = entry.buildId;
+		record.info = info;
+		this.changed();
+	}
+	deactivateHost(record) {
+		record.hostScope?.dispose();
+		record.hostScope = void 0;
+		record.activeBuildId = void 0;
+		record.rpc.clear();
+	}
+	async activateHost(record, extension) {
+		const scope = new Scope();
+		const id = record.info.id;
+		const log = (level) => (...args) => {
+			const message = args.map((a) => typeof a === "string" ? a : safeJson(a)).join(" ");
+			this.reportLog({
+				extensionId: id,
+				level,
+				message,
+				timestamp: Date.now()
+			});
+			console[level === "info" ? "log" : level](`[${id}]`, ...args);
+		};
+		const ctx = {
+			extension: {
+				id,
+				displayName: record.info.displayName,
+				path: record.info.path
+			},
+			workspace: this.deps.workspace,
+			agent: { registerTool: (tool) => scope.add(this.deps.agent.registerTool(id, tool)) },
+			rpc: {
+				handle: (method, handler) => {
+					record.rpc.set(method, handler);
+					return scope.add({ dispose: () => {
+						if (record.rpc.get(method) === handler) record.rpc.delete(method);
+					} });
+				},
+				emit: (event, payload) => this.deps.onEvent(id, event, payload)
+			},
+			secrets: {
+				get: (key) => this.deps.secrets.get(`ext.${id}.${key}`),
+				set: (key, value) => this.deps.secrets.set(`ext.${id}.${key}`, value),
+				delete: (key) => this.deps.secrets.delete(`ext.${id}.${key}`),
+				prompt: async (key, title) => {
+					const value = await this.deps.promptSecret(title);
+					if (value) await this.deps.secrets.set(`ext.${id}.${key}`, value);
+					return value;
+				}
+			},
+			storage: {
+				get: async (key) => await this.deps.storage.get(id, key),
+				set: (key, value) => this.deps.storage.set(id, key, value)
+			},
+			fs: this.deps.fs,
+			log: {
+				info: log("info"),
+				warn: log("warn"),
+				error: log("error")
+			}
+		};
+		const returned = await extension.activate(ctx);
+		for (const disposable of returned ?? []) scope.add(disposable);
+		record.hostScope = scope;
+	}
+	changed() {
+		this.deps.onChanged(this.list());
+	}
+};
+var errorText = (error) => error instanceof Error ? error.stack ?? error.message : String(error);
+var safeJson = (value) => {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+};
+//#endregion
+//#region src/main/services/store/LayeredSettings.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Folder settings win: objects merge key by key, keybindings add to the
+* root ones (registered later, so they take precedence), and any other
+* value — arrays included — replaces the root's.
+*/
+var mergeSettings = (root, folder) => {
+	const merge = (base, over) => {
+		const result = { ...base };
+		for (const [key, value] of Object.entries(over)) {
+			const current = result[key];
+			if (key === "keybindings" && Array.isArray(current)) result[key] = [...current, ...Array.isArray(value) ? value : []];
+			else if (isPlainObject(current) && isPlainObject(value)) result[key] = merge(current, value);
+			else if (value !== void 0) result[key] = value;
+		}
+		return result;
+	};
+	return merge(root, folder);
+};
+/** The settings one folder tab sees: `~/.nubase/settings.json` with the folder's `.nubase/settings.json` on top. */
+var LayeredSettings = class {
+	folder = {};
+	folderFile;
+	listeners = /* @__PURE__ */ new Set();
+	disposers = [];
+	constructor(root, folderSettingsPath) {
+		this.root = root;
+		if (folderSettingsPath) this.folderFile = new JsonFile(folderSettingsPath);
+	}
+	async load() {
+		this.disposers.push(this.root.onChange(() => this.notify()));
+		if (!this.folderFile) return;
+		this.folder = await this.folderFile.read() ?? {};
+		this.disposers.push(this.folderFile.onExternalChange((value) => {
+			this.folder = isPlainObject(value) ? value : {};
+			this.notify();
+		}, { createDir: false }));
+	}
+	get() {
+		return mergeSettings(this.root.get(), this.folder);
+	}
+	getFolderOverrides() {
+		return this.folder;
+	}
+	async update(patch, scope = "root") {
+		if (scope === "root") {
+			await this.root.update(patch);
+			return this.get();
+		}
+		if (!this.folderFile) throw new Error("The ~ tab has no folder settings; use the root scope");
+		this.folder = {
+			...this.folder,
+			...patch
+		};
+		await this.folderFile.write(this.folder);
+		this.notify();
+		return this.get();
+	}
+	onChange(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	dispose() {
+		for (const dispose of this.disposers.splice(0)) dispose();
+		this.listeners.clear();
+	}
+	notify() {
+		const value = this.get();
+		for (const listener of this.listeners) listener(value);
+	}
+};
+//#endregion
+//#region src/main/services/workspaces/Workspace.ts
+/** Collapses a pre-folder-tabs layout (several tabs) into its active tab. */
+var migrateLegacyLayout = async (target) => {
+	if (existsSync(target.path) || !existsSync(paths.legacyLayout)) return;
+	const legacy = await new JsonFile(paths.legacyLayout).read();
+	const tab = legacy?.tabs?.find((t) => t.id === legacy.activeTabId) ?? legacy?.tabs?.[0];
+	if (!legacy || !tab) return;
+	await target.write({
+		...legacy,
+		tabs: [tab],
+		activeTabId: tab.id
+	});
+};
+/**
+* One folder tab: its own renderer (view), host server, merged settings,
+* agent (working in the folder) and extension host. Built-ins and global
+* extensions come from `~/.nubase`; the folder's `.nubase` overrides them.
+*/
+var Workspace = class {
+	view;
+	server = new HostServer();
+	settings;
+	agent;
+	extensions;
+	folderExtensions;
+	layoutFile;
+	fsWatches = /* @__PURE__ */ new Map();
+	watchCounter = 0;
+	disposers = [];
+	constructor(id, folder, shared, tabs) {
+		this.id = id;
+		this.folder = folder;
+		this.shared = shared;
+		this.tabs = tabs;
+		const isHome = this.info.isHome;
+		const local = isHome ? void 0 : folderPaths(folder);
+		const state = workspacePaths(id);
+		const layered = local && local.dir !== paths.home ? local : void 0;
+		this.settings = new LayeredSettings(shared.rootSettings, layered?.settings);
+		this.layoutFile = new JsonFile(state.layout);
+		this.view = new WebContentsView({ webPreferences: {
+			preload: shared.preloadPath,
+			contextIsolation: true,
+			nodeIntegration: false,
+			sandbox: true
+		} });
+		this.view.setBackgroundColor("#0a0a0a");
+		this.view.webContents.setWindowOpenHandler(({ url }) => {
+			shell.openExternal(url);
+			return { action: "deny" };
+		});
+		this.server.connect(createElectronTransport(this.view.webContents));
+		const rootSettings = shared.rootSettings.get();
+		const agentCwd = isHome ? rootSettings.agent.cwd ?? homedir() : folder;
+		this.agent = new AgentHost({
+			cwd: agentCwd,
+			createHarness: (emit) => new PiHarness({
+				agentDir: paths.agentDir,
+				cwd: agentCwd,
+				model: rootSettings.agent.model,
+				skillPaths: [join(shared.resourcesDir, "skills")],
+				appendSystemPrompt: nubaseSystemPrompt({
+					folder,
+					isHome,
+					nubaseHome: paths.home,
+					globalExtensionsDir: paths.extensions,
+					folderNubaseDir: layered?.dir
+				}),
+				dialogs: this.agentDialogs(),
+				emit
+			}),
+			onEvent: (event) => this.server.emit("agent.event", event)
+		});
+		if (layered && existsSync(layered.extensions)) this.folderExtensions = this.createFolderSource(layered.extensions);
+		this.extensions = new ExtensionHost({
+			workspace: this.info,
+			sources: [this.folderExtensions, shared.globalExtensions].filter((s) => Boolean(s)),
+			agent: this.agent,
+			fs: shared.fs,
+			secrets: shared.secrets,
+			storage: shared.storage,
+			safeMode: shared.safeMode,
+			builtins: BUILTIN_EXTENSIONS.map((b) => ({
+				...b,
+				host: b.id === "terminal" ? createTerminalHost({
+					PI_CODING_AGENT_DIR: paths.agentDir,
+					NUBASE_EXTENSIONS_DIR: paths.extensions,
+					NUBASE_FOLDER: folder
+				}) : b.id === "files" ? createFilesHost() : void 0
+			})),
+			isDisabled: (extensionId) => this.settings.get().disabledExtensions.includes(extensionId),
+			promptSecret: (title) => this.server.requestRenderer("dialogs.input", title, { secret: true }),
+			onChanged: (list) => this.server.emit("extensions.changed", list),
+			onEvent: (extensionId, event, payload) => this.server.emit("extensions.event", {
+				extensionId,
+				event,
+				payload
+			})
+		});
+		for (const tool of createNubaseTools({
+			server: this.server,
+			extensions: this.extensions,
+			globalExtensionsDir: paths.extensions,
+			folderExtensionsDir: layered?.extensions,
+			ensureFolderExtensions: async () => {
+				if (!layered) throw new Error("The ~ tab has no folder extensions");
+				await this.ensureFolderExtensions(layered.extensions);
+				return layered.extensions;
+			},
+			templateDir: join(shared.resourcesDir, "templates", "extension"),
+			getWebContents: () => this.view.webContents.isDestroyed() ? void 0 : this.view.webContents
+		})) this.agent.registerTool("nubase", tool);
+		this.registerHandlers(layered?.extensions);
+	}
+	get info() {
+		return this.tabs.info(this.id);
+	}
+	/** The folder's own extensions, if it has any; asset URLs use the workspace id as their key. */
+	get folderSource() {
+		return this.folderExtensions;
+	}
+	async start() {
+		if (this.info.isHome) await migrateLegacyLayout(this.layoutFile);
+		await this.settings.load();
+		this.disposers.push(this.settings.onChange((value) => {
+			this.server.emit("settings.changed", value);
+			this.extensions.refresh();
+		}), this.layoutFile.onExternalChange((layout) => this.server.emit("layout.changedOnDisk", layout)));
+		const { rendererUrl } = this.shared;
+		if ("url" in rendererUrl) this.view.webContents.loadURL(rendererUrl.url);
+		else this.view.webContents.loadFile(rendererUrl.file);
+		this.agent.start();
+		this.extensions.start().catch((error) => console.error(`Extensions failed to start for ${this.folder}`, error));
+	}
+	dispose() {
+		for (const dispose of this.disposers.splice(0)) dispose();
+		for (const watch of this.fsWatches.values()) watch.dispose();
+		this.fsWatches.clear();
+		this.extensions.dispose();
+		this.agent.dispose();
+		this.folderExtensions?.dispose();
+		this.settings.dispose();
+		if (!this.view.webContents.isDestroyed()) this.view.webContents.close();
+	}
+	createFolderSource(dir) {
+		return new ExtensionSource({
+			key: this.id,
+			kind: "folder",
+			dir,
+			builder: this.shared.builder,
+			repo: new ExtensionsRepo(dir, workspacePaths(this.id).extensionsGitDir)
+		});
+	}
+	async ensureFolderExtensions(dir) {
+		if (this.folderExtensions) return;
+		await prepareExtensionsWorkspace(dir, this.shared.resourcesDir, { inProject: true });
+		this.folderExtensions = this.createFolderSource(dir);
+		await this.extensions.addSource(this.folderExtensions);
+	}
+	agentDialogs() {
+		const server = this.server;
+		return {
+			confirm: (title, message) => server.requestRenderer("dialogs.confirm", title, message),
+			input: (title, options) => {
+				const { signal, ...inputOptions } = options ?? {};
+				if (signal?.aborted) return Promise.resolve(void 0);
+				const dialogId = randomUUID();
+				const cancel = () => {
+					server.requestRenderer("dialogs.cancelInput", dialogId).catch(() => {});
+				};
+				signal?.addEventListener("abort", cancel, { once: true });
+				return server.requestRenderer("dialogs.input", title, {
+					...inputOptions,
+					dialogId
+				}).finally(() => signal?.removeEventListener("abort", cancel));
+			},
+			select: (title, options) => server.requestRenderer("dialogs.select", title, options),
+			notify: (message, level) => void server.requestRenderer("notify", message, level).catch(() => {}),
+			openExternal: (url) => {
+				if (/^https?:\/\//.test(url)) shell.openExternal(url);
+			}
+		};
+	}
+	registerHandlers(folderExtensionsDir) {
+		const { fs, storage, safeMode } = this.shared;
+		const { server, settings, agent, extensions } = this;
+		server.handle({
+			"app.info": () => ({
+				version: this.shared.appVersion(),
+				platform: process.platform,
+				homeDir: fs.homeDir,
+				nubaseHome: paths.home,
+				extensionsDir: paths.extensions,
+				folderExtensionsDir,
+				safeMode,
+				workspace: this.info
+			}),
+			"app.openExternal": (url) => {
+				if (/^https?:\/\//.test(url)) shell.openExternal(url);
+			},
+			"app.reportLog": (entry) => extensions.reportLog(entry),
+			"fs.readText": (path) => fs.readText(path),
+			"fs.writeText": (path, content) => fs.writeText(path, content),
+			"fs.stat": (path) => fs.stat(path),
+			"fs.readDirectory": (path) => fs.readDirectory(path),
+			"fs.mkdir": (path) => fs.mkdir(path),
+			"fs.delete": (path, recursive) => fs.delete(path, { recursive }),
+			"fs.rename": (from, to) => fs.rename(from, to),
+			"fs.watch": (path, recursive) => {
+				const watchId = `w${this.watchCounter++}`;
+				this.fsWatches.set(watchId, fs.watch(path, (change) => server.emit("fs.change", {
+					watchId,
+					change
+				}), { recursive }));
+				return watchId;
+			},
+			"fs.unwatch": (watchId) => {
+				this.fsWatches.get(watchId)?.dispose();
+				this.fsWatches.delete(watchId);
+			},
+			"fs.thumbnail": async (path, size) => {
+				if (process.platform !== "darwin" && process.platform !== "win32") return;
+				try {
+					const image = await nativeImage.createThumbnailFromPath(path, {
+						width: size,
+						height: size
+					});
+					return image.isEmpty() ? void 0 : image.toDataURL();
+				} catch {
+					return;
+				}
+			},
+			"shell.openPath": async (path) => {
+				const error = await shell.openPath(path);
+				if (error) throw new Error(error);
+			},
+			"shell.showItemInFolder": (path) => shell.showItemInFolder(path),
+			"shell.quickLook": (path) => {
+				if (process.platform !== "darwin") return false;
+				const window = BaseWindow.getAllWindows().find((w) => w.contentView.children.includes(this.view));
+				if (!window) return false;
+				window.previewFile(path);
+				return true;
+			},
+			"settings.get": () => settings.get(),
+			"settings.update": (patch, scope) => settings.update(patch, scope),
+			"settings.getFolderOverrides": () => settings.getFolderOverrides(),
+			"layout.load": () => this.layoutFile.read(),
+			"layout.save": (layout) => this.layoutFile.write(layout),
+			"storage.get": (scope, key) => storage.get(scope, key),
+			"storage.set": (scope, key, value) => storage.set(scope, key, value),
+			"workspaces.list": () => this.tabs.list(),
+			"workspaces.open": (folder) => this.tabs.open(folder),
+			"workspaces.close": (id) => this.tabs.close(id),
+			"workspaces.activate": (id) => this.tabs.activate(id),
+			"agent.getState": () => agent.getState(),
+			"agent.getMessages": () => agent.getMessages(),
+			"agent.prompt": (text, images) => agent.prompt(text, images),
+			"agent.steer": (text, images) => agent.steer(text, images),
+			"agent.abort": () => agent.abort(),
+			"agent.newSession": () => agent.newSession(),
+			"agent.listSessions": () => agent.listSessions(),
+			"agent.switchSession": (path) => agent.switchSession(path),
+			"agent.listModels": () => agent.listModels(),
+			"agent.setModel": async (provider, id) => {
+				await agent.setModel(provider, id);
+				await settings.update({ agent: {
+					...this.shared.rootSettings.get().agent,
+					model: {
+						provider,
+						id
+					}
+				} });
+			},
+			"agent.listProviders": () => agent.listProviders(),
+			"agent.login": (providerId, method) => agent.login(providerId, method),
+			"agent.logout": (providerId) => agent.logout(providerId),
+			"extensions.list": () => extensions.list(),
+			"extensions.rebuild": (id) => extensions.rebuild(id),
+			"extensions.setEnabled": async (id, enabled) => {
+				const disabled = new Set(settings.get().disabledExtensions);
+				if (enabled) disabled.delete(id);
+				else disabled.add(id);
+				const scope = settings.getFolderOverrides().disabledExtensions !== void 0 ? "folder" : "root";
+				await settings.update({ disabledExtensions: [...disabled] }, scope);
+				await extensions.setEnabled(id);
+			},
+			"extensions.revert": (id) => extensions.revert(id),
+			"extensions.reveal": (id) => {
+				shell.showItemInFolder(join(extensions.pathOf(id), "package.json"));
+			},
+			"extensions.call": (extensionId, method, args) => extensions.call(extensionId, method, args)
+		});
+	}
+};
+//#endregion
+//#region src/main/services/workspaces/WorkspaceManager.ts
+var isDirectory = (path) => {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+};
+/**
+* The tab bar: which folders are open, which one is showing, and the
+* folder tabs (each a Workspace with its own renderer view) behind them.
+* `~` is always the first tab and cannot be closed.
+*/
+var WorkspaceManager = class {
+	folders = [];
+	activeId = HOME_WORKSPACE_ID;
+	workspaces = /* @__PURE__ */ new Map();
+	starting = /* @__PURE__ */ new Map();
+	window;
+	file = new JsonFile(paths.workspaces);
+	constructor(shared) {
+		this.shared = shared;
+	}
+	async restore() {
+		const stored = await this.file.read();
+		const home = homedir();
+		const seen = /* @__PURE__ */ new Set();
+		this.folders = (stored?.folders ?? []).map((folder) => resolve(folder)).filter((folder) => {
+			if (folder === home || seen.has(folder) || !isDirectory(folder)) return false;
+			seen.add(folder);
+			return true;
+		});
+		const activeId = stored?.activeId;
+		this.activeId = activeId && this.folderOf(activeId) ? activeId : HOME_WORKSPACE_ID;
+	}
+	/** Shows the folder tabs in a (new) window, starting with the active one. */
+	async attach(window) {
+		this.window = window;
+		window.on("resize", () => this.layoutViews());
+		window.on("closed", () => {
+			if (this.window === window) this.window = void 0;
+			for (const workspace of this.workspaces.values()) workspace.dispose();
+			this.workspaces.clear();
+		});
+		await this.activate(this.activeId);
+	}
+	list() {
+		return {
+			workspaces: this.ids().map((id) => this.info(id)),
+			activeId: this.activeId
+		};
+	}
+	info(id) {
+		const folder = this.folderOf(id);
+		if (!folder) throw new Error(`No open folder "${id}"`);
+		if (id === "home") return {
+			id,
+			folder,
+			title: "~",
+			isHome: true
+		};
+		const name = basename(folder) || folder;
+		return {
+			id,
+			folder,
+			title: this.folders.some((other) => other !== folder && basename(other) === name) ? `${basename(dirname(folder))}/${name}` : name,
+			isHome: false
+		};
+	}
+	async open(folder) {
+		let target = folder;
+		if (!target) {
+			const options = {
+				title: "Open Folder",
+				properties: ["openDirectory", "createDirectory"]
+			};
+			const result = this.window ? await dialog.showOpenDialog(this.window, options) : await dialog.showOpenDialog(options);
+			target = result.canceled ? void 0 : result.filePaths[0];
+			if (!target) return void 0;
+		}
+		target = resolve(target);
+		if (!isDirectory(target)) throw new Error(`Not a folder: ${target}`);
+		const id = workspaceIdOf(target);
+		if (id !== "home" && !this.folders.includes(target)) this.folders.push(target);
+		await this.activate(id);
+		return this.info(id);
+	}
+	async close(id) {
+		if (id === "home") throw new Error("The ~ tab cannot be closed");
+		const ids = this.ids();
+		const index = ids.indexOf(id);
+		if (index < 0) return;
+		const folder = this.folderOf(id);
+		this.folders = this.folders.filter((f) => f !== folder);
+		const workspace = this.workspaces.get(id);
+		this.workspaces.delete(id);
+		if (workspace) {
+			this.window?.contentView.removeChildView(workspace.view);
+			workspace.dispose();
+		}
+		if (this.activeId === id) await this.activate(ids[index - 1] ?? "home");
+		else {
+			await this.persist();
+			this.broadcast();
+		}
+	}
+	async activate(id) {
+		if (!this.folderOf(id)) throw new Error(`No open folder "${id}"`);
+		this.activeId = id;
+		await this.persist();
+		this.broadcast();
+		const window = this.window;
+		if (!window) return;
+		const workspace = await this.ensure(id);
+		if (this.activeId !== id || window.isDestroyed()) return;
+		for (const other of this.workspaces.values()) other.view.setVisible(other === workspace);
+		this.layoutViews();
+		workspace.view.webContents.focus();
+	}
+	/** Activates the tab `offset` places away from the current one, wrapping around. */
+	async activateRelative(offset) {
+		const ids = this.ids();
+		const next = ids[(ids.indexOf(this.activeId) + offset + ids.length) % ids.length];
+		if (next) await this.activate(next);
+	}
+	/** Resolves `nubase-ext://<key>/<id>/<file>`: `global`, or a workspace id for that folder's extensions. */
+	resolveAsset(url) {
+		const parsed = new URL(url);
+		if (parsed.protocol !== `nubase-ext:`) return void 0;
+		return (parsed.hostname === this.shared.globalExtensions.key ? this.shared.globalExtensions : this.workspaces.get(parsed.hostname)?.folderSource)?.resolveAsset(parsed.pathname);
+	}
+	dispose() {
+		for (const workspace of this.workspaces.values()) workspace.dispose();
+		this.workspaces.clear();
+	}
+	ids() {
+		return [HOME_WORKSPACE_ID, ...this.folders.map(workspaceIdOf)];
+	}
+	folderOf(id) {
+		if (id === "home") return homedir();
+		return this.folders.find((folder) => workspaceIdOf(folder) === id);
+	}
+	ensure(id) {
+		const existing = this.workspaces.get(id);
+		if (existing) return Promise.resolve(existing);
+		let pending = this.starting.get(id);
+		if (!pending) {
+			pending = (async () => {
+				const folder = this.folderOf(id);
+				if (!folder) throw new Error(`No open folder "${id}"`);
+				const workspace = new Workspace(id, folder, this.shared, {
+					info: (wid) => this.info(wid),
+					list: () => this.list(),
+					open: (f) => this.open(f),
+					close: (wid) => this.close(wid),
+					activate: (wid) => this.activate(wid)
+				});
+				workspace.view.setVisible(false);
+				this.window?.contentView.addChildView(workspace.view);
+				this.workspaces.set(id, workspace);
+				this.layoutViews();
+				await workspace.start();
+				return workspace;
+			})().finally(() => this.starting.delete(id));
+			this.starting.set(id, pending);
+		}
+		return pending;
+	}
+	layoutViews() {
+		if (!this.window || this.window.isDestroyed()) return;
+		const { width, height } = this.window.getContentBounds();
+		for (const workspace of this.workspaces.values()) workspace.view.setBounds({
+			x: 0,
+			y: 0,
+			width,
+			height
+		});
+	}
+	broadcast() {
+		const list = this.list();
+		for (const workspace of this.workspaces.values()) workspace.server.emit("workspaces.changed", list);
+	}
+	persist() {
+		return this.file.write({
+			folders: this.folders,
+			activeId: this.activeId
+		});
+	}
+};
+//#endregion
+//#region src/main/index.ts
+var safeMode = process.argv.includes("--safe-mode");
+protocol.registerSchemesAsPrivileged([{
+	scheme: EXTENSION_PROTOCOL,
+	privileges: {
+		standard: true,
+		secure: true,
+		supportFetchAPI: true,
+		corsEnabled: true,
+		stream: true
+	}
+}, {
+	scheme: FILE_PROTOCOL,
+	privileges: {
+		standard: true,
+		secure: true,
+		supportFetchAPI: true,
+		corsEnabled: true,
+		stream: true
+	}
+}]);
+var MIME_TYPES = {
+	js: "text/javascript",
+	css: "text/css",
+	json: "application/json",
+	map: "application/json",
+	png: "image/png",
+	svg: "image/svg+xml"
+};
+/** The window is only a frame: each folder tab is a view inside it with its own renderer. */
+var createWindow = () => {
+	return new BrowserWindow({
+		width: 1440,
+		height: 900,
+		minWidth: 720,
+		minHeight: 480,
+		show: false,
+		backgroundColor: "#0a0a0a",
+		titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",
+		trafficLightPosition: {
+			x: 14,
+			y: 13
+		}
+	});
+};
+var main = async () => {
+	await app.whenReady();
+	const resourcesDir = join(app.getAppPath(), "resources");
+	const rootSettings = new SettingsService(paths.settings);
+	await rootSettings.load();
+	await prepareExtensionsWorkspace(paths.extensions, resourcesDir);
+	const builder = new ExtensionBuilder();
+	const workspaces = new WorkspaceManager({
+		appVersion: () => app.getVersion(),
+		resourcesDir,
+		preloadPath: join(import.meta.dirname, "../preload/index.cjs"),
+		rendererUrl: process.env.ELECTRON_RENDERER_URL ? { url: process.env.ELECTRON_RENDERER_URL } : { file: join(import.meta.dirname, "../renderer/index.html") },
+		safeMode,
+		fs: new LocalFileSystem(),
+		storage: new StorageService(paths.storage),
+		secrets: new SecretStore(paths.secrets),
+		rootSettings,
+		builder,
+		globalExtensions: new ExtensionSource({
+			key: "global",
+			kind: "global",
+			dir: paths.extensions,
+			builder,
+			repo: new ExtensionsRepo(paths.extensions)
+		})
+	});
+	await workspaces.restore();
+	installApplicationMenu({ openFolder: () => void workspaces.open().catch(console.error) });
+	protocol.handle(EXTENSION_PROTOCOL, async (request) => {
+		const file = workspaces.resolveAsset(request.url);
+		if (!file) return new Response("Not found", { status: 404 });
+		const response = await net.fetch(pathToFileURL(file).toString());
+		const extension = file.split(".").pop() ?? "";
+		return new Response(response.body, {
+			status: response.status,
+			headers: {
+				"Content-Type": MIME_TYPES[extension] ?? "application/octet-stream",
+				"Access-Control-Allow-Origin": "*",
+				"Cache-Control": "no-store"
+			}
+		});
+	});
+	protocol.handle(FILE_PROTOCOL, handleFileRequest);
+	let mainWindow;
+	const openWindow = async () => {
+		const window = createWindow();
+		mainWindow = window;
+		window.on("closed", () => {
+			if (mainWindow === window) mainWindow = void 0;
+		});
+		await workspaces.attach(window);
+		window.show();
+	};
+	await openWindow();
+	app.on("before-quit", () => workspaces.dispose());
+	app.on("activate", () => {
+		if (!mainWindow) openWindow();
+	});
+};
+app.on("window-all-closed", () => {
+	if (process.platform !== "darwin") app.quit();
+});
+main().catch((error) => {
+	console.error("Nubase failed to start", error);
+	app.quit();
+});
+//#endregion
+export {};