miko-code 0.1.0

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

@@ -0,0 +1,126 @@
+import type { WorkspaceGitHubSnapshot } from 'src/shared/types';
+import type { WorkspaceRecord } from './event';
+import { GitHubRateLimitError } from './github-rest-client';
+import { shouldPollActiveWorkspace } from './workspace-polling';
+
+const DEFAULT_INTERVAL_MS = 2_000;
+const DEFAULT_BACKOFF_MS = 60_000;
+
+export interface PrRefreshPollerDeps {
+	listWorkspaces: () => WorkspaceRecord[];
+	getWorkspaceGitHubSnapshot: (workspaceId: string) => WorkspaceGitHubSnapshot | null;
+	refreshWorkspacePrStage: (
+		workspaceId: string,
+		options?: { force?: boolean },
+	) => Promise<{ snapshot?: WorkspaceGitHubSnapshot | null }>;
+	broadcastSnapshots: () => Promise<void>;
+	setInterval?: typeof setInterval;
+	clearInterval?: typeof clearInterval;
+	now?: () => number;
+	logger?: Pick<Console, 'warn'>;
+	intervalMs?: number;
+	defaultBackoffMs?: number;
+}
+
+function snapshotFingerprint(snapshot: WorkspaceGitHubSnapshot | null) {
+	if (!snapshot) return 'null';
+	const { lastRefreshedAt: _lastRefreshedAt, ...stable } = snapshot;
+	return JSON.stringify(stable);
+}
+
+function retryAfterMs(error: unknown, defaultBackoffMs: number) {
+	if (error instanceof GitHubRateLimitError) return error.retryAfterMs ?? defaultBackoffMs;
+	return null;
+}
+
+export class PrRefreshPoller {
+	private readonly intervalMs: number;
+	private readonly defaultBackoffMs: number;
+	private readonly setIntervalImpl: typeof setInterval;
+	private readonly clearIntervalImpl: typeof clearInterval;
+	private readonly now: () => number;
+	private readonly logger: Pick<Console, 'warn'>;
+	private timer: ReturnType<typeof setInterval> | null = null;
+	private running = false;
+	private backoffUntil = 0;
+	private stopped = false;
+	private inFlight: Promise<void> | null = null;
+
+	constructor(private readonly deps: PrRefreshPollerDeps) {
+		this.intervalMs = deps.intervalMs ?? DEFAULT_INTERVAL_MS;
+		this.defaultBackoffMs = deps.defaultBackoffMs ?? DEFAULT_BACKOFF_MS;
+		this.setIntervalImpl = deps.setInterval ?? setInterval;
+		this.clearIntervalImpl = deps.clearInterval ?? clearInterval;
+		this.now = deps.now ?? Date.now;
+		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;
+		this.backoffUntil = 0;
+		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;
+		if (this.now() < this.backoffUntil) return;
+
+		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;
+			let backoffMs: number | null = null;
+			const errors: unknown[] = [];
+			const workspaces = this.deps.listWorkspaces().filter(shouldPollActiveWorkspace);
+
+			await Promise.all(
+				workspaces.map(async (workspace) => {
+					try {
+						const before = snapshotFingerprint(this.deps.getWorkspaceGitHubSnapshot(workspace.id));
+						await this.deps.refreshWorkspacePrStage(workspace.id, { force: true });
+						const after = snapshotFingerprint(this.deps.getWorkspaceGitHubSnapshot(workspace.id));
+						if (before !== after) changed = true;
+					} catch (error) {
+						errors.push(error);
+						const nextBackoffMs = retryAfterMs(error, this.defaultBackoffMs);
+						if (nextBackoffMs !== null) backoffMs = Math.max(backoffMs ?? 0, nextBackoffMs);
+					}
+				}),
+			);
+
+			if (this.stopped) return;
+			if (backoffMs !== null) this.backoffUntil = this.now() + backoffMs;
+			if (changed) await this.deps.broadcastSnapshots();
+			if (errors.length > 0) {
+				this.logger.warn('[miko] failed to poll workspace PR state', errors[0]);
+			}
+		} catch (error) {
+			if (this.stopped) return;
+			const backoffMs = retryAfterMs(error, this.defaultBackoffMs);
+			if (backoffMs !== null) this.backoffUntil = this.now() + backoffMs;
+			this.logger.warn('[miko] failed to poll workspace PR state', error);
+		}
+	}
+}

package/src/server/process-utils.ts

@@ -0,0 +1,18 @@
+import { spawn, spawnSync } from 'node:child_process';
+
+export function spawnDetached(command: string, args: string[]) {
+	const child = spawn(command, args, { stdio: 'ignore', detached: true });
+	// Swallow ENOENT/EACCES so a missing binary cannot crash the server.
+	child.on('error', () => {});
+	child.unref();
+}
+
+export function hasCommand(command: string) {
+	const result = spawnSync('sh', ['-lc', 'command -v "$1"', 'sh', command], { stdio: 'ignore' });
+	return result.status === 0;
+}
+
+export function canOpenMacApp(appName: string) {
+	const result = spawnSync('open', ['-Ra', appName], { stdio: 'ignore' });
+	return result.status === 0;
+}

package/src/server/provider-catalog.ts

@@ -0,0 +1,90 @@
+import {
+	type AgentProvider,
+	type ClaudeContextWindow,
+	type ClaudeModelOptions,
+	type CodexModelOptions,
+	DEFAULT_CLAUDE_MODEL_OPTIONS,
+	DEFAULT_CODEX_MODEL_OPTIONS,
+	isClaudeReasoningEffort,
+	isCodexReasoningEffort,
+	type ModelOptions,
+	normalizeClaudeContextWindow,
+	PROVIDERS,
+	type ProviderCatalogEntry,
+	type ProviderModelOption,
+	type ServiceTier,
+} from 'src/shared/types';
+
+const HARD_CODED_CODEX_MODELS: ProviderModelOption[] = [
+	{ id: 'gpt-5.5', label: 'GPT-5.5', supportsEffort: false },
+	{ id: 'gpt-5.4', label: 'GPT-5.4', supportsEffort: false },
+];
+
+export const SERVER_PROVIDERS: ProviderCatalogEntry[] = PROVIDERS.map((provider) =>
+	provider.id === 'codex'
+		? {
+				...provider,
+				defaultModel: 'gpt-5.5',
+				models: HARD_CODED_CODEX_MODELS,
+			}
+		: provider,
+);
+
+export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+	const entry = SERVER_PROVIDERS.find((candidate) => candidate.id === provider);
+	if (!entry) {
+		throw new Error(`Unknown provider: ${provider}`);
+	}
+	return entry;
+}
+
+export function normalizeServerModel(provider: AgentProvider, model?: string): string {
+	const catalog = getServerProviderCatalog(provider);
+	if (model && catalog.models.some((candidate) => candidate.id === model)) {
+		return model;
+	}
+	return catalog.defaultModel;
+}
+
+export function normalizeClaudeModelOptions(
+	model: string,
+	modelOptions?: ModelOptions,
+	legacyEffort?: string,
+): ClaudeModelOptions {
+	const reasoningEffort = modelOptions?.claude?.reasoningEffort;
+	return {
+		reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
+			? reasoningEffort
+			: isClaudeReasoningEffort(legacyEffort)
+				? legacyEffort
+				: DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+		contextWindow: normalizeClaudeContextWindow(
+			model,
+			modelOptions?.claude?.contextWindow as ClaudeContextWindow | undefined,
+		),
+	};
+}
+
+export function normalizeCodexModelOptions(
+	modelOptions?: ModelOptions,
+	legacyEffort?: string,
+): CodexModelOptions {
+	const reasoningEffort = modelOptions?.codex?.reasoningEffort;
+	return {
+		reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+			? reasoningEffort
+			: isCodexReasoningEffort(legacyEffort)
+				? legacyEffort
+				: DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+		fastMode:
+			typeof modelOptions?.codex?.fastMode === 'boolean'
+				? modelOptions.codex.fastMode
+				: DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
+	};
+}
+
+export function codexServiceTierFromModelOptions(
+	modelOptions: CodexModelOptions,
+): ServiceTier | undefined {
+	return modelOptions.fastMode ? 'fast' : undefined;
+}

package/src/server/quick-response.ts

@@ -0,0 +1,274 @@
+import { homedir } from 'node:os';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getDataRootDir } from '../shared/branding';
+import { CodexAppServerManager } from './codex-app-server';
+
+const CLAUDE_STRUCTURED_TIMEOUT_MS = 5_000;
+
+type JsonSchema = {
+	type: 'object';
+	properties: Record<string, unknown>;
+	required?: readonly string[];
+	additionalProperties?: boolean;
+};
+
+export interface StructuredQuickResponseArgs<T> {
+	task: string;
+	prompt: string;
+	schema: JsonSchema;
+	parse: (value: unknown) => T | null;
+}
+
+export interface ProviderRequest {
+	cwd: string;
+	task: string;
+	prompt: string;
+	schema: JsonSchema;
+}
+
+interface QuickResponseAdapterArgs {
+	codexManager?: CodexAppServerManager;
+	runClaudeStructured?: (args: ProviderRequest) => Promise<unknown | null>;
+	runCodexStructured?: (args: ProviderRequest) => Promise<unknown | null>;
+}
+
+export interface StructuredQuickResponseFailure {
+	provider: 'claude' | 'codex';
+	reason: string;
+}
+
+export interface StructuredQuickResponseResult<T> {
+	value: T | null;
+	failures: StructuredQuickResponseFailure[];
+}
+
+export function getQuickResponseWorkspace(env: Record<string, string | undefined> = process.env) {
+	return getDataRootDir(homedir(), env);
+}
+
+export function parseJsonText(value: string): unknown | null {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+
+	const candidates = [trimmed];
+	const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+
+	if (fencedMatch?.[1]) {
+		candidates.unshift(fencedMatch[1].trim());
+	}
+
+	for (const candidate of candidates) {
+		try {
+			return JSON.parse(candidate);
+		} catch {}
+	}
+
+	return null;
+}
+
+export function structuredOutputFromSdkMessage(message: unknown): unknown | null {
+	if (!message || typeof message !== 'object') return null;
+
+	const record = message as Record<string, unknown>;
+	if (record.type === 'result') {
+		return record.structured_output ?? null;
+	}
+
+	const assistantMessage = record.message;
+	if (!assistantMessage || typeof assistantMessage !== 'object') return null;
+
+	const content = (assistantMessage as { content?: unknown }).content;
+	if (!Array.isArray(content)) return null;
+
+	for (const item of content) {
+		if (!item || typeof item !== 'object') continue;
+		const toolUse = item as Record<string, unknown>;
+
+		if (toolUse.type === 'tool_use' && toolUse.name === 'StructuredOutput') {
+			return toolUse.input ?? null;
+		}
+	}
+
+	return null;
+}
+
+export async function runClaudeStructured(args: ProviderRequest): Promise<unknown | null> {
+	const q = query({
+		prompt: args.prompt,
+		options: {
+			cwd: args.cwd,
+			model: 'haiku',
+			tools: [],
+			systemPrompt: '',
+			effort: 'low',
+			permissionMode: 'bypassPermissions',
+			outputFormat: {
+				type: 'json_schema',
+				schema: args.schema,
+			},
+			env: { ...process.env },
+		},
+	});
+
+	let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+	try {
+		const result = await Promise.race<unknown | null>([
+			(async () => {
+				for await (const message of q) {
+					const structuredOutput = structuredOutputFromSdkMessage(message);
+					if (structuredOutput !== null) {
+						return structuredOutput;
+					}
+				}
+				return null;
+			})(),
+			new Promise<null>((_, reject) => {
+				timeoutHandle = setTimeout(() => {
+					reject(
+						new Error(
+							`Claude structured response timed out after ${CLAUDE_STRUCTURED_TIMEOUT_MS}ms`,
+						),
+					);
+				}, CLAUDE_STRUCTURED_TIMEOUT_MS);
+			}),
+		]);
+
+		return result;
+	} catch {
+		return null;
+	} finally {
+		if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
+		try {
+			q.close();
+		} catch {
+			// Ignore close failures on timed-out or failed quick responses.
+		}
+	}
+}
+
+export async function runCodexStructured(
+	codexManager: CodexAppServerManager,
+	args: ProviderRequest,
+): Promise<unknown | null> {
+	const response = await codexManager.generateStructured({
+		cwd: args.cwd,
+		model: 'gpt-5.4-mini',
+		prompt: `${args.prompt}\n\nReturn JSON only that matches this schema:\n${JSON.stringify(args.schema, null, 2)}`,
+	});
+
+	if (typeof response !== 'string') return null;
+	return parseJsonText(response);
+}
+
+export class QuickResponseAdapter {
+	private readonly codexManager: CodexAppServerManager;
+	private readonly runClaudeStructured: (args: ProviderRequest) => Promise<unknown | null>;
+	private readonly runCodexStructured: (args: ProviderRequest) => Promise<unknown | null>;
+
+	constructor(args: QuickResponseAdapterArgs = {}) {
+		this.codexManager = args.codexManager ?? new CodexAppServerManager();
+		this.runClaudeStructured = args.runClaudeStructured ?? runClaudeStructured;
+
+		this.runCodexStructured =
+			args.runCodexStructured ??
+			((structuredArgs) => runCodexStructured(this.codexManager, structuredArgs));
+	}
+
+	async generateStructured<T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> {
+		const result = await this.generateStructuredWithDiagnostics(args);
+		return result.value;
+	}
+
+	async generateStructuredWithDiagnostics<T>(
+		args: StructuredQuickResponseArgs<T>,
+	): Promise<StructuredQuickResponseResult<T>> {
+		const request = {
+			cwd: getQuickResponseWorkspace(),
+			task: args.task,
+			prompt: args.prompt,
+			schema: args.schema,
+		};
+
+		const failures: StructuredQuickResponseFailure[] = [];
+
+		const claudeResult = await this.tryProvider('claude', args.task, args.parse, () =>
+			this.runClaudeStructured(request),
+		);
+
+		if (claudeResult.value !== null) {
+			return {
+				value: claudeResult.value,
+				failures,
+			};
+		}
+
+		if (claudeResult.failure) {
+			failures.push(claudeResult.failure);
+		}
+
+		const codexResult = await this.tryProvider('codex', args.task, args.parse, () =>
+			this.runCodexStructured(request),
+		);
+
+		if (codexResult.value !== null) {
+			return {
+				value: codexResult.value,
+				failures,
+			};
+		}
+
+		if (codexResult.failure) {
+			failures.push(codexResult.failure);
+		}
+
+		return {
+			value: null,
+			failures,
+		};
+	}
+
+	private async tryProvider<T>(
+		provider: 'claude' | 'codex',
+		task: string,
+		parse: (value: unknown) => T | null,
+		run: () => Promise<unknown | null>,
+	): Promise<{ value: T | null; failure: StructuredQuickResponseFailure | null }> {
+		try {
+			const result = await run();
+			if (result === null) {
+				return {
+					value: null,
+					failure: {
+						provider,
+						reason: `${provider} returned no result for ${task}`,
+					},
+				};
+			}
+
+			const parsed = parse(result);
+			if (parsed === null) {
+				return {
+					value: null,
+					failure: {
+						provider,
+						reason: `${provider} returned invalid structured output for ${task}`,
+					},
+				};
+			}
+
+			return {
+				value: parsed,
+				failure: null,
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				value: null,
+				failure: {
+					provider,
+					reason: `${provider} failed ${task}: ${message}`,
+				},
+			};
+		}
+	}
+}