miko-code 0.1.0

package/src/server/event.ts

@@ -0,0 +1,249 @@
+import type {
+	AgentProvider,
+	ChatAttachment,
+	DirectorySummary,
+	ModelOptions,
+	PromptPart,
+	SessionSummary,
+	TranscriptEntry,
+	WorkspacePullRequestSummary,
+	WorkspaceReviewState,
+	WorkspaceSummary,
+	WorkspaceVisibilityState,
+} from 'src/shared/types';
+
+export interface DirectoryRecord extends DirectorySummary {
+	removedAt?: number;
+}
+
+export interface WorkspaceRecord extends WorkspaceSummary {
+	removedAt?: number;
+}
+
+export interface SessionRecord extends SessionSummary {
+	removedAt?: number;
+}
+
+export interface QueuedSessionSendPayload {
+	provider?: AgentProvider;
+	content: string;
+	attachments?: ChatAttachment[];
+	parts?: PromptPart[];
+	model?: string;
+	modelOptions: ModelOptions;
+	effort?: string;
+	planMode?: boolean;
+}
+
+export type QueuedSessionMessageStatus = 'queued' | 'draining';
+
+export interface QueuedSessionMessageRecord {
+	id: string;
+	sessionId: string;
+	payload: QueuedSessionSendPayload;
+	status: QueuedSessionMessageStatus;
+	sequence: number;
+	promptEntryId: string;
+	createdAt: number;
+	updatedAt: number;
+}
+
+export interface StoreState {
+	directoriesById: Map<string, DirectoryRecord>;
+	workspacesById: Map<string, WorkspaceRecord>;
+	sessionsById: Map<string, SessionRecord>;
+	queuedMessagesById: Map<string, QueuedSessionMessageRecord>;
+}
+
+export interface SnapshotFile {
+	generatedAt: number;
+	directories: DirectoryRecord[];
+	workspaces: WorkspaceRecord[];
+	sessions: SessionRecord[];
+	queuedMessages?: QueuedSessionMessageRecord[];
+}
+
+export type DirectoryEvent =
+	| {
+			type: 'directory_added';
+			timestamp: number;
+			directoryId: string;
+			localPath: string;
+			title: string;
+			githubOwner: string;
+			githubRepo: string;
+			defaultBranchName: 'main';
+	  }
+	| {
+			type: 'directory_removed';
+			timestamp: number;
+			directoryId: string;
+	  };
+
+export type WorkspaceEvent =
+	| {
+			type: 'workspace_created';
+			timestamp: number;
+			workspaceId: string;
+			directoryId: string;
+			localPath: string;
+			branchName: string;
+	  }
+	| {
+			type: 'workspace_removed';
+			timestamp: number;
+			workspaceId: string;
+	  }
+	| {
+			type: 'workspace_setup_completed';
+			timestamp: number;
+			workspaceId: string;
+	  }
+	| {
+			type: 'workspace_setup_failed';
+			timestamp: number;
+			workspaceId: string;
+			error: string;
+	  }
+	| {
+			type: 'workspace_branch_name_changed';
+			timestamp: number;
+			workspaceId: string;
+			branchName: string;
+	  }
+	| {
+			type: 'workspace_review_state_changed';
+			timestamp: number;
+			workspaceId: string;
+			reviewState: WorkspaceReviewState;
+	  }
+	| {
+			type: 'workspace_visibility_changed';
+			timestamp: number;
+			workspaceId: string;
+			visibilityState: WorkspaceVisibilityState;
+	  }
+	| {
+			type: 'workspace_pr_observed';
+			timestamp: number;
+			workspaceId: string;
+			pullRequest: WorkspacePullRequestSummary;
+	  }
+	| {
+			type: 'workspace_pr_cleared';
+			timestamp: number;
+			workspaceId: string;
+	  }
+	| {
+			type: 'workspace_unread_agent_result_set';
+			timestamp: number;
+			workspaceId: string;
+			hasUnreadAgentResult: boolean;
+	  };
+
+export type SessionEvent =
+	| {
+			type: 'session_created';
+			timestamp: number;
+			sessionId: string;
+			workspaceId: string;
+			title: string;
+	  }
+	| {
+			type: 'session_renamed';
+			timestamp: number;
+			sessionId: string;
+			title: string;
+	  }
+	| {
+			type: 'session_removed';
+			timestamp: number;
+			sessionId: string;
+	  }
+	| {
+			type: 'session_provider_set';
+			timestamp: number;
+			sessionId: string;
+			provider: AgentProvider;
+	  }
+	| {
+			type: 'session_plan_mode_set';
+			timestamp: number;
+			sessionId: string;
+			planMode: boolean;
+	  };
+
+export type TurnEvent =
+	| {
+			type: 'turn_started';
+			timestamp: number;
+			sessionId: string;
+	  }
+	| {
+			type: 'turn_finished';
+			timestamp: number;
+			sessionId: string;
+	  }
+	| {
+			type: 'turn_failed';
+			timestamp: number;
+			sessionId: string;
+			error: string;
+	  }
+	| {
+			type: 'turn_cancelled';
+			timestamp: number;
+			sessionId: string;
+	  }
+	| {
+			type: 'session_token_set';
+			timestamp: number;
+			sessionId: string;
+			sessionToken: string | null;
+	  };
+
+export type QueueEvent =
+	| {
+			type: 'session_message_queued';
+			timestamp: number;
+			message: QueuedSessionMessageRecord;
+	  }
+	| {
+			type: 'session_message_claimed';
+			timestamp: number;
+			sessionId: string;
+			messageId: string;
+			promptEntryId: string;
+	  }
+	| {
+			type: 'session_message_requeued';
+			timestamp: number;
+			sessionId: string;
+			messageId: string;
+	  }
+	| {
+			type: 'session_message_completed' | 'session_message_failed' | 'session_message_dequeued';
+			timestamp: number;
+			sessionId: string;
+			messageId: string;
+	  }
+	| {
+			type: 'session_queue_cleared';
+			timestamp: number;
+			sessionId: string;
+	  };
+
+export type StoreEvent = DirectoryEvent | WorkspaceEvent | SessionEvent | TurnEvent | QueueEvent;
+
+export function createEmptyState(): StoreState {
+	return {
+		directoriesById: new Map(),
+		workspacesById: new Map(),
+		sessionsById: new Map(),
+		queuedMessagesById: new Map(),
+	};
+}
+
+export function cloneTranscriptEntries(entries: TranscriptEntry[]): TranscriptEntry[] {
+	return structuredClone(entries);
+}

package/src/server/external-file-access.ts

@@ -0,0 +1,48 @@
+import { randomUUID } from 'node:crypto';
+
+const EXTERNAL_FILE_ACCESS_TTL_MS = 10 * 60 * 1000;
+const MAX_EXTERNAL_FILE_ACCESS_TOKENS = 1024;
+
+interface ExternalFileAccessGrant {
+	filePath: string;
+	expiresAt: number;
+}
+
+const grantsByToken = new Map<string, ExternalFileAccessGrant>();
+
+function pruneExternalFileAccessGrants(now = Date.now()) {
+	for (const [token, grant] of grantsByToken) {
+		if (grant.expiresAt <= now) grantsByToken.delete(token);
+	}
+
+	while (grantsByToken.size > MAX_EXTERNAL_FILE_ACCESS_TOKENS) {
+		const oldestToken = grantsByToken.keys().next().value;
+		if (!oldestToken) break;
+		grantsByToken.delete(oldestToken);
+	}
+}
+
+export function registerExternalFileAccess(filePath: string, now = Date.now()) {
+	pruneExternalFileAccessGrants(now);
+	const token = randomUUID();
+	grantsByToken.set(token, {
+		filePath,
+		expiresAt: now + EXTERNAL_FILE_ACCESS_TTL_MS,
+	});
+	return token;
+}
+
+export function resolveExternalFileAccessToken(token: string, now = Date.now()) {
+	pruneExternalFileAccessGrants(now);
+	const grant = grantsByToken.get(token);
+	if (!grant) return null;
+	if (grant.expiresAt <= now) {
+		grantsByToken.delete(token);
+		return null;
+	}
+	return grant.filePath;
+}
+
+export function resetExternalFileAccessGrantsForTests() {
+	grantsByToken.clear();
+}

package/src/server/external-open.ts

@@ -0,0 +1,259 @@
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import type { ClientCommand, EditorOpenSettings, EditorPreset } from '../shared/protocol';
+import { resolveLocalPath } from './paths';
+import { canOpenMacApp, hasCommand, spawnDetached } from './process-utils';
+
+type OpenExternalCommand = Extract<ClientCommand, { type: 'system.openExternal' }>;
+
+interface CommandSpec {
+	command: string;
+	args: string[];
+}
+
+const DEFAULT_EDITOR_SETTINGS: EditorOpenSettings = {
+	preset: 'cursor',
+	commandTemplate: 'cursor {path}',
+};
+
+export async function openExternal(command: OpenExternalCommand) {
+	const resolvedPath = resolveLocalPath(command.localPath);
+	const platform = process.platform;
+	const info =
+		command.action === 'open_editor' || command.action === 'open_finder'
+			? await stat(resolvedPath).catch(() => null)
+			: null;
+
+	if (command.action === 'open_editor') {
+		if (!info) {
+			throw new Error(`Path not found: ${resolvedPath}`);
+		}
+
+		const editorCommand = buildEditorCommand({
+			localPath: resolvedPath,
+			isDirectory: info.isDirectory(),
+			line: command.line,
+			column: command.column,
+			editor: command.editor ?? DEFAULT_EDITOR_SETTINGS,
+			platform,
+		});
+
+		spawnDetached(editorCommand.command, editorCommand.args);
+		return;
+	}
+
+	if (platform === 'darwin') {
+		if (command.action === 'open_finder') {
+			if (info?.isDirectory()) {
+				spawnDetached('open', [resolvedPath]);
+			} else {
+				spawnDetached('open', ['-R', resolvedPath]);
+			}
+			return;
+		}
+
+		if (command.action === 'open_terminal') {
+			spawnDetached('open', ['-a', 'Terminal', resolvedPath]);
+			return;
+		}
+	}
+
+	if (command.action === 'open_finder') {
+		spawnDetached('xdg-open', [info?.isDirectory() ? resolvedPath : path.dirname(resolvedPath)]);
+		return;
+	}
+
+	if (command.action === 'open_terminal') {
+		for (const terminalCommand of ['x-terminal-emulator', 'gnome-terminal', 'konsole']) {
+			if (!hasCommand(terminalCommand)) continue;
+			if (terminalCommand === 'konsole') {
+				spawnDetached(terminalCommand, ['--workdir', resolvedPath]);
+			} else {
+				spawnDetached(terminalCommand, ['--working-directory', resolvedPath]);
+			}
+			return;
+		}
+		spawnDetached('xdg-open', [resolvedPath]);
+	}
+}
+
+export function buildEditorCommand(args: {
+	localPath: string;
+	isDirectory: boolean;
+	line?: number;
+	column?: number;
+	editor: EditorOpenSettings;
+	platform: NodeJS.Platform;
+}): CommandSpec {
+	const editor = normalizeEditorSettings(args.editor);
+	if (editor.preset === 'custom') {
+		return buildCustomEditorCommand({
+			commandTemplate: editor.commandTemplate,
+			localPath: args.localPath,
+			line: args.line,
+			column: args.column,
+		});
+	}
+	return buildPresetEditorCommand(args, editor.preset);
+}
+
+export function buildPresetEditorCommand(
+	args: {
+		localPath: string;
+		isDirectory: boolean;
+		line?: number;
+		column?: number;
+		platform: NodeJS.Platform;
+	},
+	preset: Exclude<EditorPreset, 'custom'>,
+): CommandSpec {
+	const gotoTarget = `${args.localPath}:${args.line ?? 1}:${args.column ?? 1}`;
+	const opener = resolveEditorExecutable(preset, args.platform);
+
+	if (args.isDirectory || !args.line) {
+		return { command: opener.command, args: [...opener.args, args.localPath] };
+	}
+	return { command: opener.command, args: [...opener.args, '--goto', gotoTarget] };
+}
+
+export function resolveEditorExecutable(
+	preset: Exclude<EditorPreset, 'custom'>,
+	platform: NodeJS.Platform,
+) {
+	if (preset === 'cursor') {
+		if (hasCommand('cursor')) return { command: 'cursor', args: [] };
+		if (platform === 'darwin' && canOpenMacApp('Cursor'))
+			return { command: 'open', args: ['-a', 'Cursor'] };
+	}
+
+	if (preset === 'vscode') {
+		if (hasCommand('code')) return { command: 'code', args: [] };
+		if (platform === 'darwin' && canOpenMacApp('Visual Studio Code'))
+			return { command: 'open', args: ['-a', 'Visual Studio Code'] };
+	}
+
+	if (preset === 'warp') {
+		if (hasCommand('warp')) return { command: 'warp', args: [] };
+		if (platform === 'darwin' && canOpenMacApp('Warp'))
+			return { command: 'open', args: ['-a', 'Warp'] };
+	}
+
+	if (preset === 'antigravity') {
+		if (hasCommand('antigravity')) return { command: 'antigravity', args: [] };
+		if (platform === 'darwin' && canOpenMacApp('Antigravity'))
+			return { command: 'open', args: ['-a', 'Antigravity'] };
+	}
+
+	if (platform === 'darwin') {
+		switch (preset) {
+			case 'cursor':
+				return { command: 'open', args: ['-a', 'Cursor'] };
+			case 'vscode':
+				return { command: 'open', args: ['-a', 'Visual Studio Code'] };
+			case 'warp':
+				return { command: 'open', args: ['-a', 'Warp'] };
+			case 'antigravity':
+				return { command: 'open', args: ['-a', 'Antigravity'] };
+		}
+	}
+
+	if (preset === 'vscode') return { command: 'code', args: [] };
+	return { command: preset, args: [] };
+}
+
+export function buildCustomEditorCommand(args: {
+	commandTemplate: string;
+	localPath: string;
+	line?: number;
+	column?: number;
+}): CommandSpec {
+	const template = args.commandTemplate.trim();
+	if (!template.includes('{path}')) {
+		throw new Error('Custom editor command must include {path}');
+	}
+
+	const line = String(args.line ?? 1);
+	const column = String(args.column ?? 1);
+	const replaced = template
+		.replaceAll('{path}', args.localPath)
+		.replaceAll('{line}', line)
+		.replaceAll('{column}', column);
+
+	const tokens = tokenizeCommandTemplate(replaced);
+	const [command, ...commandArgs] = tokens;
+	if (!command) {
+		throw new Error('Custom editor command is empty');
+	}
+	if (!hasCommand(command)) {
+		throw new Error(`Custom editor command not found: ${command}`);
+	}
+	return { command, args: commandArgs };
+}
+
+export function tokenizeCommandTemplate(template: string) {
+	const tokens: string[] = [];
+	let current = '';
+	let quote: "'" | '"' | null = null;
+
+	for (let index = 0; index < template.length; index += 1) {
+		const char = template[index];
+
+		if (char === '\\' && index + 1 < template.length) {
+			current += template[index + 1];
+			index += 1;
+			continue;
+		}
+
+		if (quote) {
+			if (char === quote) {
+				quote = null;
+			} else {
+				current += char;
+			}
+			continue;
+		}
+
+		if (char === "'" || char === '"') {
+			quote = char;
+			continue;
+		}
+
+		if (/\s/.test(char)) {
+			if (current.length > 0) {
+				tokens.push(current);
+				current = '';
+			}
+			continue;
+		}
+
+		current += char;
+	}
+
+	if (quote) {
+		throw new Error('Custom editor command has an unclosed quote');
+	}
+	if (current.length > 0) {
+		tokens.push(current);
+	}
+	return tokens;
+}
+
+export function normalizeEditorSettings(editor: EditorOpenSettings): EditorOpenSettings {
+	const preset = normalizeEditorPreset(editor.preset);
+	const commandTemplate = editor.commandTemplate?.trim() || DEFAULT_EDITOR_SETTINGS.commandTemplate;
+	return { preset, commandTemplate } as EditorOpenSettings;
+}
+
+function normalizeEditorPreset(preset: EditorPreset): EditorPreset {
+	switch (preset) {
+		case 'vscode':
+		case 'custom':
+		case 'warp':
+		case 'antigravity':
+		case 'cursor':
+			return preset;
+		default:
+			return DEFAULT_EDITOR_SETTINGS.preset;
+	}
+}

package/src/server/generate-title.ts

@@ -0,0 +1,75 @@
+import { QuickResponseAdapter } from './quick-response';
+
+const TITLE_SCHEMA = {
+	type: 'object',
+	properties: {
+		title: { type: 'string' },
+	},
+	required: ['title'],
+	additionalProperties: false,
+} as const;
+
+function normalizeGeneratedTitle(value: unknown): string | null {
+	if (typeof value !== 'string') return null;
+	const normalized = value.replace(/\s+/g, ' ').trim().slice(0, 80);
+
+	if (!normalized || normalized === 'Untitled') return null;
+	return normalized;
+}
+
+export function fallbackTitleFromMessage(messageContent: string): string | null {
+	const normalized = messageContent.replace(/\s+/g, ' ').trim();
+	if (!normalized) return null;
+
+	if (normalized.length <= 35) return normalized;
+	return `${normalized.slice(0, 35)}...`;
+}
+
+export interface GenerateSessionTitleResult {
+	title: string | null;
+	usedFallback: boolean;
+	failureMessage: string | null;
+}
+
+function summarizeFailures(failures: Array<{ provider: 'claude' | 'codex'; reason: string }>) {
+	if (failures.length === 0) return null;
+	return failures.map((failure) => failure.reason).join('; ');
+}
+
+export async function generateTitleForSession(
+	messageContent: string,
+	adapter = new QuickResponseAdapter(),
+): Promise<string | null> {
+	const result = await generateTitleForSessionDetailed(messageContent, adapter);
+	return result.title;
+}
+
+export async function generateTitleForSessionDetailed(
+	messageContent: string,
+	adapter = new QuickResponseAdapter(),
+): Promise<GenerateSessionTitleResult> {
+	const result = await adapter.generateStructuredWithDiagnostics<string>({
+		task: 'session title generation',
+		prompt: `Generate a short, descriptive title (under 30 chars) for a session that starts with this message.\n\n${messageContent.slice(0, 12_000)}`,
+		schema: TITLE_SCHEMA,
+		parse: (value) => {
+			const output = value && typeof value === 'object' ? (value as { title?: unknown }) : {};
+			return normalizeGeneratedTitle(output.title);
+		},
+	});
+
+	if (result.value) {
+		return {
+			title: result.value,
+			usedFallback: false,
+			failureMessage: null,
+		};
+	}
+
+	const fallbackTitle = fallbackTitleFromMessage(messageContent);
+	return {
+		title: fallbackTitle,
+		usedFallback: true,
+		failureMessage: summarizeFailures(result.failures),
+	};
+}

package/src/server/git-refresh-poller.ts

@@ -0,0 +1,92 @@
+import type { WorkspaceRecord } from './event';
+import { shouldPollActiveWorkspace } from './workspace-polling';
+
+const DEFAULT_INTERVAL_MS = 2_000;
+
+export interface GitRefreshPollerDeps {
+	listWorkspaces: () => WorkspaceRecord[];
+	refreshWorkspaceGitSnapshot: (workspaceId: string, localPath: string) => Promise<boolean>;
+	broadcastSnapshots: () => Promise<void>;
+	setInterval?: typeof setInterval;
+	clearInterval?: typeof clearInterval;
+	logger?: Pick<Console, 'warn'>;
+	intervalMs?: number;
+}
+
+export class GitRefreshPoller {
+	private readonly intervalMs: number;
+	private readonly setIntervalImpl: typeof setInterval;
+	private readonly clearIntervalImpl: typeof clearInterval;
+	private readonly logger: Pick<Console, 'warn'>;
+	private timer: ReturnType<typeof setInterval> | null = null;
+	private running = false;
+	private stopped = false;
+	private inFlight: Promise<void> | null = null;
+
+	constructor(private readonly deps: GitRefreshPollerDeps) {
+		this.intervalMs = deps.intervalMs ?? DEFAULT_INTERVAL_MS;
+		this.setIntervalImpl = deps.setInterval ?? setInterval;
+		this.clearIntervalImpl = deps.clearInterval ?? clearInterval;
+		this.logger = deps.logger ?? console;
+	}
+
+	start() {
+		if (this.timer) return;
+		this.stopped = false;
+		this.timer = this.setIntervalImpl(() => {
+			void this.tick();
+		}, this.intervalMs);
+		void this.tick();
+	}
+
+	async stop() {
+		this.stopped = true;
+		if (this.timer) this.clearIntervalImpl(this.timer);
+		this.timer = null;
+		await this.inFlight;
+	}
+
+	async tick() {
+		if (this.stopped) return;
+		if (this.running) return this.inFlight ?? undefined;
+
+		this.running = true;
+		const run = this.runTick();
+		this.inFlight = run;
+		try {
+			await run;
+		} finally {
+			this.running = false;
+			this.inFlight = null;
+		}
+	}
+
+	private async runTick() {
+		try {
+			let changed = false;
+			const errors: unknown[] = [];
+			const workspaces = this.deps.listWorkspaces().filter(shouldPollActiveWorkspace);
+
+			await Promise.all(
+				workspaces.map(async (workspace) => {
+					try {
+						if (await this.deps.refreshWorkspaceGitSnapshot(workspace.id, workspace.localPath)) {
+							changed = true;
+						}
+					} catch (error) {
+						errors.push(error);
+					}
+				}),
+			);
+
+			if (this.stopped) return;
+			if (changed) await this.deps.broadcastSnapshots();
+			if (errors.length > 0) {
+				this.logger.warn('[miko] failed to poll workspace git state', errors[0]);
+			}
+		} catch (error) {
+			if (this.stopped) return;
+			this.logger.warn('[miko] failed to poll workspace git state', error);
+		}
+	}
+}