codebay 0.9.1 → 0.10.1

package/src/lib/log-capture.server.ts

@@ -0,0 +1,262 @@
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	statSync,
+	writeFileSync
+} from 'node:fs';
+import { join } from 'node:path';
+import { LOGS_DIR } from './config.server.ts';
+import { getInstance, type InstanceRow } from './db.server.ts';
+import { isRunning } from './docker.server.ts';
+import { execInContainer } from './exec.server.ts';
+
+/** Delta pulls are cheap, so a lazier cadence than the 5s health probe is plenty. */
+const CAPTURE_MS = 10_000;
+
+const MANIFEST_MARKER = '__CODEBAY_MANIFEST__';
+const FETCH_MARKER = '__CODEBAY_FETCH__';
+const FILE_MARKER = '__CODEBAY_FILE__';
+const END_MARKER = '__CODEBAY_END__';
+
+export interface ManifestEntry {
+	path: string;
+	size: number;
+}
+
+interface FetchJob {
+	path: string;
+	hostFileName: string;
+	/** 1-indexed byte to `tail -c +N` from; 1 re-pulls the whole file. */
+	startByte: number;
+	mode: 'append' | 'rollover';
+}
+
+/**
+ * Lists the transcript + history files with their byte sizes. `find`/`wc -c` (not GNU `-printf`)
+ * so it works on busybox containers too; the marker line lets the parser skip login-shell noise.
+ */
+function manifestScript(): string {
+	return (
+		`h=$(eval echo ~$(id -un)); cfg="\${CLAUDE_CONFIG_DIR:-$h/.claude}"; ` +
+		`printf '%s\\n' '${MANIFEST_MARKER}'; ` +
+		`{ find "$cfg" -maxdepth 1 -type f -name 'history.jsonl' 2>/dev/null; ` +
+		`find "$cfg/projects" -type f -name '*.jsonl' 2>/dev/null; } | ` +
+		`while IFS= read -r f; do printf '%s\\t%s\\n' "$f" "$(wc -c < "$f" | tr -d ' ')"; done; true`
+	);
+}
+
+/** Emits, per requested file, a framed block of base64 bytes from `startByte` to EOF. */
+function fetchScript(): string {
+	return (
+		`printf '%s\\n' '${FETCH_MARKER}'; ` +
+		`while [ "$#" -ge 2 ]; do p="$1"; o="$2"; shift 2; ` +
+		`printf '${FILE_MARKER}\\t%s\\n' "$p"; ` +
+		`tail -c "+$o" "$p" 2>/dev/null | base64; ` +
+		`printf '\\n${END_MARKER}\\n'; done`
+	);
+}
+
+export function parseManifest(stdout: string): ManifestEntry[] {
+	const at = stdout.indexOf(MANIFEST_MARKER);
+	if (at === -1) return [];
+	const out: ManifestEntry[] = [];
+	for (const line of stdout.slice(at + MANIFEST_MARKER.length).split('\n')) {
+		const tab = line.indexOf('\t');
+		if (tab === -1) continue;
+		const path = line.slice(0, tab);
+		const size = Number(line.slice(tab + 1).trim());
+		if (path && Number.isFinite(size)) out.push({ path, size });
+	}
+	return out;
+}
+
+/** A `/projects/` path is a session transcript; the only other file we list is `history.jsonl`. */
+export function hostFileNameFor(instanceId: string, containerPath: string): string {
+	const base = containerPath.split('/').pop() ?? containerPath;
+	if (containerPath.includes('/projects/')) {
+		return `transcript-${instanceId}-${base.replace(/\.jsonl$/, '')}.jsonl`;
+	}
+	return `history-${instanceId}.jsonl`;
+}
+
+/** Diffs container sizes against the host mirrors: append new bytes, or re-pull a file that shrank. */
+export function planFetch(
+	instanceId: string,
+	manifest: ManifestEntry[],
+	hostSize: (hostFileName: string) => number
+): FetchJob[] {
+	const jobs: FetchJob[] = [];
+	for (const { path, size } of manifest) {
+		const hostFileName = hostFileNameFor(instanceId, path);
+		const existing = hostSize(hostFileName);
+		if (size === existing) continue;
+		if (size < existing) jobs.push({ path, hostFileName, startByte: 1, mode: 'rollover' });
+		else jobs.push({ path, hostFileName, startByte: existing + 1, mode: 'append' });
+	}
+	return jobs;
+}
+
+export function parseFetchBlocks(stdout: string): { path: string; base64: string }[] {
+	const at = stdout.indexOf(FETCH_MARKER);
+	if (at === -1) return [];
+	const blocks: { path: string; base64: string }[] = [];
+	for (const part of stdout
+		.slice(at + FETCH_MARKER.length)
+		.split(FILE_MARKER)
+		.slice(1)) {
+		const end = part.indexOf(END_MARKER);
+		const seg = end === -1 ? part : part.slice(0, end);
+		const nl = seg.indexOf('\n');
+		if (nl === -1) continue;
+		const path = seg.slice(0, nl).replace(/^\t/, '');
+		// base64 wrapping (GNU wraps at 76 cols) is stripped so multi-line blocks decode cleanly.
+		blocks.push({ path, base64: seg.slice(nl + 1).replace(/\s+/g, '') });
+	}
+	return blocks;
+}
+
+function sizeOnDisk(path: string): number {
+	try {
+		return statSync(path).size;
+	} catch {
+		return 0;
+	}
+}
+
+/**
+ * A rebuild recreates the container (`--remove-existing-container`), so its `~/.claude` starts empty
+ * and the next manifest reports a file smaller than our mirror. Archiving the mirror aside — rather
+ * than overwriting it with the new container's few hundred bytes — is what makes retention real.
+ */
+function rollOver(dest: string): void {
+	if (!existsSync(dest)) return;
+	const dot = dest.lastIndexOf('.');
+	const stem = dot === -1 ? dest : dest.slice(0, dot);
+	const ext = dot === -1 ? '' : dest.slice(dot);
+	for (let n = 1; ; n++) {
+		const archive = `${stem}.${n}${ext}`;
+		if (existsSync(archive)) continue;
+		renameSync(dest, archive);
+		return;
+	}
+}
+
+/** Keeps `index.json` mapping the opaque UUID filenames back to a human-readable instance. */
+function updateIndex(logsDir: string, row: InstanceRow): void {
+	const indexPath = join(logsDir, 'index.json');
+	let index: Record<string, unknown> = {};
+	try {
+		const parsed = JSON.parse(readFileSync(indexPath, 'utf8'));
+		if (parsed && typeof parsed === 'object') index = parsed as Record<string, unknown>;
+	} catch {
+		// Absent or corrupt — start fresh rather than lose this pass.
+	}
+	index[row.id] = {
+		name: row.name,
+		source_path: row.source_path,
+		created_at: row.created_at,
+		last_captured: Date.now()
+	};
+	writeFileSync(indexPath, JSON.stringify(index, null, 2));
+}
+
+interface CaptureDeps {
+	exec?: typeof execInContainer;
+	logsDir?: string;
+}
+
+/**
+ * One extraction pass: manifest → plan deltas → fetch → append/roll over host mirrors → index.
+ * Resolves false when the container could not be read, which is how `tick` detects a dead chain.
+ */
+export async function runCapturePass(row: InstanceRow, deps: CaptureDeps = {}): Promise<boolean> {
+	if (!row.container_id) return false;
+	const exec = deps.exec ?? execInContainer;
+	const logsDir = deps.logsDir ?? LOGS_DIR;
+	const target = { containerId: row.container_id, remoteUser: row.remote_user };
+
+	const manifestRes = await exec(target, { script: manifestScript(), capture: true });
+	if (!manifestRes.ok) return false;
+	const manifest = parseManifest(manifestRes.stdout);
+
+	mkdirSync(logsDir, { recursive: true });
+	const jobs = planFetch(row.id, manifest, (name) => sizeOnDisk(join(logsDir, name)));
+
+	if (jobs.length) {
+		const args = ['fetch'];
+		for (const j of jobs) args.push(j.path, String(j.startByte));
+		const fetchRes = await exec(target, { script: fetchScript(), args, capture: true });
+		if (fetchRes.ok) {
+			const byPath = new Map(jobs.map((j) => [j.path, j]));
+			for (const block of parseFetchBlocks(fetchRes.stdout)) {
+				const job = byPath.get(block.path);
+				if (!job) continue;
+				const bytes = Buffer.from(block.base64, 'base64');
+				const dest = join(logsDir, job.hostFileName);
+				if (job.mode === 'rollover') rollOver(dest);
+				appendFileSync(dest, bytes);
+			}
+		}
+	}
+	updateIndex(logsDir, row);
+	return true;
+}
+
+interface Capture {
+	timer: ReturnType<typeof setTimeout>;
+}
+
+// Pinned to globalThis so dev-mode hot reload doesn't orphan the interval timers.
+const globalForCapture = globalThis as unknown as { __codebayLogCapture?: Map<string, Capture> };
+const captures: Map<string, Capture> = (globalForCapture.__codebayLogCapture ??= new Map());
+
+async function tick(id: string, cap: Capture): Promise<void> {
+	// Re-read every tick: a rename has to reach index.json, and a stale container_id would exec
+	// against a container that no longer exists.
+	const row = getInstance(id);
+	// Best-effort: a failed pass (container just stopped, transient exec error) must not kill the loop.
+	const ok = row ? await runCapturePass(row).catch(() => false) : false;
+	// syncLogCapture would normally stop us, but it only runs from the reconcile loop, which is idle
+	// whenever no client is connected — so a container that died on its own has to end the chain here.
+	const alive =
+		ok || (!!row?.container_id && (await isRunning(row.container_id).catch(() => false)));
+	// Stopped or replaced while the pass was in flight — rescheduling would leak a second chain.
+	if (captures.get(id) !== cap) return;
+	if (!alive) {
+		stopLogCapture(id);
+		return;
+	}
+	cap.timer = setTimeout(() => void tick(id, cap), CAPTURE_MS);
+}
+
+function startLogCapture(id: string): void {
+	if (captures.has(id)) return;
+	const cap: Capture = { timer: setTimeout(() => undefined, 0) };
+	captures.set(id, cap);
+	// Seed a pass now so a short-lived session is captured without waiting a full interval.
+	void tick(id, cap);
+}
+
+/** Stops the timer only — the mirrored logs are retained on disk past instance deletion. */
+export function stopLogCapture(id: string): void {
+	const cap = captures.get(id);
+	if (!cap) return;
+	clearTimeout(cap.timer);
+	captures.delete(id);
+}
+
+/** Driven from the reconcile loop, so capture tracks the container lifecycle automatically. */
+export function syncLogCapture(rows: InstanceRow[]): void {
+	const running = new Set(
+		rows.filter((r) => r.status === 'running' && r.container_id).map((r) => r.id)
+	);
+	for (const row of rows) {
+		if (running.has(row.id) && !captures.has(row.id)) startLogCapture(row.id);
+	}
+	for (const id of [...captures.keys()]) {
+		if (!running.has(id)) stopLogCapture(id);
+	}
+}

package/src/lib/ports.server.ts

@@ -7,3 +7,34 @@ export function pickFreePort(usedSets: ReadonlySet<number>[]): number {
 	}
 	throw new Error('No free host ports available.');
 }
+
+/**
+ * A listener outside Docker's view is invisible to the DB/Docker union — and on a VM-backed daemon
+ * the collision never surfaces as an error, because the `-p` bind happens inside the VM where the
+ * port is free while the host-side forward fails (colima logs that as a warning). Claiming the port
+ * ourselves first is the only way the collision reaches us.
+ */
+export async function isHostPortBindable(port: number): Promise<boolean> {
+	try {
+		// Loopback specifically: it's where code-server is always published, and a wildcard squatter
+		// blocks this bind too, so the one probe covers both.
+		const server = Bun.listen({ hostname: '127.0.0.1', port, socket: { data() {} } });
+		server.stop(true);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/** Takes the probe as a parameter so the scan is testable without binding real sockets. */
+export async function pickBindablePort(
+	usedSets: ReadonlySet<number>[],
+	isBindable: (port: number) => Promise<boolean>
+): Promise<number> {
+	const rejected = new Set<number>();
+	for (;;) {
+		const port = pickFreePort([...usedSets, rejected]);
+		if (await isBindable(port)) return port;
+		rejected.add(port);
+	}
+}

package/src/lib/proxy.server.ts

@@ -74,10 +74,10 @@ async function proxyHttp(event: MochiApiEvent, port: number, rest: string): Prom
 			duplex: 'half'
 		});
 	} catch (err) {
-		// Usually just code-server not having bound its port yet; letting it escape would
+		// Usually just the served surface not having bound its port yet; letting it escape would
 		// render a 500 stack trace inside the IDE iframe.
 		console.warn(`[proxy] upstream 127.0.0.1:${port}${rest} unreachable:`, (err as Error).message);
-		return new Response('code-server is not accepting connections yet', {
+		return new Response('The instance is not accepting connections yet', {
 			status: 503,
 			headers: { 'retry-after': '1', 'cache-control': 'no-store' }
 		});

package/src/pages/Settings.svelte

@@ -3,11 +3,13 @@
 	import '@fontsource-variable/jetbrains-mono';
 	import SettingsView from '../components/SettingsView.svelte';
 	import type { AvatarArt } from '../avatars/index.ts';
-	import type { InstanceMode } from '../types.ts';
+	import type { ClaudeEffortLevel, ClaudePermissionMode, InstanceMode } from '../types.ts';
 
 	let {
 		pet,
 		defaultMode,
+		claudePermissionMode,
+		claudeEffortLevel,
 		defaultImage,
 		builtinImage,
 		disableBuildCache,
@@ -37,10 +39,17 @@
 		hostEnvVarsEnabled,
 		hostEnvVarNames,
 		hostEnvVarPresence,
+		customEnvVarsEnabled,
+		customEnvVarNames,
+		advancedSerialInjections,
+		advancedNoBuildkit,
+		advancedBlockingExtInstall,
 		version
 	}: {
 		pet?: AvatarArt;
 		defaultMode: InstanceMode;
+		claudePermissionMode: ClaudePermissionMode;
+		claudeEffortLevel: ClaudeEffortLevel;
 		defaultImage: string;
 		builtinImage: string;
 		disableBuildCache: boolean;
@@ -70,6 +79,11 @@
 		hostEnvVarsEnabled: boolean;
 		hostEnvVarNames: string[];
 		hostEnvVarPresence: Record<string, boolean>;
+		customEnvVarsEnabled: boolean;
+		customEnvVarNames: string[];
+		advancedSerialInjections: boolean;
+		advancedNoBuildkit: boolean;
+		advancedBlockingExtInstall: boolean;
 		version: string;
 	} = $props();
 </script>
@@ -77,6 +91,8 @@
 <SettingsView
 	{pet}
 	{defaultMode}
+	{claudePermissionMode}
+	{claudeEffortLevel}
 	{defaultImage}
 	{builtinImage}
 	{disableBuildCache}
@@ -106,6 +122,11 @@
 	{hostEnvVarsEnabled}
 	{hostEnvVarNames}
 	{hostEnvVarPresence}
+	{customEnvVarsEnabled}
+	{customEnvVarNames}
+	{advancedSerialInjections}
+	{advancedNoBuildkit}
+	{advancedBlockingExtInstall}
 	{version}
 	mochi:hydrate
 />

package/src/routes.ts

@@ -19,7 +19,14 @@ import {
 	DEFAULT_SONNET_MODEL
 } from './container-injections/claude-code-custom.ts';
 import { hostEnvVarPresence, parseHostEnvVarNames } from './container-injections/host-env-vars.ts';
+import { parseCustomEnvVars } from './container-injections/custom-env-vars.ts';
 import { gitIdentityEnabled } from './container-injections/git-identity.ts';
+import {
+	LATEST_CHECKED_AT_KEY,
+	LATEST_VERSION_KEY
+} from './container-injections/claude-code-update.ts';
+import { getClaudePermissionMode } from './container-injections/claude-permission-mode.ts';
+import { getClaudeEffortLevel } from './container-injections/claude-effort-level.ts';
 import { browse } from './lib/picker.server.ts';
 import { pickNamePrompt } from './avatars/name-prompts.ts';
 import { avatars, findAvatar } from './avatars/index.ts';
@@ -44,7 +51,8 @@ import {
 	stopInstance,
 	streamClose,
 	streamOpen,
-	subscribeLogs
+	subscribeLogs,
+	invalidateSecretValues
 } from './lib/instances.server.ts';
 import {
 	deleteFolderHistory,
@@ -58,7 +66,13 @@ import { wsUpgradeAllowed } from './lib/auth.server.ts';
 import { clearAttention, setAttention } from './lib/bridge.server.ts';
 import { timingSafeEqualStr } from './lib/crypto.server.ts';
 import { proxyRoutes } from './lib/proxy.server.ts';
-import { isInstanceFilter, normalizeMode, type InstanceFilter } from './types.ts';
+import {
+	isInstanceFilter,
+	normalizeMode,
+	normalizePermissionMode,
+	normalizeEffortLevel,
+	type InstanceFilter
+} from './types.ts';
 
 async function preflight() {
 	const [docker, cli, auth] = await Promise.all([
@@ -187,6 +201,8 @@ export const routes: Record<string, MochiRouteValue> = {
 			return {
 				pet: currentPet(),
 				defaultMode: getDefaultMode(),
+				claudePermissionMode: getClaudePermissionMode(),
+				claudeEffortLevel: getClaudeEffortLevel(),
 				defaultImage: getOption('default_image') ?? DEFAULT_IMAGE,
 				builtinImage: DEFAULT_IMAGE,
 				disableBuildCache: getOption('disable_build_cache') === '1',
@@ -227,6 +243,12 @@ export const routes: Record<string, MochiRouteValue> = {
 				hostEnvVarsEnabled: getOption('host_env_vars_enabled') === '1',
 				hostEnvVarNames,
 				hostEnvVarPresence: hostEnvVarPresence(hostEnvVarNames),
+				// Freeform secrets: only the names round-trip; the values never leave the server.
+				customEnvVarsEnabled: getOption('custom_env_vars_enabled') === '1',
+				customEnvVarNames: parseCustomEnvVars(getOption('custom_env_vars')).map((v) => v.name),
+				advancedSerialInjections: getOption('advanced_serial_injections') === '1',
+				advancedNoBuildkit: getOption('advanced_no_buildkit') === '1',
+				advancedBlockingExtInstall: getOption('advanced_blocking_ext_install') === '1',
 				version: APP_VERSION
 			};
 		},
@@ -239,6 +261,20 @@ export const routes: Record<string, MochiRouteValue> = {
 				return success({ mode });
 			},
 
+			// Baked into the container launcher at provision time, so it lands on create/rebuild.
+			claudePermissionMode: ({ formData }) => {
+				const mode = normalizePermissionMode(str(formData, 'mode'));
+				setOption('claude_permission_mode', mode);
+				return success({ mode });
+			},
+
+			// Injected into ~/.claude/settings.json at provision time, so it lands on create/rebuild.
+			claudeEffortLevel: ({ formData }) => {
+				const level = normalizeEffortLevel(str(formData, 'level'));
+				setOption('claude_effort_level', level);
+				return success({ level });
+			},
+
 			// Persist the default container image used when a source folder ships no devcontainer.json.
 			defaultImage: ({ formData }) => {
 				const image = str(formData, 'image');
@@ -384,11 +420,71 @@ export const routes: Record<string, MochiRouteValue> = {
 				return success({ presence: hostEnvVarPresence(saved) });
 			},
 
+			// Freeform name=value secrets injected into every container via containerEnv. Values are
+			// stored plaintext in the options table (like the tokens above) and never sent to the client.
+			customEnvVarsToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setOption('custom_env_vars_enabled', enabled ? '1' : '0');
+				// The redaction set only masks while enabled, so it must be rebuilt on either flip.
+				invalidateSecretValues();
+				return success({ enabled });
+			},
+			// Upsert one var: the client only ever sends the single var it's changing, since it never
+			// holds the other secrets to resubmit (unlike host-env's whole-list-replace).
+			setCustomEnvVar: ({ formData }) => {
+				const name = str(formData, 'name');
+				const value = str(formData, 'value');
+				if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+					return fail(400, { error: `invalid variable name: ${name || '(empty)'}` });
+				}
+				if (!value) return fail(400, { error: 'value is required' });
+				const vars = parseCustomEnvVars(getOption('custom_env_vars')).filter(
+					(v) => v.name !== name
+				);
+				vars.push({ name, value });
+				setOption('custom_env_vars', JSON.stringify(vars));
+				invalidateSecretValues();
+				return success({ names: vars.map((v) => v.name) });
+			},
+			removeCustomEnvVar: ({ formData }) => {
+				const name = str(formData, 'name');
+				const vars = parseCustomEnvVars(getOption('custom_env_vars')).filter(
+					(v) => v.name !== name
+				);
+				setOption('custom_env_vars', JSON.stringify(vars));
+				invalidateSecretValues();
+				return success({ names: vars.map((v) => v.name) });
+			},
+
 			clearBuildCache: async () => {
 				const { spaceReclaimed } = await pruneBuildCache();
 				return success({ spaceReclaimed: spaceReclaimed ?? 0 });
 			},
 
+			serialInjectionsToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setOption('advanced_serial_injections', enabled ? '1' : '0');
+				return success({ enabled });
+			},
+
+			noBuildkitToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setOption('advanced_no_buildkit', enabled ? '1' : '0');
+				return success({ enabled });
+			},
+
+			blockingExtInstallToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setOption('advanced_blocking_ext_install', enabled ? '1' : '0');
+				return success({ enabled });
+			},
+
+			clearVersionCache: () => {
+				setOption(LATEST_VERSION_KEY, '');
+				setOption(LATEST_CHECKED_AT_KEY, '');
+				return success({});
+			},
+
 			rebuildAllNoCache: () => success({ count: rebuildRunningInstancesNoCache() }),
 
 			// The process exits mid-flight, so the client may see success or a dropped

package/src/types.ts

@@ -19,6 +19,8 @@ export interface Instance {
 	created_at: number;
 	/** `'local'` when the folder shipped its own config; null until provisioned. */
 	image_source: string | null;
+	/** Sprite name chosen collision-free at creation; null pre-dates this and falls back to the id hash. */
+	avatar: string | null;
 	/** `'ide'` serves full code-server; `'terminal'` serves only ttyd + Claude Code. */
 	mode: InstanceMode;
 	/** Terminal mode only: 1 when the scratch-shell pane was left open, so a reload restores it. */
@@ -37,6 +39,40 @@ export function normalizeMode(value: unknown): InstanceMode {
 	return value === 'terminal' ? 'terminal' : 'ide';
 }
 
+/** The permission mode Claude Code starts in. `'default'` keeps the historical bypass behaviour. */
+export type ClaudePermissionMode = 'default' | 'manual' | 'auto' | 'plan';
+
+export const CLAUDE_PERMISSION_MODES: ClaudePermissionMode[] = [
+	'default',
+	'manual',
+	'auto',
+	'plan'
+];
+
+/** Anything unrecognised falls back to the historical behaviour. */
+export function normalizePermissionMode(value: unknown): ClaudePermissionMode {
+	return CLAUDE_PERMISSION_MODES.includes(value as ClaudePermissionMode)
+		? (value as ClaudePermissionMode)
+		: 'default';
+}
+
+/** The flags every managed `claude` invocation carries — the launchers and the shell alias share them. */
+export function claudePermissionFlags(mode: ClaudePermissionMode): string {
+	return mode === 'default' ? '--dangerously-skip-permissions' : `--permission-mode ${mode}`;
+}
+
+/** Claude Code's default reasoning-effort level for new sessions, written to `settings.json`. */
+export type ClaudeEffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+export const CLAUDE_EFFORT_LEVELS: ClaudeEffortLevel[] = ['low', 'medium', 'high', 'xhigh', 'max'];
+
+/** Anything unrecognised falls back to the balanced default. */
+export function normalizeEffortLevel(value: unknown): ClaudeEffortLevel {
+	return CLAUDE_EFFORT_LEVELS.includes(value as ClaudeEffortLevel)
+		? (value as ClaudeEffortLevel)
+		: 'high';
+}
+
 /** Dashboard run-state view filter: All | Active (running/creating) | Stopped (stopped/error). */
 export type InstanceFilter = 'all' | 'active' | 'stopped';
 

package/.mochi/svelte-client/HydratableIsland-k6q8esj4.js

@@ -1 +0,0 @@
-import{cb as a}from"/_mochi/client/chunk-v65n8th6.js";import"/_mochi/client/chunk-rs41by6w.js";export{a as registerComponent};