miko-code 0.1.0

package/src/server/update-manager.ts

@@ -0,0 +1,250 @@
+import { PACKAGE_NAME } from '../shared/branding';
+import type { UpdateInstallResult, UpdateSnapshot } from '../shared/types';
+import { compareVersions, type UpdateInstallAttemptResult } from './cli-runtime';
+
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000;
+
+export interface UpdateManagerDeps {
+	currentVersion: string;
+	fetchLatestVersion: (packageName: string) => Promise<string>;
+	installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult;
+	devMode?: boolean;
+}
+
+export class UpdateManager {
+	private readonly deps: UpdateManagerDeps;
+	private readonly listeners = new Set<(snapshot: UpdateSnapshot) => void>();
+	private snapshot: UpdateSnapshot;
+	private checkPromise: Promise<UpdateSnapshot> | null = null;
+	private installPromise: Promise<UpdateInstallResult> | null = null;
+
+	constructor(deps: UpdateManagerDeps) {
+		this.deps = deps;
+		this.snapshot = {
+			currentVersion: deps.currentVersion,
+			latestVersion: deps.devMode ? `${deps.currentVersion}-dev` : null,
+			status: deps.devMode ? 'available' : 'idle',
+			updateAvailable: Boolean(deps.devMode),
+			lastCheckedAt: deps.devMode ? Date.now() : null,
+			error: null,
+			installAction: 'restart',
+		};
+	}
+
+	getSnapshot() {
+		return this.snapshot;
+	}
+
+	onChange(listener: (snapshot: UpdateSnapshot) => void) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	async checkForUpdates(options: { force?: boolean } = {}) {
+		if (this.deps.devMode) {
+			return this.snapshot;
+		}
+
+		if (this.snapshot.status === 'updating' || this.snapshot.status === 'restart_pending') {
+			return this.snapshot;
+		}
+
+		if (this.checkPromise) {
+			return this.checkPromise;
+		}
+
+		if (
+			!options.force &&
+			this.snapshot.lastCheckedAt &&
+			Date.now() - this.snapshot.lastCheckedAt < UPDATE_CACHE_TTL_MS
+		) {
+			return this.snapshot;
+		}
+
+		this.setSnapshot({
+			...this.snapshot,
+			status: 'checking',
+			error: null,
+		});
+
+		const checkPromise = this.runCheck();
+		this.checkPromise = checkPromise;
+
+		try {
+			return await checkPromise;
+		} finally {
+			if (this.checkPromise === checkPromise) {
+				this.checkPromise = null;
+			}
+		}
+	}
+
+	async installUpdate(): Promise<UpdateInstallResult> {
+		if (this.deps.devMode) {
+			this.setSnapshot({
+				...this.snapshot,
+				status: 'updating',
+				error: null,
+			});
+
+			this.setSnapshot({
+				...this.snapshot,
+				status: 'restart_pending',
+				updateAvailable: false,
+				error: null,
+			});
+
+			return {
+				ok: true,
+				action: 'restart',
+				errorCode: null,
+				userTitle: null,
+				userMessage: null,
+			};
+		}
+
+		if (this.installPromise) {
+			return this.installPromise;
+		}
+
+		if (this.snapshot.status === 'restart_pending') {
+			return {
+				ok: true,
+				action: 'restart',
+				errorCode: null,
+				userTitle: null,
+				userMessage: null,
+			};
+		}
+
+		if (this.snapshot.status === 'updating') {
+			return {
+				ok: false,
+				action: 'restart',
+				errorCode: null,
+				userTitle: null,
+				userMessage: null,
+			};
+		}
+
+		const installPromise = this.runInstall();
+		this.installPromise = installPromise;
+
+		try {
+			return await installPromise;
+		} finally {
+			if (this.installPromise === installPromise) {
+				this.installPromise = null;
+			}
+		}
+	}
+
+	private async runCheck() {
+		try {
+			const latestVersion = await this.deps.fetchLatestVersion(PACKAGE_NAME);
+			const updateAvailable = compareVersions(this.snapshot.currentVersion, latestVersion) < 0;
+
+			const nextSnapshot: UpdateSnapshot = {
+				...this.snapshot,
+				latestVersion,
+				updateAvailable,
+				status: updateAvailable ? 'available' : 'up_to_date',
+				lastCheckedAt: Date.now(),
+				error: null,
+			};
+
+			this.setSnapshot(nextSnapshot);
+			return nextSnapshot;
+		} catch (error) {
+			const nextSnapshot: UpdateSnapshot = {
+				...this.snapshot,
+				status: 'error',
+				lastCheckedAt: Date.now(),
+				error: error instanceof Error ? error.message : String(error),
+			};
+
+			this.setSnapshot(nextSnapshot);
+			return nextSnapshot;
+		}
+	}
+
+	private async runInstall(): Promise<UpdateInstallResult> {
+		if (!this.snapshot.updateAvailable) {
+			const snapshot = await this.checkForUpdates({ force: true });
+			if (!snapshot.updateAvailable) {
+				return {
+					ok: false,
+					action: 'restart',
+					errorCode: null,
+					userTitle: null,
+					userMessage: null,
+				};
+			}
+		}
+
+		this.setSnapshot({
+			...this.snapshot,
+			status: 'updating',
+			error: null,
+		});
+
+		const targetVersion = this.snapshot.latestVersion;
+		if (!targetVersion) {
+			this.setSnapshot({
+				...this.snapshot,
+				status: 'error',
+				error: 'Unable to determine which version to install.',
+			});
+
+			return {
+				ok: false,
+				action: 'restart',
+				errorCode: 'install_failed',
+				userTitle: 'Update failed',
+				userMessage: 'Miko could not determine which version to install.',
+			};
+		}
+
+		const installed = this.deps.installVersion(PACKAGE_NAME, targetVersion);
+		if (!installed.ok) {
+			this.setSnapshot({
+				...this.snapshot,
+				status: 'error',
+				error: installed.userMessage ?? 'Unable to install the latest version.',
+			});
+
+			return {
+				ok: false,
+				action: 'restart',
+				errorCode: installed.errorCode,
+				userTitle: installed.userTitle,
+				userMessage: installed.userMessage,
+			};
+		}
+
+		this.setSnapshot({
+			...this.snapshot,
+			currentVersion: this.snapshot.latestVersion ?? this.snapshot.currentVersion,
+			status: 'restart_pending',
+			updateAvailable: false,
+			error: null,
+		});
+
+		return {
+			ok: true,
+			action: 'restart',
+			errorCode: null,
+			userTitle: null,
+			userMessage: null,
+		};
+	}
+
+	private setSnapshot(snapshot: UpdateSnapshot) {
+		this.snapshot = snapshot;
+		for (const listener of this.listeners) {
+			listener(snapshot);
+		}
+	}
+}

package/src/server/uploads.ts

@@ -0,0 +1,191 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { fileTypeFromBuffer } from 'file-type';
+import type { ChatAttachment } from '../shared/types';
+import { getWorkspaceUploadDir } from './paths';
+
+const DEFAULT_BINARY_MIME_TYPE = 'application/octet-stream';
+const IMAGE_MIME_PREFIX = 'image/';
+const TEXT_PLAIN_CONTENT_TYPE = 'text/plain; charset=utf-8';
+
+const TEXT_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+	['.csv', 'text/csv; charset=utf-8'],
+	['.json', 'application/json; charset=utf-8'],
+	['.jsonc', TEXT_PLAIN_CONTENT_TYPE],
+	['.md', 'text/markdown; charset=utf-8'],
+	['.svg', 'text/plain; charset=utf-8'],
+	['.tsv', 'text/tab-separated-values; charset=utf-8'],
+]);
+
+const IMAGE_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+	['.gif', 'image/gif'],
+	['.jpeg', 'image/jpeg'],
+	['.jpg', 'image/jpeg'],
+	['.png', 'image/png'],
+	['.webp', 'image/webp'],
+]);
+
+const TEXT_LIKE_EXTENSIONS = new Set([
+	'.c',
+	'.cc',
+	'.cfg',
+	'.conf',
+	'.cpp',
+	'.cs',
+	'.css',
+	'.env',
+	'.go',
+	'.graphql',
+	'.h',
+	'.hpp',
+	'.html',
+	'.ini',
+	'.java',
+	'.js',
+	'.jsx',
+	'.kt',
+	'.lua',
+	'.mjs',
+	'.php',
+	'.pl',
+	'.properties',
+	'.py',
+	'.rb',
+	'.rs',
+	'.scss',
+	'.sh',
+	'.sql',
+	'.swift',
+	'.toml',
+	'.ts',
+	'.tsx',
+	'.txt',
+	'.vue',
+	'.xml',
+	'.yaml',
+	'.yml',
+	'.zsh',
+]);
+
+export function sanitizeFileName(fileName: string) {
+	const baseName = path.basename(fileName).trim();
+	const cleaned = baseName.replace(/[^\w.-]+/g, '-').replace(/^-+|-+$/g, '');
+	return cleaned || 'upload';
+}
+
+export function getUploadCandidateNames(originalName: string) {
+	const sanitizedName = sanitizeFileName(originalName);
+	const parsed = path.parse(sanitizedName);
+	const extension = parsed.ext;
+	const name = parsed.name || 'upload';
+
+	return {
+		first: sanitizedName,
+		withCounter(counter: number) {
+			return `${name}-${counter}${extension}`;
+		},
+	};
+}
+
+export async function persistWorkspaceUpload(args: {
+	workspaceId: string;
+	dataDir?: string;
+	fileName: string;
+	bytes: Uint8Array;
+	fallbackMimeType?: string;
+}): Promise<ChatAttachment> {
+	const uploadDir = getWorkspaceUploadDir(args.workspaceId, args.dataDir);
+	await mkdir(uploadDir, { recursive: true });
+
+	const detectedType = await fileTypeFromBuffer(args.bytes);
+	const mimeType = detectedType?.mime ?? args.fallbackMimeType ?? DEFAULT_BINARY_MIME_TYPE;
+	const candidates = getUploadCandidateNames(args.fileName);
+
+	let storedName = candidates.first;
+	let absolutePath = path.join(uploadDir, storedName);
+	let counter = 1;
+
+	while (true) {
+		try {
+			const handle = await open(absolutePath, 'wx');
+			try {
+				await handle.writeFile(args.bytes);
+			} finally {
+				await handle.close();
+			}
+			break;
+		} catch (error) {
+			const code =
+				error instanceof Error && 'code' in error
+					? (error as NodeJS.ErrnoException).code
+					: undefined;
+			if (code !== 'EEXIST') {
+				throw error;
+			}
+
+			storedName = candidates.withCounter(counter);
+			absolutePath = path.join(uploadDir, storedName);
+			counter += 1;
+		}
+	}
+
+	return {
+		id: randomUUID(),
+		kind: mimeType.startsWith(IMAGE_MIME_PREFIX) ? 'image' : 'file',
+		displayName: args.fileName,
+		absolutePath,
+		relativePath: `miko://uploads/${args.workspaceId}/${storedName}`,
+		contentUrl: `/api/workspaces/${args.workspaceId}/uploads/${encodeURIComponent(storedName)}/content`,
+		mimeType,
+		size: args.bytes.byteLength,
+	};
+}
+
+export function inferAttachmentContentType(fileName: string, fallbackType?: string): string {
+	const extension = path.extname(fileName).toLowerCase();
+	const mappedType = TEXT_CONTENT_TYPE_BY_EXTENSION.get(extension);
+	if (mappedType) {
+		return mappedType;
+	}
+
+	const mappedImageType = IMAGE_CONTENT_TYPE_BY_EXTENSION.get(extension);
+	if (mappedImageType) {
+		return mappedImageType;
+	}
+
+	if (TEXT_LIKE_EXTENSIONS.has(extension)) {
+		return TEXT_PLAIN_CONTENT_TYPE;
+	}
+
+	return fallbackType || DEFAULT_BINARY_MIME_TYPE;
+}
+
+export function inferWorkspaceFileContentType(fileName: string, fallbackType?: string): string {
+	return inferAttachmentContentType(fileName, fallbackType);
+}
+
+export async function deleteWorkspaceUpload(args: {
+	workspaceId: string;
+	dataDir?: string;
+	storedName: string;
+}): Promise<boolean> {
+	const storedName = args.storedName;
+	if (
+		!storedName ||
+		storedName.includes('/') ||
+		storedName.includes('\\') ||
+		storedName === '.' ||
+		storedName === '..'
+	) {
+		return false;
+	}
+
+	const absolutePath = path.join(getWorkspaceUploadDir(args.workspaceId, args.dataDir), storedName);
+	try {
+		await rm(absolutePath, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/server/workspace-file-search.ts

@@ -0,0 +1,191 @@
+import path from 'node:path';
+
+import type { WorkspaceFileSearchResult } from 'src/shared/types';
+import { runGit } from './diff-store';
+
+const DEFAULT_FILE_SEARCH_LIMIT = 20;
+const MAX_FILE_SEARCH_LIMIT = 50;
+const DEFAULT_FILE_LIST_LIMIT = 2_000;
+const MAX_FILE_LIST_LIMIT = 5_000;
+const FILE_LIST_CACHE_TTL_MS = 15_000;
+const MAX_FILE_LIST_CACHE_ENTRIES = 50;
+
+interface FileListCacheEntry {
+	expiresAt: number;
+	paths: string[];
+	pending?: Promise<string[]>;
+}
+
+const fileListCacheByWorkspacePath = new Map<string, FileListCacheEntry>();
+
+function pruneWorkspaceFileListCache(now = Date.now()) {
+	for (const [workspacePath, entry] of fileListCacheByWorkspacePath.entries()) {
+		if (!entry.pending && entry.expiresAt <= now)
+			fileListCacheByWorkspacePath.delete(workspacePath);
+	}
+
+	while (fileListCacheByWorkspacePath.size > MAX_FILE_LIST_CACHE_ENTRIES) {
+		let oldestWorkspacePath: string | null = null;
+		let oldestExpiresAt = Number.POSITIVE_INFINITY;
+
+		for (const [workspacePath, entry] of fileListCacheByWorkspacePath.entries()) {
+			if (entry.pending) continue;
+			if (entry.expiresAt >= oldestExpiresAt) continue;
+			oldestWorkspacePath = workspacePath;
+			oldestExpiresAt = entry.expiresAt;
+		}
+
+		if (!oldestWorkspacePath) return;
+		fileListCacheByWorkspacePath.delete(oldestWorkspacePath);
+	}
+}
+
+function normalizeFilePath(filePath: string) {
+	return filePath.replace(/\\/g, '/').trim();
+}
+
+function normalizeQuery(query: string) {
+	return query.trim().toLowerCase();
+}
+
+function resultName(relativePath: string) {
+	return path.posix.basename(relativePath);
+}
+
+function scorePath(relativePath: string, query: string) {
+	if (!query) return 0;
+
+	const normalizedPath = relativePath.toLowerCase();
+	const name = resultName(normalizedPath);
+
+	if (name === query) return 0;
+	if (name.startsWith(query)) return 10;
+	if (normalizedPath.startsWith(query)) return 20;
+
+	const segmentStartIndex = normalizedPath.indexOf(`/${query}`);
+	if (segmentStartIndex !== -1) return 30 + segmentStartIndex;
+
+	const nameIndex = name.indexOf(query);
+	if (nameIndex !== -1) return 40 + nameIndex;
+
+	const pathIndex = normalizedPath.indexOf(query);
+	if (pathIndex !== -1) return 60 + pathIndex;
+
+	return null;
+}
+
+function uniqueFilePaths(stdout: string) {
+	const seen = new Set<string>();
+	const paths: string[] = [];
+
+	for (const line of stdout.split(/\r?\n/u)) {
+		const relativePath = normalizeFilePath(line);
+		if (!relativePath || seen.has(relativePath)) continue;
+		seen.add(relativePath);
+		paths.push(relativePath);
+	}
+
+	return paths;
+}
+
+async function loadWorkspaceFileList(workspacePath: string) {
+	const result = await runGit(['ls-files', '-co', '--exclude-standard'], workspacePath);
+
+	if (result.exitCode !== 0) {
+		const detail = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join('\n');
+		throw new Error(detail || 'Unable to search workspace files');
+	}
+
+	return uniqueFilePaths(result.stdout);
+}
+
+async function getWorkspaceFileList(workspacePath: string) {
+	const now = Date.now();
+	pruneWorkspaceFileListCache(now);
+	const cached = fileListCacheByWorkspacePath.get(workspacePath);
+	if (cached && !cached.pending && cached.expiresAt > now) return cached.paths;
+	if (cached?.pending) return cached.pending;
+
+	const pending = loadWorkspaceFileList(workspacePath)
+		.then((paths) => {
+			const current = fileListCacheByWorkspacePath.get(workspacePath);
+			if (current?.pending === pending) {
+				fileListCacheByWorkspacePath.set(workspacePath, {
+					paths,
+					expiresAt: Date.now() + FILE_LIST_CACHE_TTL_MS,
+				});
+				pruneWorkspaceFileListCache();
+			}
+			return paths;
+		})
+		.catch((error) => {
+			const current = fileListCacheByWorkspacePath.get(workspacePath);
+			if (current?.pending === pending) fileListCacheByWorkspacePath.delete(workspacePath);
+			throw error;
+		});
+
+	fileListCacheByWorkspacePath.set(workspacePath, {
+		paths: cached?.paths ?? [],
+		expiresAt: cached?.expiresAt ?? 0,
+		pending,
+	});
+
+	return pending;
+}
+
+export function clearWorkspaceFileSearchCache(workspacePath?: string) {
+	if (workspacePath) {
+		fileListCacheByWorkspacePath.delete(workspacePath);
+		return;
+	}
+	fileListCacheByWorkspacePath.clear();
+}
+
+export async function listWorkspaceFiles(
+	workspacePath: string,
+	limit = DEFAULT_FILE_LIST_LIMIT,
+): Promise<WorkspaceFileSearchResult[]> {
+	const requestedLimit = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_FILE_LIST_LIMIT;
+	const safeLimit = Math.max(1, Math.min(requestedLimit, MAX_FILE_LIST_LIMIT));
+	const filePaths = await getWorkspaceFileList(workspacePath);
+
+	return filePaths
+		.toSorted((left, right) => left.localeCompare(right))
+		.slice(0, safeLimit)
+		.map((relativePath) => ({
+			id: relativePath,
+			name: resultName(relativePath),
+			relativePath,
+		}));
+}
+
+export async function searchWorkspaceFiles(
+	workspacePath: string,
+	query: string,
+	limit = DEFAULT_FILE_SEARCH_LIMIT,
+): Promise<WorkspaceFileSearchResult[]> {
+	const normalizedQuery = normalizeQuery(query);
+	const requestedLimit = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_FILE_SEARCH_LIMIT;
+	const safeLimit = Math.max(1, Math.min(requestedLimit, MAX_FILE_SEARCH_LIMIT));
+	const filePaths = await getWorkspaceFileList(workspacePath);
+
+	return filePaths
+		.map((relativePath) => {
+			const score = scorePath(relativePath, normalizedQuery);
+			return score === null ? null : { relativePath, score };
+		})
+		.filter((entry): entry is { relativePath: string; score: number } => entry !== null)
+		.sort((left, right) => {
+			if (left.score !== right.score) return left.score - right.score;
+			if (left.relativePath.length !== right.relativePath.length) {
+				return left.relativePath.length - right.relativePath.length;
+			}
+			return left.relativePath.localeCompare(right.relativePath);
+		})
+		.slice(0, safeLimit)
+		.map(({ relativePath }) => ({
+			id: relativePath,
+			name: resultName(relativePath),
+			relativePath,
+		}));
+}