miko-code 0.1.0

package/src/server/github-rest-client.ts

@@ -0,0 +1,176 @@
+import { runCommand } from './diff-store';
+
+export type GitHubRestResult<T> = { status: 'ok'; data: T } | { status: 'not_modified' };
+
+interface GitHubRestClientDeps {
+	fetch?: typeof fetch;
+	runGh?: (args: string[]) => Promise<Awaited<ReturnType<typeof runCommand>>>;
+	now?: () => number;
+}
+
+interface CacheEntry {
+	etag?: string;
+	lastModified?: string;
+	data?: unknown;
+	link?: string | null;
+}
+
+type GitHubRestPageResult<T> =
+	| { status: 'ok'; data: T; link?: string | null }
+	| { status: 'not_modified' };
+
+const TOKEN_TTL_MS = 45 * 60 * 1000;
+const GITHUB_API_BASE_URL = 'https://api.github.com';
+
+function retryAfterMs(headers: Headers, now: () => number) {
+	const retryAfter = headers.get('retry-after');
+	if (retryAfter) {
+		const seconds = Number.parseInt(retryAfter, 10);
+		if (Number.isFinite(seconds) && seconds > 0) return seconds * 1000;
+	}
+
+	const reset = headers.get('x-ratelimit-reset');
+	if (!reset) return null;
+	const resetSeconds = Number.parseInt(reset, 10);
+	if (!Number.isFinite(resetSeconds) || resetSeconds <= 0) return null;
+	return Math.max(0, resetSeconds * 1000 - now());
+}
+
+function isGitHubRateLimitResponse(status: number, headers: Headers, body: string) {
+	if (status === 429) return true;
+	if (status !== 403) return false;
+	if (headers.get('retry-after')) return true;
+	if (headers.get('x-ratelimit-remaining') === '0' && headers.get('x-ratelimit-reset')) return true;
+	const normalizedBody = body.toLowerCase();
+	return normalizedBody.includes('rate limit') || normalizedBody.includes('secondary limit');
+}
+
+function nextLink(linkHeader: string | null | undefined) {
+	if (!linkHeader) return null;
+	for (const part of linkHeader.split(',')) {
+		const match = part.match(/<([^>]+)>;\s*rel="next"/);
+		if (match?.[1]) return match[1];
+	}
+	return null;
+}
+
+export class GitHubRateLimitError extends Error {
+	readonly retryAfterMs: number | null;
+
+	constructor(message: string, retryAfterMs: number | null) {
+		super(message);
+		this.name = 'GitHubRateLimitError';
+		this.retryAfterMs = retryAfterMs;
+	}
+}
+
+export class GitHubRestClient {
+	private readonly fetchImpl: typeof fetch;
+	private readonly runGhCommand: (
+		args: string[],
+	) => Promise<Awaited<ReturnType<typeof runCommand>>>;
+	private readonly now: () => number;
+	private readonly cacheByKey = new Map<string, CacheEntry>();
+	private token: { value: string; expiresAt: number } | null = null;
+
+	constructor(deps: GitHubRestClientDeps = {}) {
+		this.fetchImpl = deps.fetch ?? fetch;
+		this.runGhCommand = deps.runGh ?? ((args) => runCommand(['gh', ...args]));
+		this.now = deps.now ?? Date.now;
+	}
+
+	private async getToken() {
+		if (this.token && this.token.expiresAt > this.now()) return this.token.value;
+
+		const result = await this.runGhCommand(['auth', 'token']);
+		if (result.exitCode !== 0) {
+			throw new Error(
+				[result.stderr.trim(), result.stdout.trim()].filter(Boolean).join('\n') ||
+					'GitHub authentication token lookup failed',
+			);
+		}
+
+		const value = result.stdout.trim();
+		if (!value) throw new Error('GitHub authentication token lookup returned an empty token');
+		this.token = { value, expiresAt: this.now() + TOKEN_TTL_MS };
+		return value;
+	}
+
+	private async requestJsonPage<T>(
+		cacheKey: string,
+		path: string,
+	): Promise<GitHubRestPageResult<T>> {
+		const token = await this.getToken();
+		const headers = new Headers({
+			Accept: 'application/vnd.github+json',
+			Authorization: `Bearer ${token}`,
+			'X-GitHub-Api-Version': '2022-11-28',
+		});
+		const cache = this.cacheByKey.get(cacheKey);
+		if (cache?.etag) headers.set('If-None-Match', cache.etag);
+		else if (cache?.lastModified) headers.set('If-Modified-Since', cache.lastModified);
+
+		const response = await this.fetchImpl(new URL(path, GITHUB_API_BASE_URL), { headers });
+		if (response.status === 304) {
+			if (cache && 'data' in cache) {
+				return {
+					status: 'ok',
+					data: cache.data as T,
+					link: response.headers.get('link') ?? cache.link,
+				};
+			}
+			return { status: 'not_modified' };
+		}
+		const errorBody = response.ok ? '' : await response.text().catch(() => '');
+		if (isGitHubRateLimitResponse(response.status, response.headers, errorBody)) {
+			throw new GitHubRateLimitError(
+				`GitHub REST request was rate limited (${response.status})`,
+				retryAfterMs(response.headers, this.now),
+			);
+		}
+		if (response.status === 401) this.token = null;
+		if (!response.ok) {
+			throw new Error(errorBody.trim() || `GitHub REST request failed (${response.status})`);
+		}
+
+		const data = (await response.json()) as T;
+		const etag = response.headers.get('etag') ?? undefined;
+		const lastModified = response.headers.get('last-modified') ?? undefined;
+		if (etag || lastModified) {
+			this.cacheByKey.set(cacheKey, {
+				etag,
+				lastModified,
+				data,
+				link: response.headers.get('link'),
+			});
+		}
+
+		return { status: 'ok', data, link: response.headers.get('link') };
+	}
+
+	async requestJson<T>(cacheKey: string, path: string): Promise<GitHubRestResult<T>> {
+		const result = await this.requestJsonPage<T>(cacheKey, path);
+		return result.status === 'ok' ? { status: 'ok', data: result.data } : result;
+	}
+
+	async requestJsonPages<TPage, TItem>(
+		cacheKey: string,
+		path: string,
+		getItems: (page: TPage) => TItem[],
+	): Promise<GitHubRestResult<TItem[]>> {
+		const items: TItem[] = [];
+		let page = 1;
+		let currentPath: string | null = path;
+
+		while (currentPath) {
+			const result = await this.requestJsonPage<TPage>(`${cacheKey}:page:${page}`, currentPath);
+			if (result.status === 'not_modified')
+				return page === 1 ? result : { status: 'ok', data: items };
+			items.push(...getItems(result.data));
+			currentPath = nextLink(result.link);
+			page += 1;
+		}
+
+		return { status: 'ok', data: items };
+	}
+}

package/src/server/harness-types.ts

@@ -0,0 +1,24 @@
+import type {
+	AccountInfo,
+	AgentProvider,
+	NormalizedToolCall,
+	TranscriptEntry,
+} from '../shared/types';
+
+export interface HarnessEvent {
+	type: 'transcript' | 'session_token';
+	entry?: TranscriptEntry;
+	sessionToken?: string;
+}
+
+export interface HarnessToolRequest {
+	tool: NormalizedToolCall & { toolKind: 'ask_user_question' | 'exit_plan_mode' };
+}
+
+export interface HarnessTurn {
+	provider: AgentProvider;
+	stream: AsyncIterable<HarnessEvent>;
+	getAccountInfo?: () => Promise<AccountInfo | null>;
+	interrupt: () => Promise<void>;
+	close: () => void;
+}

package/src/server/keybindings.ts

@@ -0,0 +1,203 @@
+import { type FSWatcher, watch } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { getKeybindingsFilePath, LOG_PREFIX } from '../shared/branding';
+import {
+	DEFAULT_KEYBINDINGS,
+	type KeybindingAction,
+	type KeybindingsSnapshot,
+} from '../shared/types';
+
+const KEYBINDING_ACTIONS = Object.keys(DEFAULT_KEYBINDINGS) as KeybindingAction[];
+const MODIFIER_SHORTCUT_PARTS = new Set(['cmd', 'ctrl', 'alt', 'shift']);
+
+type KeybindingsFile = Partial<Record<KeybindingAction, unknown>>;
+
+export class KeybindingsManager {
+	readonly filePath: string;
+	private watcher: FSWatcher | null = null;
+	private snapshot: KeybindingsSnapshot;
+	private readonly listeners = new Set<(snapshot: KeybindingsSnapshot) => void>();
+
+	constructor(filePath = getKeybindingsFilePath(homedir())) {
+		this.filePath = filePath;
+		this.snapshot = createDefaultSnapshot(this.filePath);
+	}
+
+	async initialize() {
+		await mkdir(path.dirname(this.filePath), { recursive: true });
+		const file = Bun.file(this.filePath);
+
+		if (!(await file.exists())) {
+			await Bun.write(this.filePath, `${JSON.stringify(DEFAULT_KEYBINDINGS, null, 2)}\n`);
+		}
+
+		await this.reload();
+		this.startWatching();
+	}
+
+	dispose() {
+		this.watcher?.close();
+		this.watcher = null;
+		this.listeners.clear();
+	}
+
+	getSnapshot() {
+		return this.snapshot;
+	}
+
+	onChange(listener: (snapshot: KeybindingsSnapshot) => void) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+
+	async reload() {
+		const nextSnapshot = await readKeybindingsSnapshot(this.filePath);
+		this.setSnapshot(nextSnapshot);
+	}
+
+	async write(bindings: Partial<Record<KeybindingAction, string[]>>) {
+		const nextSnapshot = normalizeKeybindings(bindings, this.filePath);
+		await mkdir(path.dirname(this.filePath), { recursive: true });
+		await Bun.write(this.filePath, `${JSON.stringify(nextSnapshot.bindings, null, 2)}\n`);
+
+		this.setSnapshot(nextSnapshot);
+		return nextSnapshot;
+	}
+
+	private setSnapshot(snapshot: KeybindingsSnapshot) {
+		this.snapshot = snapshot;
+		for (const listener of this.listeners) {
+			listener(snapshot);
+		}
+	}
+
+	private startWatching() {
+		this.watcher?.close();
+		try {
+			this.watcher = watch(
+				path.dirname(this.filePath),
+				{ persistent: false },
+				(_eventType, filename) => {
+					if (filename && filename !== path.basename(this.filePath)) {
+						return;
+					}
+
+					void this.reload().catch((error: unknown) => {
+						console.warn(`${LOG_PREFIX} Failed to reload keybindings:`, error);
+					});
+				},
+			);
+		} catch (error) {
+			console.warn(`${LOG_PREFIX} Failed to watch keybindings file:`, error);
+			this.watcher = null;
+		}
+	}
+}
+
+export async function readKeybindingsSnapshot(filePath: string) {
+	try {
+		const text = await Bun.file(filePath).text();
+		if (!text.trim()) {
+			return createDefaultSnapshot(filePath, 'Keybindings file was empty. Using defaults.');
+		}
+		const parsed = JSON.parse(text) as KeybindingsFile;
+		return normalizeKeybindings(parsed, filePath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+			return createDefaultSnapshot(filePath);
+		}
+
+		if (error instanceof SyntaxError) {
+			return createDefaultSnapshot(filePath, 'Keybindings file is invalid JSON. Using defaults.');
+		}
+
+		throw error;
+	}
+}
+
+export function normalizeKeybindings(
+	value: KeybindingsFile | null | undefined,
+	filePath = getKeybindingsFilePath(homedir()),
+): KeybindingsSnapshot {
+	const warnings: string[] = [];
+	const source = value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+
+	if (!source) {
+		return createDefaultSnapshot(
+			filePath,
+			'Keybindings file must contain a JSON object. Using defaults.',
+		);
+	}
+
+	const bindings = {} as Record<KeybindingAction, string[]>;
+	for (const action of KEYBINDING_ACTIONS) {
+		const rawValue = source[action];
+		if (!Array.isArray(rawValue)) {
+			bindings[action] = [...DEFAULT_KEYBINDINGS[action]];
+			if (rawValue !== undefined) {
+				warnings.push(`${action} must be an array of shortcut strings`);
+			}
+			continue;
+		}
+
+		const normalized = rawValue
+			.filter((entry): entry is string => typeof entry === 'string')
+			.map((entry) => entry.trim())
+			.map((entry) => entry.toLowerCase())
+			.filter((entry) =>
+				entry.split('+').some((part) => part.trim() && !MODIFIER_SHORTCUT_PARTS.has(part.trim())),
+			)
+			.filter(Boolean);
+
+		if (normalized.length === 0) {
+			bindings[action] = [...DEFAULT_KEYBINDINGS[action]];
+			if (rawValue.length > 0) {
+				warnings.push(`${action} did not contain any valid shortcut strings`);
+			}
+			continue;
+		}
+
+		bindings[action] = normalized;
+	}
+
+	return {
+		bindings,
+		warning:
+			warnings.length > 0
+				? `Some keybindings were reset to defaults: ${warnings.join('; ')}`
+				: null,
+		filePathDisplay: formatDisplayPath(filePath),
+	};
+}
+
+function createDefaultSnapshot(
+	filePath: string,
+	warning: string | null = null,
+): KeybindingsSnapshot {
+	return {
+		bindings: {
+			toggleLeftSidebar: [...DEFAULT_KEYBINDINGS.toggleLeftSidebar],
+			toggleEmbeddedTerminal: [...DEFAULT_KEYBINDINGS.toggleEmbeddedTerminal],
+			toggleRightSidebar: [...DEFAULT_KEYBINDINGS.toggleRightSidebar],
+			addSplitTerminal: [...DEFAULT_KEYBINDINGS.addSplitTerminal],
+			createSessionInCurrentWorkspace: [...DEFAULT_KEYBINDINGS.createSessionInCurrentWorkspace],
+			createWorkspaceInCurrentDirectory: [...DEFAULT_KEYBINDINGS.createWorkspaceInCurrentDirectory],
+			switchToNextWorkspace: [...DEFAULT_KEYBINDINGS.switchToNextWorkspace],
+		},
+		warning,
+		filePathDisplay: formatDisplayPath(filePath),
+	};
+}
+
+export function formatDisplayPath(filePath: string) {
+	const homePath = homedir();
+	if (filePath === homePath) return '~';
+	if (filePath.startsWith(`${homePath}${path.sep}`)) {
+		return `~${filePath.slice(homePath.length)}`;
+	}
+	return filePath;
+}

package/src/server/machine-name.ts

@@ -0,0 +1,22 @@
+import { spawnSync } from 'node:child_process';
+import { hostname } from 'node:os';
+import process from 'node:process';
+
+function runAndRead(command: string, args: string[]) {
+	const result = spawnSync(command, args, { encoding: 'utf8' });
+	if (result.status !== 0) return null;
+	const value = result.stdout.trim();
+	return value || null;
+}
+
+export function getMachineDisplayName() {
+	if (process.platform === 'darwin') {
+		const computerName = runAndRead('scutil', ['--get', 'ComputerName']);
+		if (computerName) {
+			return computerName;
+		}
+	}
+
+	const rawHostname = hostname().trim();
+	return rawHostname.replace(/\.local$|\.lan$/i, '') || 'This Machine';
+}

package/src/server/paths.ts

@@ -0,0 +1,51 @@
+import { mkdir, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { getDataDir } from '../shared/branding';
+
+export function resolveLocalPath(localPath: string) {
+	const trimmed = localPath.trim();
+	if (!trimmed) {
+		throw new Error('Directory path is required');
+	}
+
+	if (trimmed === '~') {
+		return homedir();
+	}
+
+	if (trimmed.startsWith('~/')) {
+		return path.join(homedir(), trimmed.slice(2));
+	}
+
+	return path.resolve(trimmed);
+}
+
+export async function requireExistingDirectoryPath(localPath: string) {
+	const resolvedPath = resolveLocalPath(localPath);
+	let info: Awaited<ReturnType<typeof stat>>;
+	try {
+		info = await stat(resolvedPath);
+	} catch {
+		throw new Error(`Directory not found: ${resolvedPath}`);
+	}
+
+	if (!info.isDirectory()) {
+		throw new Error('Directory path must be a directory');
+	}
+
+	return resolvedPath;
+}
+
+export async function ensureDirectoryPath(localPath: string) {
+	const resolvedPath = resolveLocalPath(localPath);
+	await mkdir(resolvedPath, { recursive: true });
+
+	const info = await stat(resolvedPath);
+	if (!info.isDirectory()) {
+		throw new Error('Directory path must be a directory');
+	}
+}
+
+export function getWorkspaceUploadDir(workspaceId: string, dataDir = getDataDir(homedir())) {
+	return path.join(resolveLocalPath(dataDir), 'uploads', workspaceId);
+}