@alashi/cli 0.1.0

package/dist/store-CwgDCAAx.mjs

@@ -0,0 +1,1201 @@
+import { APP_NAME_PATTERN, AppSdkError, ConfigError, JsonFileStore, SDK_VERSION, evaluateAppConfig, interpolateConfig, manifestConfigDefaults, mergeConfig, parseManifest } from "@alashi/apps-sdk";
+import semver from "semver";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { extname, isAbsolute, join, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { Cron } from "croner";
+import { homedir } from "node:os";
+//#region src/compat.ts
+/**
+* Enforces the manifest's declared `sdkVersion` range against the SDK
+* this host is built with. Apps that declare nothing are accepted.
+*/
+function checkSdkCompatibility(manifest) {
+	const range = manifest.sdkVersion;
+	if (!range) return;
+	if (!semver.validRange(range)) throw new AppSdkError(`App "${manifest.name}" declares an invalid sdkVersion range: ${JSON.stringify(range)}`);
+	if (!semver.satisfies(SDK_VERSION, range)) throw new AppSdkError(`App "${manifest.name}" supports SDK ${range}, but this host uses SDK ${SDK_VERSION}. Update the host (or the app) to a compatible version.`);
+}
+//#endregion
+//#region src/loader.ts
+function entryFromExports(exportsField) {
+	if (typeof exportsField === "string") return exportsField;
+	if (typeof exportsField !== "object" || exportsField === null) return void 0;
+	const record = exportsField;
+	const dot = record["."] ?? record.default ?? record.import;
+	if (typeof dot === "string") return dot;
+	if (typeof dot === "object" && dot !== null) {
+		const conditions = dot;
+		const target = conditions.default ?? conditions.import;
+		if (typeof target === "string") return target;
+	}
+}
+/**
+* Imports an app's entry module and validates its default export.
+* The manifest is always re-validated here — the host never trusts
+* that an app used defineApp().
+*/
+async function loadApp(repoDir) {
+	let pkg;
+	try {
+		pkg = JSON.parse(await readFile(join(repoDir, "package.json"), "utf8"));
+	} catch (err) {
+		throw new AppSdkError(`App has no readable package.json in ${repoDir}`, { cause: err });
+	}
+	const entry = entryFromExports(pkg.exports) ?? pkg.main ?? "index.js";
+	const entryPath = join(repoDir, entry);
+	let mod;
+	try {
+		mod = await import(`${pathToFileURL(entryPath).href}?t=${Date.now()}`);
+	} catch (err) {
+		let detail = String(err);
+		if (err?.name === "ManifestValidationError" && /Unrecognized key/i.test(detail)) detail += "\nThe manifest may use fields newer than the app's bundled @alashi/apps-sdk — update the app's dependency to match its sdkVersion.";
+		throw new AppSdkError(`Failed to import app entry ${entry}: ${detail}`, { cause: err });
+	}
+	const definition = mod.default;
+	if (typeof definition !== "object" || definition === null || !("manifest" in definition)) throw new AppSdkError("App entry must default-export an app definition (use defineApp() from @alashi/apps-sdk)");
+	return {
+		definition,
+		manifest: parseManifest(definition.manifest),
+		entryPath
+	};
+}
+//#endregion
+//#region src/sources.ts
+const execFileAsync$1 = promisify(execFile);
+function parseSourceArg(arg) {
+	if (arg.startsWith(".") || isAbsolute(arg)) return {
+		type: "local",
+		path: resolve(arg)
+	};
+	if (/^(https?:\/\/|git@|ssh:\/\/)/.test(arg)) return {
+		type: "git",
+		url: arg
+	};
+	if (/^github\.com\//.test(arg)) return {
+		type: "git",
+		url: `https://${arg}`
+	};
+	return {
+		type: "registry",
+		name: arg
+	};
+}
+async function git(args, cwd) {
+	try {
+		const { stdout } = await execFileAsync$1("git", args, cwd ? { cwd } : {});
+		return stdout.trim();
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new AppSdkError(`git ${args[0]} failed: ${message}`, { cause: err });
+	}
+}
+/** Materializes a source at destDir: git clone, or symlink for local dev installs. */
+async function fetchSource(spec, destDir) {
+	await mkdir(resolve(destDir, ".."), { recursive: true });
+	if (spec.type === "git") {
+		const args = [
+			"clone",
+			"--depth",
+			"1"
+		];
+		if (spec.ref) args.push("--branch", spec.ref);
+		args.push(spec.url, destDir);
+		await git(args);
+		return;
+	}
+	await symlink(spec.path, destDir, "dir");
+}
+/** Brings an installed source up to date in place. Local symlinks are always live. */
+async function updateSource(spec, repoDir) {
+	if (spec.type === "git") await git(["pull", "--ff-only"], repoDir);
+}
+//#endregion
+//#region src/registry.ts
+const registryIndexSchema = z.object({ apps: z.array(z.object({
+	name: z.string().min(1),
+	repo: z.string().min(1),
+	description: z.string().optional(),
+	ref: z.string().optional(),
+	sdkVersion: z.string().optional()
+})) });
+function parseIndex(raw, source) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch (err) {
+		throw new AppSdkError(`Registry ${source} did not return valid JSON`, { cause: err });
+	}
+	const result = registryIndexSchema.safeParse(data);
+	if (!result.success) throw new AppSdkError(`Registry ${source} has an invalid index: ${result.error.message}`);
+	return result.data;
+}
+/**
+* Fetches a registry index and caches it under registries/<name>.json.
+* URLs ending in .json are fetched over HTTP; anything else is treated
+* as a git repo containing index.json at its root (brew-tap style).
+*/
+async function refreshRegistry(store, registry) {
+	let raw;
+	if (/^https?:\/\/.*\.json$/.test(registry.url)) {
+		const response = await fetch(registry.url);
+		if (!response.ok) throw new AppSdkError(`Registry fetch failed (${response.status}) for ${registry.url}`);
+		raw = await response.text();
+	} else {
+		const cloneDir = join(store.stagingDir, `registry-${registry.name}-${Date.now()}`);
+		await fetchSource({
+			type: "git",
+			url: registry.url
+		}, cloneDir);
+		try {
+			raw = await readFile(join(cloneDir, "index.json"), "utf8");
+		} finally {
+			await rm(cloneDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	const index = parseIndex(raw, registry.url);
+	await mkdir(store.registriesDir, { recursive: true });
+	await writeFile(store.registryCachePath(registry.name), JSON.stringify(index, null, 2), "utf8");
+	return index;
+}
+async function readCachedIndex(store, name) {
+	try {
+		return parseIndex(await readFile(store.registryCachePath(name), "utf8"), name);
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		throw err;
+	}
+}
+async function addRegistry(store, name, url) {
+	const config = await store.readGlobalConfig();
+	if (config.registries.some((r) => r.name === name)) throw new AppSdkError(`Registry "${name}" already exists`);
+	const index = await refreshRegistry(store, {
+		name,
+		url
+	});
+	config.registries.push({
+		name,
+		url
+	});
+	await store.writeGlobalConfig(config);
+	return index;
+}
+async function removeRegistry(store, name) {
+	const config = await store.readGlobalConfig();
+	const next = config.registries.filter((r) => r.name !== name);
+	if (next.length === config.registries.length) throw new AppSdkError(`Registry "${name}" is not configured`);
+	config.registries = next;
+	await store.writeGlobalConfig(config);
+	await rm(store.registryCachePath(name), { force: true });
+}
+/** Finds an app by name across configured registries (refreshing caches). */
+async function resolveApp(store, appName) {
+	const config = await store.readGlobalConfig();
+	if (config.registries.length === 0) throw new AppSdkError(`No registries configured. Add one with: alashi registry add <name> <url>`);
+	for (const registry of config.registries) {
+		let index;
+		try {
+			index = await refreshRegistry(store, registry);
+		} catch {
+			const cached = await readCachedIndex(store, registry.name);
+			if (!cached) continue;
+			index = cached;
+		}
+		const app = index.apps.find((a) => a.name === appName);
+		if (app) return {
+			registry: registry.name,
+			app
+		};
+	}
+	throw new AppSdkError(`App "${appName}" not found in any configured registry`);
+}
+//#endregion
+//#region src/installer.ts
+const execFileAsync = promisify(execFile);
+async function hasDependencies(dir) {
+	try {
+		const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+		return Object.keys(pkg.dependencies ?? {}).length > 0;
+	} catch {
+		return false;
+	}
+}
+/** Lifecycle scripts stay off: installing an app must not execute arbitrary code. */
+async function installDependencies(dir) {
+	if (!await hasDependencies(dir)) return;
+	try {
+		await execFileAsync("npm", [
+			"install",
+			"--ignore-scripts",
+			"--omit=dev",
+			"--no-fund",
+			"--no-audit"
+		], { cwd: dir });
+	} catch (err) {
+		throw new AppSdkError(`npm install failed: ${err instanceof Error ? err.message : err}`, { cause: err });
+	}
+}
+/**
+* Install flow: materialize the source into a staging dir, install deps
+* (scripts disabled), import + validate the manifest, and only then move
+* it into apps/<name>/repo. A failed validation never leaves a broken app.
+*/
+async function installApp(store, source, options = {}) {
+	let spec;
+	let expectName = options.expectName;
+	if (typeof source === "string") {
+		const parsed = parseSourceArg(source);
+		if (parsed.type === "registry") {
+			const resolved = await resolveApp(store, parsed.name);
+			spec = {
+				type: "git",
+				url: resolved.app.repo,
+				...resolved.app.ref && { ref: resolved.app.ref }
+			};
+			expectName = expectName ?? parsed.name;
+		} else spec = parsed;
+	} else spec = source;
+	let stageDir;
+	let inspectDir;
+	if (spec.type === "local") inspectDir = spec.path;
+	else {
+		stageDir = join(store.stagingDir, randomUUID());
+		await fetchSource(spec, stageDir);
+		await installDependencies(stageDir);
+		inspectDir = stageDir;
+	}
+	try {
+		const { manifest } = await loadApp(inspectDir);
+		checkSdkCompatibility(manifest);
+		if (expectName && manifest.name !== expectName) throw new AppSdkError(`App manifest name "${manifest.name}" does not match requested "${expectName}"`);
+		if (await store.readAppRecord(manifest.name)) throw new AppSdkError(`App "${manifest.name}" is already installed (use: alashi update ${manifest.name})`);
+		const repoDir = store.appRepoDir(manifest.name);
+		await mkdir(store.appDir(manifest.name), { recursive: true });
+		if (stageDir) {
+			await rename(stageDir, repoDir);
+			stageDir = void 0;
+		} else await fetchSource(spec, repoDir);
+		await mkdir(store.appDataDir(manifest.name), { recursive: true });
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const record = {
+			name: manifest.name,
+			version: manifest.version,
+			...manifest.sdkVersion && { sdkVersion: manifest.sdkVersion },
+			source: spec,
+			installedAt: now,
+			updatedAt: now
+		};
+		await store.writeAppRecord(record);
+		return record;
+	} finally {
+		if (stageDir) await rm(stageDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function updateApp(store, name) {
+	const record = await store.readAppRecord(name);
+	if (!record) throw new AppSdkError(`App "${name}" is not installed`);
+	const repoDir = store.appRepoDir(name);
+	await updateSource(record.source, repoDir);
+	await installDependencies(repoDir);
+	const { manifest } = await loadApp(repoDir);
+	checkSdkCompatibility(manifest);
+	if (manifest.name !== name) throw new AppSdkError(`App renamed itself to "${manifest.name}"; refusing update`);
+	const updated = {
+		...record,
+		version: manifest.version,
+		...manifest.sdkVersion && { sdkVersion: manifest.sdkVersion },
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await store.writeAppRecord(updated);
+	return updated;
+}
+async function removeApp(store, name, options = {}) {
+	if (!await store.readAppRecord(name)) throw new AppSdkError(`App "${name}" is not installed`);
+	if (options.purge) {
+		await rm(store.appDir(name), {
+			recursive: true,
+			force: true
+		});
+		return;
+	}
+	await rm(store.appRepoDir(name), {
+		recursive: true,
+		force: true
+	});
+	await rm(store.appRecordPath(name), { force: true });
+}
+//#endregion
+//#region src/runtime.ts
+function createLogger(prefix) {
+	const log = (level, message, data) => {
+		const line = `[${prefix}] ${message}`;
+		if (data === void 0) console[level](line);
+		else console[level](line, data);
+	};
+	return {
+		debug: (message, data) => log("debug", message, data),
+		info: (message, data) => log("info", message, data),
+		warn: (message, data) => log("warn", message, data),
+		error: (message, data) => log("error", message, data)
+	};
+}
+/**
+* Wraps the host provider so every session an app opens automatically gets
+* its manifest-declared MCP servers, tool allowlist, agents, skills,
+* instructions, and data-dir cwd. Per-call options still win where they
+* overlap.
+*/
+function scopeProvider(provider, defaults) {
+	return {
+		name: provider.name,
+		async createSession(options = {}) {
+			if (defaults.unreadyError !== void 0) throw new ConfigError(defaults.unreadyError);
+			const mcpServers = {
+				...defaults.mcpServers,
+				...options.mcpServers
+			};
+			const allowedTools = [.../* @__PURE__ */ new Set([...defaults.allowedTools, ...options.allowedTools ?? []])];
+			const agents = {
+				...defaults.agents,
+				...options.agents
+			};
+			const skillDirs = [.../* @__PURE__ */ new Set([...defaults.skillDirs, ...options.skillDirs ?? []])];
+			return provider.createSession({
+				cwd: defaults.cwd,
+				...defaults.instructions !== void 0 && { systemPrompt: defaults.instructions },
+				...options,
+				...Object.keys(mcpServers).length > 0 && { mcpServers },
+				...allowedTools.length > 0 && { allowedTools },
+				...Object.keys(agents).length > 0 && { agents },
+				...skillDirs.length > 0 && { skillDirs }
+			});
+		}
+	};
+}
+/** Merges the config layers for an app and evaluates its setup state. */
+async function resolveAppConfig(store, manifest) {
+	const globalConfig = await store.readGlobalConfig();
+	const merged = mergeConfig(manifestConfigDefaults(manifest), globalConfig.apps?.[manifest.name], await store.readAppConfig(manifest.name));
+	return {
+		merged,
+		status: evaluateAppConfig(manifest, merged)
+	};
+}
+/**
+* Builds the AppContext for an installed app: merges the config layers
+* (manifest defaults < global apps[name] < per-app config), resolves
+* `${config.*}` placeholders (with `dataDir` available as a built-in key),
+* and scopes the AI provider to the app's manifest.
+*
+* Setup state shapes the session defaults: unconfigured MCP servers are
+* dropped (with their tools) so interpolation never hits a missing key, and
+* while required keys are missing the scoped provider fails closed.
+*/
+async function buildAppContext(store, manifest, provider) {
+	const name = manifest.name;
+	const dataDir = store.appDataDir(name);
+	const repoDir = store.appRepoDir(name);
+	await mkdir(dataDir, { recursive: true });
+	const { merged, status } = await resolveAppConfig(store, manifest);
+	const lookup = {
+		...merged,
+		dataDir
+	};
+	const interpolate = (value) => interpolateConfig(value, lookup, { resolveRelativeTo: repoDir });
+	const config = interpolate(merged);
+	const excluded = status.integrations.filter((i) => !i.configured).map((i) => i.name);
+	const mcpServers = interpolate(Object.fromEntries(Object.entries(manifest.mcpServers).filter(([server]) => !excluded.includes(server)).map(([server, { optional: _optional, ...decl }]) => [server, decl])));
+	const allowedTools = manifest.permissions.allowedTools.filter((tool) => !excluded.some((server) => tool.startsWith(`mcp__${server}__`)));
+	return {
+		appName: name,
+		dataDir,
+		config,
+		logger: createLogger(name),
+		state: new JsonFileStore(join(dataDir, "state.json")),
+		ai: scopeProvider(provider, {
+			mcpServers,
+			allowedTools,
+			agents: manifest.agents,
+			skillDirs: manifest.skills.map((dir) => resolve(repoDir, dir)),
+			...manifest.instructions !== void 0 && { instructions: manifest.instructions },
+			cwd: dataDir,
+			...!status.ready && { unreadyError: `App "${name}" is not configured: missing ${status.missing.join(", ")}. Set the missing keys in the dashboard settings or ${store.appConfigPath(name)}.` }
+		})
+	};
+}
+//#endregion
+//#region src/scheduler.ts
+const RUN_LOG_CAP = 50;
+function nextFire(schedule, after) {
+	return new Cron(schedule).nextRun(after ?? void 0);
+}
+/**
+* Runs manifest-declared jobs on their cron schedules. One instance per host
+* process; start() schedules every installed app's jobs, stop() cancels them.
+* A job missed while the host was down runs once at startup ("catchup"), but
+* only if it has run before — a fresh install waits for its first slot.
+*/
+var Scheduler = class {
+	store;
+	getApp;
+	crons = [];
+	runningJobs = /* @__PURE__ */ new Set();
+	started = false;
+	/** Serializes jobs.json read-modify-write across concurrently finishing jobs. */
+	stateQueue = Promise.resolve();
+	constructor(store, getApp) {
+		this.store = store;
+		this.getApp = getApp;
+	}
+	async start() {
+		if (this.started) return;
+		this.started = true;
+		for (const record of await this.store.listInstalled()) {
+			let app;
+			try {
+				app = await this.getApp(record.name);
+			} catch (err) {
+				console.error(`[scheduler] skipping ${record.name}: failed to load (${String(err)})`);
+				continue;
+			}
+			if (!app || app.manifest.jobs.length === 0) continue;
+			const state = await this.store.readJobState(record.name);
+			for (const job of app.manifest.jobs) {
+				let cron;
+				try {
+					cron = new Cron(job.schedule, { paused: true }, () => {
+						this.run(record.name, job.name, "schedule");
+					});
+				} catch (err) {
+					app.ctx.logger.error(`Job "${job.name}" has an invalid schedule`, {
+						schedule: job.schedule,
+						error: String(err)
+					});
+					continue;
+				}
+				const last = state.lastRun[job.name];
+				if (last) {
+					const missed = nextFire(job.schedule, new Date(last));
+					if (missed && missed.getTime() <= Date.now()) this.run(record.name, job.name, "catchup");
+				}
+				cron.resume();
+				this.crons.push(cron);
+			}
+		}
+	}
+	stop() {
+		for (const cron of this.crons) cron.stop();
+		this.crons = [];
+		this.started = false;
+	}
+	/**
+	* Runs one job immediately. Returns the recorded run, 'skipped' when that
+	* job is already mid-run, or undefined when the app/job doesn't exist.
+	*/
+	async run(appName, jobName, trigger = "manual") {
+		const app = await this.getApp(appName).catch(() => void 0);
+		const handler = app?.jobHandlers?.[jobName];
+		if (!app || !handler || !app.manifest.jobs.some((j) => j.name === jobName)) return void 0;
+		const key = `${appName}/${jobName}`;
+		if (this.runningJobs.has(key)) return "skipped";
+		this.runningJobs.add(key);
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		let ok = true;
+		let error;
+		try {
+			await handler(app.ctx);
+		} catch (err) {
+			ok = false;
+			error = String(err);
+			app.ctx.logger.error(`Job "${jobName}" failed`, { error });
+		} finally {
+			this.runningJobs.delete(key);
+		}
+		const run = {
+			job: jobName,
+			trigger,
+			startedAt,
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			ok,
+			...error !== void 0 && { error }
+		};
+		await this.recordRun(appName, run);
+		return run;
+	}
+	/** Job statuses for an app, or undefined when the app isn't installed. */
+	async status(appName) {
+		const app = await this.getApp(appName).catch(() => void 0);
+		if (!app) return void 0;
+		const state = await this.store.readJobState(appName);
+		return app.manifest.jobs.map((job) => {
+			let valid = true;
+			let nextRun;
+			try {
+				nextRun = nextFire(job.schedule)?.toISOString();
+			} catch {
+				valid = false;
+			}
+			return {
+				name: job.name,
+				schedule: job.schedule,
+				...job.description !== void 0 && { description: job.description },
+				valid,
+				running: this.runningJobs.has(`${appName}/${job.name}`),
+				...nextRun !== void 0 && { nextRun },
+				...state.lastRun[job.name] !== void 0 && { lastRun: state.lastRun[job.name] },
+				recentRuns: state.runs.filter((r) => r.job === job.name).slice(-5).reverse()
+			};
+		});
+	}
+	recordRun(appName, run) {
+		const update = this.stateQueue.then(async () => {
+			const state = await this.store.readJobState(appName);
+			state.lastRun[run.job] = run.startedAt;
+			state.runs.push(run);
+			if (state.runs.length > RUN_LOG_CAP) state.runs.splice(0, state.runs.length - RUN_LOG_CAP);
+			await this.store.writeJobState(appName, state);
+		});
+		this.stateQueue = update.catch(() => void 0);
+		return update;
+	}
+};
+//#endregion
+//#region src/settings-page.ts
+/**
+* Self-contained per-app settings page. All data comes from
+* GET /api/apps/:name/config at runtime; saving PUTs only changed keys.
+* The app name is injected via a JSON-encoded script constant, never into
+* markup, so no escaping subtleties apply.
+*/
+function settingsPage(name) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Settings</title>
+<style>
+  :root { --accent: #6d28d9; --bg: #f6f5f8; --card: #fff; --line: #e5e2eb; --muted: #6b6478; }
+  * { box-sizing: border-box; }
+  body { margin: 0; font: 15px/1.5 system-ui, sans-serif; background: var(--bg); color: #1d1a24; }
+  header { background: #17141f; color: #fff; padding: 14px 24px; display: flex; align-items: center; gap: 12px; }
+  header a { color: #cbc4dd; text-decoration: none; }
+  main { max-width: 760px; margin: 24px auto; padding: 0 16px; }
+  .banner { border-radius: 8px; padding: 10px 14px; margin-bottom: 16px; font-weight: 500; }
+  .banner.ok { background: #e7f6ec; color: #16652f; }
+  .banner.warn { background: #fdeeee; color: #9c2121; }
+  .card { background: var(--card); border: 1px solid var(--line); border-radius: 10px; margin-bottom: 16px; }
+  .card h2 { margin: 0; padding: 12px 16px; font-size: 15px; border-bottom: 1px solid var(--line);
+             display: flex; align-items: center; justify-content: space-between; }
+  .chip { font-size: 12px; font-weight: 600; border-radius: 999px; padding: 2px 10px; }
+  .chip.on { background: #e7f6ec; color: #16652f; }
+  .chip.off { background: #f1eef7; color: var(--muted); }
+  .card .body { padding: 12px 16px 16px; }
+  .field { margin-bottom: 12px; }
+  .field label { display: block; font-weight: 600; font-size: 13px; margin-bottom: 2px; }
+  .field .desc { font-size: 12.5px; color: var(--muted); margin-bottom: 4px; }
+  .field input { width: 100%; padding: 8px 10px; border: 1px solid var(--line); border-radius: 6px;
+                 font: inherit; }
+  .field input:focus { outline: 2px solid var(--accent); border-color: transparent; }
+  .req { color: #9c2121; }
+  button { background: var(--accent); color: #fff; border: 0; border-radius: 6px;
+           padding: 9px 18px; font: inherit; font-weight: 600; cursor: pointer; }
+  button:disabled { opacity: 0.5; cursor: default; }
+  #status { margin-left: 12px; color: var(--muted); }
+</style>
+</head>
+<body>
+<header><a href="/">alashi</a> <span>/</span> <strong id="title"></strong> <span>settings</span></header>
+<main>
+  <div id="banner" class="banner" hidden></div>
+  <div id="cards"></div>
+  <button id="save">Save changes</button><span id="status"></span>
+</main>
+<script>
+const APP = ${JSON.stringify(name)};
+document.getElementById('title').textContent = APP;
+
+const state = { data: null, dirty: new Map() };
+
+function el(tag, attrs = {}, children = []) {
+  const node = document.createElement(tag);
+  for (const [k, v] of Object.entries(attrs)) {
+    if (k === 'text') node.textContent = v;
+    else if (k.startsWith('on')) node.addEventListener(k.slice(2), v);
+    else node.setAttribute(k, v);
+  }
+  for (const child of children) node.append(child);
+  return node;
+}
+
+function parseInput(raw) {
+  if (raw === '') return null; // empty clears the user-set value
+  try { const v = JSON.parse(raw); if (typeof v !== 'string') return v; } catch {}
+  return raw;
+}
+
+function displayValue(value) {
+  return typeof value === 'string' ? value : value === undefined ? '' : JSON.stringify(value);
+}
+
+function field(key, decl, data) {
+  const secret = decl.secret === true;
+  const isSet = secret ? data.secretsSet.includes(key) : data.values[key] !== undefined;
+  const input = el('input', {
+    type: secret ? 'password' : 'text',
+    value: secret ? '' : displayValue(data.values[key]),
+    placeholder: secret && isSet ? '(set — type to replace)' : '',
+    oninput: () => state.dirty.set(key, { secret, input }),
+  });
+  const labelChildren = [document.createTextNode(key)];
+  if (decl.required) labelChildren.push(el('span', { class: 'req', text: ' *' }));
+  const parts = [el('label', {}, labelChildren)];
+  if (decl.description) parts.push(el('div', { class: 'desc', text: decl.description }));
+  parts.push(input);
+  return el('div', { class: 'field' }, parts);
+}
+
+function card(title, keys, data, configured) {
+  const chip = configured === undefined
+    ? ''
+    : el('span', { class: 'chip ' + (configured ? 'on' : 'off'),
+                   text: configured ? 'configured' : 'not configured' });
+  return el('div', { class: 'card' }, [
+    el('h2', {}, chip === '' ? [document.createTextNode(title)] : [document.createTextNode(title), chip]),
+    el('div', { class: 'body' }, keys.map((key) => field(key, data.schema[key] ?? {}, data))),
+  ]);
+}
+
+function render(data) {
+  state.data = data;
+  state.dirty.clear();
+  const banner = document.getElementById('banner');
+  banner.hidden = false;
+  if (data.ready) {
+    banner.className = 'banner ok';
+    banner.textContent = 'App is configured and ready.';
+  } else {
+    banner.className = 'banner warn';
+    banner.textContent = 'Needs setup — missing: ' + data.missing.join(', ');
+  }
+
+  const cards = document.getElementById('cards');
+  cards.replaceChildren();
+  const integrationKeys = new Set(data.integrations.flatMap((i) => i.configKeys));
+  const generalKeys = Object.keys(data.schema).filter((k) => !integrationKeys.has(k));
+  if (generalKeys.length > 0) cards.append(card('General', generalKeys, data, undefined));
+  for (const integration of data.integrations) {
+    if (integration.configKeys.length === 0) continue;
+    cards.append(card(
+      integration.name + (integration.optional ? ' (optional integration)' : ''),
+      integration.configKeys, data, integration.configured,
+    ));
+  }
+  if (cards.childElementCount === 0) {
+    cards.append(el('p', { text: 'This app declares no configurable settings.' }));
+  }
+}
+
+async function load() {
+  const res = await fetch('/api/apps/' + APP + '/config');
+  if (!res.ok) {
+    document.getElementById('banner').hidden = false;
+    document.getElementById('banner').className = 'banner warn';
+    document.getElementById('banner').textContent = 'Failed to load config (' + res.status + ')';
+    return;
+  }
+  render(await res.json());
+}
+
+document.getElementById('save').addEventListener('click', async () => {
+  const body = {};
+  for (const [key, { secret, input }] of state.dirty) {
+    if (secret && input.value === '') continue; // untouched secret: keep as-is
+    body[key] = parseInput(input.value);
+  }
+  if (Object.keys(body).length === 0) return;
+  const status = document.getElementById('status');
+  status.textContent = 'Saving…';
+  const res = await fetch('/api/apps/' + APP + '/config', {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  status.textContent = res.ok ? 'Saved — app restarted.' : 'Save failed (' + res.status + ')';
+  if (res.ok) await load();
+});
+
+load();
+<\/script>
+</body>
+</html>
+`;
+}
+//#endregion
+//#region src/server.ts
+const CONTENT_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".txt": "text/plain; charset=utf-8"
+};
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+/**
+* The host HTTP surface:
+*   GET  /                      dashboard of installed apps
+*   GET  /settings/:name        per-app settings page (config form)
+*   GET  /api/apps              installed apps as JSON
+*   POST /api/apps/:name/chat   { message, conversationId? } -> SSE stream of AgentEvents
+*                               (omit conversationId to start a new conversation; the
+*                                id is echoed in the x-conversation-id response header)
+*   GET  /api/apps/:name/chat/conversations          conversations, most recent first
+*   GET  /api/apps/:name/chat/:conversationId/history  past turns from the provider transcript
+*   GET  /api/apps/:name/jobs           manifest-declared jobs with schedule/status
+*   POST /api/apps/:name/jobs/:job/run  trigger a job now (409 while already running)
+*   GET  /api/apps/:name/config         declared config schema + merged values
+*                                       (secrets masked) + readiness/integrations
+*   PUT  /api/apps/:name/config         merge keys into the per-app config layer
+*                                       (null deletes a key) and restart the app
+*   ALL  /app/:name/api/*       dispatched to the app's fetch handler (prefix stripped)
+*   ALL  /app/:name/*           a matching static file from the app's ui dir wins,
+*                               otherwise the app's fetch handler (/app/:name stripped),
+*                               otherwise 404
+*/
+function createServer(store, provider) {
+	const apps = /* @__PURE__ */ new Map();
+	const sessions = /* @__PURE__ */ new Map();
+	async function startApp(name) {
+		const { definition, manifest } = await loadApp(store.appRepoDir(name));
+		const ctx = await buildAppContext(store, manifest, provider);
+		return {
+			manifest,
+			ctx,
+			handler: definition.routes ? await definition.routes(ctx) : void 0,
+			jobHandlers: definition.jobHandlers
+		};
+	}
+	/** Loads an installed app once per process; undefined when not installed. */
+	async function getApp(name) {
+		if (!APP_NAME_PATTERN.test(name)) return void 0;
+		if (!await store.readAppRecord(name)) return void 0;
+		let running = apps.get(name);
+		if (!running) {
+			running = startApp(name);
+			running.catch(() => apps.delete(name));
+			apps.set(name, running);
+		}
+		return running;
+	}
+	/** chat.json per app, loaded once and mutated in place so turns share one view. */
+	const chatStates = /* @__PURE__ */ new Map();
+	function getChatState(name) {
+		let state = chatStates.get(name);
+		if (!state) {
+			state = store.readChatState(name);
+			state.catch(() => chatStates.delete(name));
+			chatStates.set(name, state);
+		}
+		return state;
+	}
+	function getSession(name, running, convo) {
+		const key = `${name}/${convo.id}`;
+		let session = sessions.get(key);
+		if (!session) {
+			const model = running.ctx.config.model;
+			session = running.ctx.ai.createSession({
+				...typeof model === "string" && { model },
+				...convo.sessionId && { resume: convo.sessionId }
+			});
+			session.catch(() => sessions.delete(key));
+			sessions.set(key, session);
+		}
+		return session;
+	}
+	const scheduler = new Scheduler(store, getApp);
+	/** Rebuilds the request with `prefix` stripped and hands it to the app's handler. */
+	function dispatch(handler, raw, prefix) {
+		const url = new URL(raw.url);
+		url.pathname = url.pathname.slice(prefix.length) || "/";
+		return handler(new Request(url, {
+			method: raw.method,
+			headers: raw.headers,
+			body: raw.body,
+			...raw.body ? { duplex: "half" } : {}
+		}));
+	}
+	/** A file from the app's ui dir, or undefined when there is no match. */
+	async function serveStatic(name, manifest, reqPath) {
+		if (!manifest.ui) return void 0;
+		const uiDir = resolve(store.appRepoDir(name), manifest.ui);
+		let rest;
+		try {
+			rest = decodeURIComponent(reqPath.slice(`/app/${name}/`.length));
+		} catch {
+			return;
+		}
+		if (rest === "" || rest.endsWith("/")) rest += "index.html";
+		const filePath = resolve(uiDir, rest);
+		if (filePath !== uiDir && !filePath.startsWith(uiDir + sep)) return void 0;
+		try {
+			const body = await readFile(filePath);
+			const type = CONTENT_TYPES[extname(filePath)] ?? "application/octet-stream";
+			return new Response(new Uint8Array(body), {
+				status: 200,
+				headers: { "content-type": type }
+			});
+		} catch {
+			return;
+		}
+	}
+	const app = new Hono();
+	app.onError((err, c) => c.json({ error: String(err) }, 500));
+	/** Readiness for the dashboard badge; undefined when the app fails to load. */
+	async function readiness(name) {
+		try {
+			const running = await getApp(name);
+			if (!running) return void 0;
+			return (await resolveAppConfig(store, running.manifest)).status;
+		} catch {
+			return;
+		}
+	}
+	app.get("/", async (c) => {
+		const records = await store.listInstalled();
+		const rows = (await Promise.all(records.map(async (r) => {
+			const name = escapeHtml(r.name);
+			const status = await readiness(r.name);
+			const badge = status && !status.ready ? ` <a href="/settings/${name}" style="color:#9c2121;font-weight:600">needs setup</a>` : "";
+			return `<li><a href="/app/${name}/">${name}</a> <small>v${escapeHtml(r.version)} (${escapeHtml(r.source.type)})</small> <a href="/settings/${name}"><small>settings</small></a>${badge}</li>`;
+		}))).join("\n");
+		return c.html(`<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>alashi</title></head>
+<body>
+<h1>alashi</h1>
+${records.length === 0 ? "<p>No apps installed. Run <code>alashi install &lt;name&gt;</code>.</p>" : `<ul>\n${rows}\n</ul>`}
+</body>
+</html>
+`);
+	});
+	app.get("/api/apps", async (c) => c.json({ apps: await store.listInstalled() }));
+	app.get("/settings/:name", async (c) => {
+		const name = c.req.param("name");
+		if (!APP_NAME_PATTERN.test(name) || !await store.readAppRecord(name)) return c.json({ error: `App "${name}" is not installed` }, 404);
+		return c.html(settingsPage(name));
+	});
+	app.get("/api/apps/:name/chat/conversations", async (c) => {
+		const name = c.req.param("name");
+		if (!await getApp(name)) return c.json({ error: `App "${name}" is not installed` }, 404);
+		const { conversations } = await getChatState(name);
+		return c.json({ conversations: [...conversations].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)) });
+	});
+	app.get("/api/apps/:name/chat/:conversationId/history", async (c) => {
+		const name = c.req.param("name");
+		if (!await getApp(name)) return c.json({ error: `App "${name}" is not installed` }, 404);
+		const conversationId = c.req.param("conversationId");
+		const { conversations } = await getChatState(name);
+		const convo = conversations.find((conv) => conv.id === conversationId);
+		if (!convo) return c.json({ error: "Unknown conversation" }, 404);
+		const messages = convo.sessionId ? await provider.history?.(convo.sessionId) ?? [] : [];
+		return c.json({ messages });
+	});
+	/** Drops the cached app and its warm sessions so the next request rebuilds with fresh config. */
+	function restartApp(name) {
+		apps.delete(name);
+		for (const [key, session] of sessions) {
+			if (!key.startsWith(`${name}/`)) continue;
+			sessions.delete(key);
+			session.then((s) => s.close()).catch(() => void 0);
+		}
+	}
+	app.get("/api/apps/:name/config", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		const { manifest } = running;
+		const { merged, status } = await resolveAppConfig(store, manifest);
+		const values = { ...merged };
+		const secretsSet = [];
+		for (const [key, decl] of Object.entries(manifest.config)) {
+			if (decl.secret !== true) continue;
+			if (values[key] !== void 0) secretsSet.push(key);
+			delete values[key];
+		}
+		return c.json({
+			schema: manifest.config,
+			values,
+			secretsSet,
+			userKeys: Object.keys(await store.readAppConfig(name)),
+			...status
+		});
+	});
+	app.put("/api/apps/:name/config", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		let body;
+		try {
+			body = await c.req.json();
+		} catch {
+			return c.json({ error: "Body must be JSON" }, 400);
+		}
+		if (typeof body !== "object" || body === null || Array.isArray(body)) return c.json({ error: "Body must be an object of config keys" }, 400);
+		const config = await store.readAppConfig(name);
+		for (const [key, value] of Object.entries(body)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			if (value === null) delete config[key];
+			else config[key] = value;
+		}
+		await store.writeAppConfig(name, config);
+		restartApp(name);
+		const { status } = await resolveAppConfig(store, running.manifest);
+		return c.json({
+			ok: true,
+			...status
+		});
+	});
+	app.get("/api/apps/:name/jobs", async (c) => {
+		const name = c.req.param("name");
+		const jobs = await scheduler.status(name);
+		if (!jobs) return c.json({ error: `App "${name}" is not installed` }, 404);
+		return c.json({ jobs });
+	});
+	app.post("/api/apps/:name/jobs/:job/run", async (c) => {
+		const result = await scheduler.run(c.req.param("name"), c.req.param("job"));
+		if (result === void 0) return c.json({ error: "Unknown app or job" }, 404);
+		if (result === "skipped") return c.json({ error: "Job is already running" }, 409);
+		return c.json({ run: result }, result.ok ? 200 : 500);
+	});
+	app.post("/api/apps/:name/chat", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		let message;
+		let conversationId;
+		try {
+			({message, conversationId} = await c.req.json());
+		} catch {
+			return c.json({ error: "Body must be JSON" }, 400);
+		}
+		if (typeof message !== "string" || message.length === 0) return c.json({ error: "Body must be { \"message\": string }" }, 400);
+		if (conversationId !== void 0 && typeof conversationId !== "string") return c.json({ error: "\"conversationId\" must be a string" }, 400);
+		const state = await getChatState(name);
+		let convo;
+		if (conversationId !== void 0) {
+			convo = state.conversations.find((conv) => conv.id === conversationId);
+			if (!convo) return c.json({ error: "Unknown conversation" }, 404);
+		} else {
+			convo = {
+				id: randomUUID(),
+				title: message.slice(0, 80),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			state.conversations.push(convo);
+			await store.writeChatState(name, state);
+		}
+		const conversation = convo;
+		let session;
+		try {
+			session = await getSession(name, running, conversation);
+		} catch (err) {
+			return c.json({ error: `Failed to start AI session: ${String(err)}` }, 502);
+		}
+		c.header("x-conversation-id", conversation.id);
+		return streamSSE(c, async (stream) => {
+			try {
+				for await (const event of session.send(message)) {
+					if (event.type === "session") {
+						conversation.sessionId = event.sessionId;
+						conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+						await store.writeChatState(name, state);
+					}
+					await stream.writeSSE({
+						event: event.type,
+						data: JSON.stringify(event)
+					});
+				}
+			} catch (err) {
+				await stream.writeSSE({
+					event: "result",
+					data: JSON.stringify({
+						type: "result",
+						ok: false,
+						error: String(err)
+					})
+				});
+			}
+		});
+	});
+	app.all("/app/:name/api/*", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		if (!running.handler) return c.json({ error: `App "${name}" has no routes` }, 404);
+		return dispatch(running.handler, c.req.raw, `/app/${name}/api`);
+	});
+	app.get("/app/:name", (c) => c.redirect(`/app/${c.req.param("name")}/`));
+	app.all("/app/:name/*", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		if (c.req.method === "GET" || c.req.method === "HEAD") {
+			const file = await serveStatic(name, running.manifest, c.req.path);
+			if (file) return file;
+		}
+		if (running.handler) return dispatch(running.handler, c.req.raw, `/app/${name}`);
+		return c.json({ error: "Not found" }, 404);
+	});
+	return {
+		app,
+		scheduler,
+		async close() {
+			scheduler.stop();
+			const open = [...sessions.values()];
+			sessions.clear();
+			await Promise.all(open.map(async (p) => {
+				try {
+					await (await p).close();
+				} catch {}
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/store.ts
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch (err) {
+		if (err.code === "ENOENT") return void 0;
+		throw err;
+	}
+}
+async function writeJson(path, value) {
+	await mkdir(join(path, ".."), { recursive: true });
+	const tmp = `${path}.tmp`;
+	await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	await rename(tmp, path);
+}
+/**
+* The portable state directory ($ALASHI_HOME, default ~/.alashi).
+* Everything the host knows lives under this root so it can be moved
+* between machines as a unit.
+*/
+var Store = class {
+	root;
+	constructor(root) {
+		this.root = root ?? process.env.ALASHI_HOME ?? join(homedir(), ".alashi");
+	}
+	get configPath() {
+		return join(this.root, "config.json");
+	}
+	get appsDir() {
+		return join(this.root, "apps");
+	}
+	get registriesDir() {
+		return join(this.root, "registries");
+	}
+	get stagingDir() {
+		return join(this.root, ".staging");
+	}
+	/** Validates the name before using it in a path (traversal guard). */
+	appDir(name) {
+		if (!APP_NAME_PATTERN.test(name)) throw new AppSdkError(`Invalid app name: ${JSON.stringify(name)}`);
+		return join(this.appsDir, name);
+	}
+	appRepoDir(name) {
+		return join(this.appDir(name), "repo");
+	}
+	appDataDir(name) {
+		return join(this.appDir(name), "data");
+	}
+	appConfigPath(name) {
+		return join(this.appDir(name), "config.json");
+	}
+	appRecordPath(name) {
+		return join(this.appDir(name), "app.json");
+	}
+	appChatStatePath(name) {
+		return join(this.appDir(name), "chat.json");
+	}
+	appJobStatePath(name) {
+		return join(this.appDir(name), "jobs.json");
+	}
+	registryCachePath(name) {
+		if (!APP_NAME_PATTERN.test(name)) throw new AppSdkError(`Invalid registry name: ${JSON.stringify(name)}`);
+		return join(this.registriesDir, `${name}.json`);
+	}
+	async readGlobalConfig() {
+		return await readJson(this.configPath) ?? { registries: [] };
+	}
+	async writeGlobalConfig(config) {
+		await writeJson(this.configPath, config);
+	}
+	async readAppRecord(name) {
+		return readJson(this.appRecordPath(name));
+	}
+	async writeAppRecord(record) {
+		await writeJson(this.appRecordPath(record.name), record);
+	}
+	async readAppConfig(name) {
+		return await readJson(this.appConfigPath(name)) ?? {};
+	}
+	async writeAppConfig(name, config) {
+		await writeJson(this.appConfigPath(name), config);
+	}
+	async readChatState(name) {
+		return { conversations: (await readJson(this.appChatStatePath(name)))?.conversations ?? [] };
+	}
+	async writeChatState(name, state) {
+		await writeJson(this.appChatStatePath(name), state);
+	}
+	async readJobState(name) {
+		const state = await readJson(this.appJobStatePath(name));
+		return {
+			lastRun: state?.lastRun ?? {},
+			runs: state?.runs ?? []
+		};
+	}
+	async writeJobState(name, state) {
+		await writeJson(this.appJobStatePath(name), state);
+	}
+	async listInstalled() {
+		let entries;
+		try {
+			entries = await readdir(this.appsDir);
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			throw err;
+		}
+		const records = [];
+		for (const entry of entries.sort()) {
+			if (!APP_NAME_PATTERN.test(entry)) continue;
+			const record = await this.readAppRecord(entry);
+			if (record) records.push(record);
+		}
+		return records;
+	}
+};
+//#endregion
+export { checkSdkCompatibility as _, installApp as a, addRegistry as c, removeRegistry as d, resolveApp as f, loadApp as g, updateSource as h, resolveAppConfig as i, readCachedIndex as l, parseSourceArg as m, createServer as n, removeApp as o, fetchSource as p, buildAppContext as r, updateApp as s, Store as t, refreshRegistry as u };
+
+//# sourceMappingURL=store-CwgDCAAx.mjs.map