miko-code 0.1.0

package/src/server/read-models.ts

@@ -0,0 +1,311 @@
+import type {
+	DirectoryListSnapshot,
+	MikoStatus,
+	PendingToolSnapshot,
+	QueuedMessageSnapshot,
+	SessionRuntime,
+	SessionSnapshot,
+	SidebarDirectoryGroup,
+	SidebarSnapshot,
+	SidebarWorkspaceRow,
+	WorkspaceGitHubSnapshot,
+	WorkspaceGitSnapshot,
+	WorkspaceHealthState,
+	WorkspaceSidebarIndicator,
+	WorkspaceSnapshot,
+} from 'src/shared/types';
+import type { SessionRecord, StoreState, WorkspaceRecord } from './event';
+import { SERVER_PROVIDERS } from './provider-catalog';
+
+export function deriveStatus(session: SessionRecord, activeStatus?: MikoStatus): MikoStatus {
+	if (activeStatus) return activeStatus;
+	if (session.lastTurnOutcome === 'failed') return 'failed';
+	return 'idle';
+}
+
+function getSessionActivityTimestamp(session: SessionRecord) {
+	return session.lastMessageAt ?? session.updatedAt;
+}
+
+function getWorkspaceLastActivityAt(state: StoreState, workspace: WorkspaceRecord) {
+	return [...state.sessionsById.values()].reduce((latest, session) => {
+		if (session.workspaceId !== workspace.id || session.removedAt) return latest;
+		return Math.max(latest, getSessionActivityTimestamp(session));
+	}, workspace.updatedAt);
+}
+
+function getWorkspaceLatestSession(state: StoreState, workspace: WorkspaceRecord) {
+	return [...state.sessionsById.values()]
+		.filter((session) => session.workspaceId === workspace.id && !session.removedAt)
+		.toSorted((a, b) => getSessionActivityTimestamp(b) - getSessionActivityTimestamp(a))[0];
+}
+
+function hasPrDiffStats(github: WorkspaceGitHubSnapshot | null | undefined) {
+	return typeof github?.additions === 'number' || typeof github?.deletions === 'number';
+}
+
+function getWorkspaceDiffStats(
+	git: WorkspaceGitSnapshot | null | undefined,
+	github: WorkspaceGitHubSnapshot | null | undefined,
+) {
+	if (
+		(github?.status === 'open' || github?.status === 'merged' || github?.status === 'closed') &&
+		hasPrDiffStats(github)
+	) {
+		return {
+			additions: github.additions ?? 0,
+			deletions: github.deletions ?? 0,
+		};
+	}
+
+	return (git?.files ?? []).reduce(
+		(stats, file) => ({
+			additions: stats.additions + file.additions,
+			deletions: stats.deletions + file.deletions,
+		}),
+		{ additions: 0, deletions: 0 },
+	);
+}
+
+function getWorkspaceDisplayName(
+	workspace: WorkspaceRecord,
+	github: WorkspaceGitHubSnapshot | null | undefined,
+) {
+	return getWorkspacePrTitle(workspace, github) ?? workspace.branchName;
+}
+
+function getWorkspacePrTitle(
+	workspace: WorkspaceRecord,
+	github: WorkspaceGitHubSnapshot | null | undefined,
+) {
+	return github?.status !== 'none' && github?.title ? github.title : workspace.pullRequest?.title;
+}
+
+function workspaceHasPullRequest(workspace: WorkspaceRecord) {
+	return Boolean(
+		workspace.pullRequest ||
+			workspace.reviewState === 'in_review' ||
+			workspace.reviewState === 'done' ||
+			workspace.reviewState === 'closed',
+	);
+}
+
+function getWorkspaceSidebarIndicator(args: {
+	workspace: WorkspaceRecord;
+	hasActiveSession: boolean;
+	git?: WorkspaceGitSnapshot | null;
+	github?: WorkspaceGitHubSnapshot | null;
+}): WorkspaceSidebarIndicator {
+	const { workspace, hasActiveSession, git, github } = args;
+
+	if (workspace.setupState === 'creating') return 'workspace_creating';
+	if (workspace.setupState === 'failed') return 'workspace_failed';
+	if (hasActiveSession) return 'agent_active';
+	if (workspace.reviewState === 'done' || workspace.pullRequest?.status === 'merged')
+		return 'merged';
+	if (workspace.reviewState === 'closed' || workspace.pullRequest?.status === 'closed')
+		return 'closed';
+	const hasOpenPr =
+		workspace.reviewState === 'in_review' || workspace.pullRequest?.status === 'open';
+	if (hasOpenPr && (github?.hasMergeConflicts || workspace.pullRequest?.hasMergeConflicts)) {
+		return 'merge_conflicts';
+	}
+	if (hasOpenPr && (github?.isDraft || workspace.pullRequest?.isDraft)) {
+		return 'draft_pr';
+	}
+	if (github?.ciStatus === 'failing' || workspace.pullRequest?.ciStatus === 'failing') {
+		return 'ci_failed';
+	}
+	if (hasOpenPr && ((git?.files.length ?? 0) > 0 || (git?.aheadCount ?? 0) > 0)) {
+		return 'commit_and_push';
+	}
+	if (hasOpenPr) {
+		return 'pr_opened';
+	}
+	if (git?.hasPushedCommits) return 'create_pr';
+	return 'none';
+}
+
+export function deriveSidebarSnapshot(args: {
+	state: StoreState;
+	activeStatuses: Map<string, MikoStatus>;
+	gitSnapshots?: Map<string, WorkspaceGitSnapshot>;
+	githubSnapshots?: Map<string, WorkspaceGitHubSnapshot>;
+}): SidebarSnapshot {
+	const directories = [...args.state.directoriesById.values()]
+		.filter((directory) => !directory.removedAt)
+		.sort((a, b) => b.updatedAt - a.updatedAt);
+
+	const directoryGroups: SidebarDirectoryGroup[] = directories.map((directory) => {
+		const workspaces: SidebarWorkspaceRow[] = [...args.state.workspacesById.values()]
+			.filter(
+				(workspace) =>
+					workspace.directoryId === directory.id &&
+					!workspace.removedAt &&
+					workspace.visibilityState === 'active',
+			)
+			.sort(
+				(a, b) =>
+					getWorkspaceLastActivityAt(args.state, b) - getWorkspaceLastActivityAt(args.state, a),
+			)
+			.map((workspace) => {
+				const hasActiveSession = [...args.state.sessionsById.values()].some(
+					(session) =>
+						session.workspaceId === workspace.id &&
+						!session.removedAt &&
+						args.activeStatuses.has(session.id),
+				);
+
+				const git = args.gitSnapshots?.get(workspace.id) ?? null;
+				const github = args.githubSnapshots?.get(workspace.id) ?? null;
+				const latestSession = getWorkspaceLatestSession(args.state, workspace);
+
+				return {
+					_id: workspace.id,
+					_creationTime: workspace.createdAt,
+					workspaceId: workspace.id,
+					createdAt: workspace.createdAt,
+					updatedAt: workspace.updatedAt,
+					displayName: getWorkspaceDisplayName(workspace, github),
+					reviewState: workspace.reviewState,
+					visibilityState: workspace.visibilityState,
+					indicator: getWorkspaceSidebarIndicator({
+						workspace,
+						hasActiveSession,
+						git,
+						github,
+					}),
+					hasUnreadAgentResult: workspace.hasUnreadAgentResult,
+					hasActiveSession,
+					localPath: workspace.localPath,
+					branchName: workspace.branchName,
+					githubOwner: directory.githubOwner,
+					githubRepo: directory.githubRepo,
+					defaultBranchName: directory.defaultBranchName,
+					hasPullRequest: workspaceHasPullRequest(workspace),
+					prNumber: workspace.pullRequest?.number,
+					prTitle: getWorkspacePrTitle(workspace, github),
+					prUrl: workspace.pullRequest?.url,
+					prCreatedAt: workspace.pullRequest?.createdAt,
+					hasDirtyFiles: (git?.files.length ?? 0) > 0,
+					hasUnpushedCommits: (git?.aheadCount ?? 0) > 0,
+					displayDiffStats: getWorkspaceDiffStats(git, github),
+					lastActivityAt: getWorkspaceLastActivityAt(args.state, workspace),
+					lastSessionId: latestSession?.id,
+					lastSessionTitle:
+						latestSession && latestSession.title !== 'Untitled' ? latestSession.title : undefined,
+					lastAssistantPreview: latestSession?.lastAssistantPreview,
+				};
+			});
+
+		return {
+			groupKey: directory.id,
+			directoryId: directory.id,
+			localPath: directory.localPath,
+			title: directory.title,
+			createdAt: directory.createdAt,
+			updatedAt: directory.updatedAt,
+			avatarUrl: `https://github.com/${directory.githubOwner}.png`,
+			workspaces,
+		};
+	});
+
+	return { directoryGroups };
+}
+
+export function deriveDirectoryListSnapshot(
+	state: StoreState,
+	machineName: string,
+): DirectoryListSnapshot {
+	return {
+		machine: {
+			id: 'local',
+			displayName: machineName,
+		},
+		directories: [...state.directoriesById.values()]
+			.filter((directory) => !directory.removedAt)
+			.sort((a, b) => b.updatedAt - a.updatedAt)
+			.map(({ removedAt: _removedAt, ...directory }) => directory),
+		workspaces: [...state.workspacesById.values()]
+			.filter((workspace) => {
+				if (workspace.removedAt) return false;
+				const directory = state.directoriesById.get(workspace.directoryId);
+				return Boolean(directory && !directory.removedAt);
+			})
+			.sort((a, b) => b.updatedAt - a.updatedAt)
+			.map(({ removedAt: _removedAt, ...workspace }) => workspace),
+	};
+}
+
+export function deriveWorkspaceSnapshot(args: {
+	state: StoreState;
+	activeStatuses: Map<string, MikoStatus>;
+	workspaceId: string;
+	healthState?: WorkspaceHealthState;
+	git?: WorkspaceGitSnapshot | null;
+	github?: WorkspaceGitHubSnapshot | null;
+}): WorkspaceSnapshot | null {
+	const workspace = args.state.workspacesById.get(args.workspaceId);
+	if (!workspace || workspace.removedAt) return null;
+	const directory = args.state.directoriesById.get(workspace.directoryId);
+	if (!directory || directory.removedAt) return null;
+
+	const { removedAt: _removedAt, ...workspaceSummary } = workspace;
+	const sessions = [...args.state.sessionsById.values()]
+		.filter((session) => session.workspaceId === workspace.id && !session.removedAt)
+		.map(({ removedAt: _removedAt, ...session }) => session);
+
+	return {
+		workspace: workspaceSummary,
+		primaryLabel: getWorkspaceDisplayName(workspace, args.github),
+		healthState: args.healthState ?? 'healthy',
+		git: args.git ?? null,
+		github: args.github ?? null,
+		sessions,
+		hasActiveSession: sessions.some((session) => args.activeStatuses.has(session.id)),
+		hasUnreadAgentResult: workspace.hasUnreadAgentResult,
+	};
+}
+
+export function deriveSessionSnapshot(
+	state: StoreState,
+	activeStatuses: Map<string, MikoStatus>,
+	drainingSessionIds: Set<string>,
+	sessionId: string,
+	pendingTool: PendingToolSnapshot | null,
+	queued: QueuedMessageSnapshot[],
+	getMessages: (sessionId: string) => Pick<SessionSnapshot, 'messages' | 'history'>,
+): SessionSnapshot | null {
+	const session = state.sessionsById.get(sessionId);
+	if (!session || session.removedAt) return null;
+
+	const workspace = state.workspacesById.get(session.workspaceId);
+	if (!workspace || workspace.removedAt) return null;
+
+	const directory = state.directoriesById.get(workspace.directoryId);
+	if (!directory || directory.removedAt) return null;
+
+	const runtime: SessionRuntime = {
+		sessionId: session.id,
+		workspaceId: workspace.id,
+		directoryId: directory.id,
+		localPath: workspace.localPath,
+		title: session.title,
+		status: deriveStatus(session, activeStatuses.get(session.id)),
+		isDraining: drainingSessionIds.has(session.id),
+		provider: session.provider,
+		planMode: session.planMode,
+		sessionToken: session.sessionToken,
+		pendingTool,
+		queued,
+	};
+
+	const transcript = getMessages(session.id);
+
+	return {
+		runtime,
+		messages: transcript.messages,
+		history: transcript.history,
+		availableProviders: [...SERVER_PROVIDERS],
+	};
+}

package/src/server/restart.ts

@@ -0,0 +1,33 @@
+export const CLI_CHILD_MODE_ENV_VAR = 'MIKO_CLI_MODE';
+export const CLI_CHILD_MODE = 'child';
+export const CLI_STARTUP_UPDATE_RESTART_EXIT_CODE = 75;
+export const CLI_UI_UPDATE_RESTART_EXIT_CODE = 76;
+export const CLI_CHILD_COMMAND_ENV_VAR = 'MIKO_CLI_CHILD_COMMAND';
+export const CLI_CHILD_ARGS_ENV_VAR = 'MIKO_CLI_CHILD_ARGS';
+export const CLI_SUPPRESS_OPEN_ONCE_ENV_VAR = 'MIKO_SUPPRESS_OPEN_ONCE';
+
+export function shouldRestartCliProcess(code: number | null, signal: NodeJS.Signals | null) {
+	return (
+		signal === null &&
+		(code === CLI_STARTUP_UPDATE_RESTART_EXIT_CODE || code === CLI_UI_UPDATE_RESTART_EXIT_CODE)
+	);
+}
+
+export function isUiUpdateRestart(code: number | null, signal: NodeJS.Signals | null) {
+	return signal === null && code === CLI_UI_UPDATE_RESTART_EXIT_CODE;
+}
+
+export function parseChildArgsEnv(value: string | undefined) {
+	if (!value) return [];
+
+	try {
+		const parsed = JSON.parse(value) as unknown;
+		if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === 'string')) {
+			throw new Error('child args must be an array of strings');
+		}
+		return parsed;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid ${CLI_CHILD_ARGS_ENV_VAR}: ${message}`);
+	}
+}

package/src/server/scratchpad-manager.ts

@@ -0,0 +1,87 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename } from 'node:fs/promises';
+import path from 'node:path';
+import type { ScratchpadSnapshot } from '../shared/types';
+
+const SAFE_WORKSPACE_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+interface ScratchpadStorageAdapter {
+	write: (destination: string, content: string) => Promise<unknown>;
+	rename: (oldPath: string, newPath: string) => Promise<unknown>;
+	mkdir: (directoryPath: string, options: { recursive: true }) => Promise<unknown>;
+}
+
+const defaultStorageAdapter: ScratchpadStorageAdapter = {
+	write: Bun.write,
+	rename,
+	mkdir,
+};
+
+export class ScratchpadManager {
+	private readonly scratchpadsDir: string;
+	private readonly storage: ScratchpadStorageAdapter;
+	private readonly writeChainsByWorkspaceId = new Map<string, Promise<unknown>>();
+
+	constructor(dataDir: string, storage: ScratchpadStorageAdapter = defaultStorageAdapter) {
+		this.scratchpadsDir = path.join(dataDir, 'scratchpads');
+		this.storage = storage;
+	}
+
+	async getSnapshot(workspaceId: string): Promise<ScratchpadSnapshot> {
+		const filePath = this.getScratchpadPath(workspaceId);
+		const file = Bun.file(filePath);
+
+		if (!(await file.exists())) {
+			return { workspaceId, content: '', updatedAt: null };
+		}
+
+		const content = await file.text();
+		return { workspaceId, content, updatedAt: file.lastModified };
+	}
+
+	async updateScratchpad(workspaceId: string, content: string): Promise<ScratchpadSnapshot> {
+		this.assertSafeWorkspaceId(workspaceId);
+		return this.enqueueWorkspaceScratchpadWrite(workspaceId, async () => {
+			await this.storage.mkdir(this.scratchpadsDir, { recursive: true });
+
+			const filePath = this.getScratchpadPath(workspaceId);
+			const tempPath = path.join(this.scratchpadsDir, `.${workspaceId}.${randomUUID()}.tmp`);
+
+			await this.storage.write(tempPath, content);
+			await this.storage.rename(tempPath, filePath);
+
+			return this.getSnapshot(workspaceId);
+		});
+	}
+
+	private enqueueWorkspaceScratchpadWrite<T>(
+		workspaceId: string,
+		operation: () => Promise<T>,
+	): Promise<T> {
+		const previous = this.writeChainsByWorkspaceId.get(workspaceId) ?? Promise.resolve();
+		const run = previous.catch(() => undefined).then(operation);
+
+		this.writeChainsByWorkspaceId.set(workspaceId, run);
+
+		void run
+			.finally(() => {
+				if (this.writeChainsByWorkspaceId.get(workspaceId) === run) {
+					this.writeChainsByWorkspaceId.delete(workspaceId);
+				}
+			})
+			.catch(() => undefined);
+
+		return run;
+	}
+
+	private assertSafeWorkspaceId(workspaceId: string) {
+		if (!SAFE_WORKSPACE_ID_PATTERN.test(workspaceId)) {
+			throw new Error('Invalid workspace id');
+		}
+	}
+
+	private getScratchpadPath(workspaceId: string) {
+		this.assertSafeWorkspaceId(workspaceId);
+		return path.join(this.scratchpadsDir, `${workspaceId}.md`);
+	}
+}