miko-code 0.1.0

package/src/shared/branding.ts

@@ -0,0 +1,69 @@
+export const APP_NAME = 'Miko';
+export const CLI_COMMAND = 'miko';
+export const DATA_ROOT_NAME = '.miko';
+export const DEV_DATA_ROOT_NAME = '.miko-dev';
+export const PACKAGE_NAME = 'miko-code';
+export const RUNTIME_PROFILE_ENV_VAR = 'MIKO_RUNTIME_PROFILE';
+
+// Read version from package.json - JSON import works in both Bun and Vite
+import pkg from '../../package.json';
+export const SDK_CLIENT_APP = `miko/${pkg.version}`;
+export const LOG_PREFIX = '[miko]';
+export const DEFAULT_NEW_PROJECT_ROOT = `~/${APP_NAME}`;
+
+export type RuntimeProfile = 'dev' | 'prod';
+
+type RuntimeEnv = Record<string, string | undefined> | undefined;
+
+function getRuntimeEnv(): RuntimeEnv {
+	const candidate = globalThis as typeof globalThis & {
+		process?: {
+			env?: Record<string, string | undefined>;
+		};
+	};
+	return candidate.process.env;
+}
+
+export function getRuntimeProfile(env: RuntimeEnv = getRuntimeEnv()): RuntimeProfile {
+	return env?.[RUNTIME_PROFILE_ENV_VAR]?.trim().toLowerCase() === 'dev' ? 'dev' : 'prod';
+}
+
+export function getDataRootName(env: RuntimeEnv = getRuntimeEnv()) {
+	return getRuntimeProfile(env) === 'dev' ? DEV_DATA_ROOT_NAME : DATA_ROOT_NAME;
+}
+
+export function getDataRootDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+	return `${homeDir}/${getDataRootName(env)}`;
+}
+
+export function getDataRootDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+	return `~/${getDataRootName(env)}`;
+}
+
+export function getDataDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDir(homeDir, env)}/data`;
+}
+
+export function getDataDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDirDisplay(env)}/data`;
+}
+
+export function getWorktreesDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDir(homeDir, env)}/worktrees`;
+}
+
+export function getWorktreesDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDirDisplay(env)}/worktrees`;
+}
+
+export function getKeybindingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDir(homeDir, env)}/keybindings.json`;
+}
+
+export function getKeybindingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+	return `${getDataRootDirDisplay(env)}/keybindings.json`;
+}
+
+export function getCliInvocation(arg?: string) {
+	return arg ? `${CLI_COMMAND} ${arg}` : CLI_COMMAND;
+}

package/src/shared/dev-ports.ts

@@ -0,0 +1,100 @@
+export const DEFAULT_DEV_CLIENT_PORT = 5174;
+
+export function getDefaultDevServerPort(clientPort = DEFAULT_DEV_CLIENT_PORT) {
+	return clientPort + 1;
+}
+
+export interface DevArgResolution {
+	clientPort: number;
+	serverPort: number;
+	share: boolean;
+	backendTargetHost: string;
+	allowedHosts: true | string[];
+	serverArgs: string[];
+}
+
+export function resolveDevPorts(args: string[]) {
+	let clientPort = DEFAULT_DEV_CLIENT_PORT;
+
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg !== '--port') continue;
+
+		const next = args[index + 1];
+		if (!next || next.startsWith('-')) {
+			throw new Error('Missing value for --port');
+		}
+
+		clientPort = Number(next);
+	}
+
+	return {
+		clientPort,
+		serverPort: getDefaultDevServerPort(clientPort),
+	};
+}
+
+export function stripPortArg(args: string[]) {
+	const stripped: string[] = [];
+
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg === '--port') {
+			index += 1;
+			continue;
+		}
+
+		stripped.push(arg);
+	}
+	return stripped;
+}
+
+export function parseDevArgs(args: string[], localHostname: string): DevArgResolution {
+	const { clientPort, serverPort } = resolveDevPorts(args);
+	const serverArgs = stripPortArg(args).filter((arg) => arg !== '--share');
+
+	let share = false;
+	let sawHost = false;
+	let sawRemote = false;
+	let backendTargetHost = '127.0.0.1';
+	let allowedAllHosts = false;
+
+	const hosts = new Set<string>(['localhost', '127.0.0.1', '0.0.0.0', localHostname]);
+
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg === '--share') {
+			if (sawHost) throw new Error('--share cannot be used with --host');
+			if (sawRemote) throw new Error('--share cannot be used with --remote');
+			share = true;
+			continue;
+		}
+
+		if (arg === '--remote') {
+			if (share) throw new Error('--share cannot be used with --remote');
+			sawRemote = true;
+			backendTargetHost = '127.0.0.1';
+			allowedAllHosts = true;
+			continue;
+		}
+
+		if (arg !== '--host') continue;
+
+		const next = args[index + 1];
+		if (!next || next.startsWith('-')) continue;
+		if (share) throw new Error('--share cannot be used with --host');
+
+		sawHost = true;
+		hosts.add(next);
+		backendTargetHost = next === '0.0.0.0' ? '127.0.0.1' : next;
+	}
+
+	return {
+		clientPort,
+		serverPort,
+		share,
+		backendTargetHost,
+		allowedHosts: share || allowedAllHosts ? true : [...hosts],
+		serverArgs,
+	};
+}

package/src/shared/ports.ts

@@ -0,0 +1,2 @@
+export const PROD_SERVER_PORT = 3210;
+export const DEV_CLIENT_PORT = 5174;

package/src/shared/protocol.ts

@@ -0,0 +1,217 @@
+import type {
+	AgentProvider,
+	BranchActionFailure,
+	BranchActionSuccess,
+	ChatAttachment,
+	DirectoryListSnapshot,
+	GitHubRepoAvailabilityResult,
+	GithubPublishInfo,
+	KeybindingsSnapshot,
+	ModelOptions,
+	PromptPart,
+	ScratchpadSnapshot,
+	SessionHistoryPage,
+	SessionSnapshot,
+	SidebarSnapshot,
+	UpdateSnapshot,
+	WorkspaceFileSearchResult,
+	WorkspaceSnapshot,
+	WorkspaceVisibilityState,
+} from './types';
+
+export type EditorPreset = 'cursor' | 'vscode' | 'warp' | 'antigravity' | 'custom';
+
+export type EditorOpenSettings =
+	| { preset: Exclude<EditorPreset, 'custom'>; commandTemplate?: string }
+	| { preset: 'custom'; commandTemplate: string };
+
+export type SubscriptionTopic =
+	| { type: 'sidebar' }
+	| { type: 'directories' }
+	| { type: 'update' }
+	| { type: 'keybindings' }
+	| { type: 'workspace'; workspaceId: string }
+	| { type: 'session'; sessionId: string; recentLimit?: number }
+	| { type: 'scratchpad'; workspaceId: string }
+	| { type: 'terminal'; terminalId: string };
+
+export interface TerminalSnapshot {
+	terminalId: string;
+	title: string;
+	cwd: string;
+	shell: string;
+	cols: number;
+	rows: number;
+	scrollback: number;
+	serializedState: string;
+	status: 'running' | 'exited';
+	exitCode: number | null;
+	signal?: number;
+}
+
+export type TerminalEvent =
+	| { type: 'terminal.output'; terminalId: string; data: string }
+	| { type: 'terminal.exit'; terminalId: string; exitCode: number; signal?: number };
+
+export type DirectoryOnboardingResult = BranchActionSuccess | BranchActionFailure;
+
+export type ClientCommand =
+	| {
+			type: 'directory.add';
+			localPath: string;
+			title?: string;
+	  }
+	| { type: 'directory.remove'; directoryId: string }
+	| { type: 'directory.initializeGit'; localPath: string }
+	| { type: 'directory.getGithubPublishInfo'; localPath: string }
+	| { type: 'directory.checkGithubRepoAvailability'; owner: string; name: string }
+	| {
+			type: 'directory.publishToGithub';
+			localPath: string;
+			owner: string;
+			name: string;
+			visibility: 'public' | 'private';
+			description?: string;
+	  }
+	| { type: 'workspace.create'; directoryId: string }
+	| { type: 'workspace.remove'; workspaceId: string }
+	| {
+			type: 'workspace.setVisibility';
+			workspaceId: string;
+			visibilityState: WorkspaceVisibilityState;
+	  }
+	| { type: 'workspace.renameBranch'; workspaceId: string; branchName: string }
+	| { type: 'workspace.continueOnNewBranch'; workspaceId: string }
+	| { type: 'workspace.markRead'; workspaceId: string }
+	| { type: 'workspace.refreshGit'; workspaceId: string; fetchRemote?: boolean }
+	| { type: 'workspace.refreshPrStage'; workspaceId: string }
+	| { type: 'workspace.readDiffPatch'; workspaceId: string; path: string }
+	| { type: 'workspace.discardFile'; workspaceId: string; path: string }
+	| { type: 'workspace.readFile'; workspaceId: string; path: string }
+	| { type: 'file.readExternal'; workspaceId: string; sessionId: string; path: string }
+	| { type: 'workspace.searchFiles'; workspaceId: string; query: string; limit?: number }
+	| { type: 'workspace.listFiles'; workspaceId: string; limit?: number }
+	| { type: 'workspace.commitAndPush'; workspaceId: string; sessionId: string }
+	| { type: 'workspace.pullLatestMain'; workspaceId: string; sessionId: string }
+	| { type: 'workspace.createPr'; workspaceId: string; sessionId: string }
+	| { type: 'workspace.fixCi'; workspaceId: string; sessionId: string }
+	| { type: 'workspace.resolveMergeConflicts'; workspaceId: string; sessionId: string }
+	| { type: 'workspace.markPrReady'; workspaceId: string }
+	| {
+			type: 'workspace.addressReviewComments';
+			workspaceId: string;
+			sessionId: string;
+			commentIds: string[];
+	  }
+	| { type: 'workspace.mergePr'; workspaceId: string }
+	| { type: 'workspace.reviewChanges'; workspaceId: string }
+	| { type: 'workspace.updateScratchpad'; workspaceId: string; content: string }
+	| { type: 'system.ping' }
+	| { type: 'update.check'; force?: boolean }
+	| { type: 'update.install' }
+	| { type: 'settings.readKeybindings' }
+	| { type: 'settings.writeKeybindings'; bindings: KeybindingsSnapshot['bindings'] }
+	| {
+			type: 'system.openExternal';
+			localPath: string;
+			action: 'open_finder' | 'open_terminal' | 'open_editor';
+			line?: number;
+			column?: number;
+			editor?: EditorOpenSettings;
+	  }
+	| { type: 'session.create'; workspaceId: string }
+	| { type: 'session.rename'; sessionId: string; title: string }
+	| { type: 'session.remove'; sessionId: string }
+	| {
+			type: 'session.send';
+			sessionId?: string;
+			workspaceId?: string;
+			provider?: AgentProvider;
+			content: string;
+			attachments?: ChatAttachment[];
+			parts?: PromptPart[];
+			model?: string;
+			modelOptions: ModelOptions;
+			effort?: string;
+			planMode?: boolean;
+	  }
+	| { type: 'session.cancel'; sessionId: string }
+	| { type: 'session.stopDraining'; sessionId: string }
+	| { type: 'session.loadHistory'; sessionId: string; beforeCursor: string; limit: number }
+	| { type: 'session.respondTool'; sessionId: string; toolUseId: string; result: unknown }
+	| { type: 'session.listCommands'; sessionId: string; provider: AgentProvider }
+	| { type: 'session.dequeue'; sessionId: string; messageId: string }
+	| {
+			type: 'terminal.create';
+			workspaceId: string;
+			terminalId: string;
+			cols: number;
+			rows: number;
+			scrollback: number;
+	  }
+	| { type: 'terminal.input'; terminalId: string; data: string }
+	| { type: 'terminal.resize'; terminalId: string; cols: number; rows: number }
+	| { type: 'terminal.close'; terminalId: string };
+
+export type ClientEnvelope =
+	| { type: 'subscribe'; id: string; topic: SubscriptionTopic }
+	| { type: 'unsubscribe'; id: string }
+	| { type: 'command'; id: string; command: ClientCommand };
+
+export type ServerSnapshot =
+	| { type: 'sidebar'; data: SidebarSnapshot }
+	| { type: 'directories'; data: DirectoryListSnapshot }
+	| { type: 'update'; data: UpdateSnapshot }
+	| { type: 'keybindings'; data: KeybindingsSnapshot }
+	| { type: 'workspace'; data: WorkspaceSnapshot | null }
+	| { type: 'session'; data: SessionSnapshot | null }
+	| { type: 'scratchpad'; data: ScratchpadSnapshot }
+	| { type: 'terminal'; data: TerminalSnapshot | null };
+
+export type ServerEnvelope =
+	| { type: 'snapshot'; id: string; snapshot: ServerSnapshot }
+	| { type: 'event'; id: string; event: TerminalEvent }
+	| {
+			type: 'ack';
+			id: string;
+			result?:
+				| unknown
+				| SessionHistoryPage
+				| DirectoryOnboardingResult
+				| GithubPublishInfo
+				| GitHubRepoAvailabilityResult
+				| WorkspaceFileSearchResult[];
+	  }
+	| { type: 'error'; id?: string; message: string };
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return Boolean(value && typeof value === 'object');
+}
+
+function isClientCommand(value: unknown): value is ClientCommand {
+	if (!isObject(value) || typeof value.type !== 'string') return false;
+	if (value.type === 'workspace.continueOnNewBranch') {
+		return typeof value.workspaceId === 'string' && value.workspaceId.length > 0;
+	}
+	return true;
+}
+
+export function isClientEnvelope(value: unknown): value is ClientEnvelope {
+	if (!isObject(value)) return false;
+	const candidate = value as Partial<ClientEnvelope>;
+	if (typeof candidate.id !== 'string') return false;
+
+	if (candidate.type === 'subscribe') {
+		return Boolean(candidate.topic && typeof candidate.topic === 'object');
+	}
+
+	if (candidate.type === 'unsubscribe') {
+		return true;
+	}
+
+	if (candidate.type === 'command') {
+		return isClientCommand(candidate.command);
+	}
+
+	return false;
+}

package/src/shared/tools.ts

@@ -0,0 +1,324 @@
+import type {
+	AskUserQuestionAnswerMap,
+	AskUserQuestionItem,
+	AskUserQuestionToolResult,
+	HydratedToolCall,
+	NormalizedToolCall,
+	ReadFileToolResult,
+	TodoItem,
+} from './types';
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+	return value as Record<string, unknown>;
+}
+
+export function normalizeToolCall(args: {
+	toolName: string;
+	toolId: string;
+	input: Record<string, unknown>;
+}): NormalizedToolCall {
+	const { toolName, toolId, input } = args;
+
+	switch (toolName) {
+		case 'AskUserQuestion':
+			return {
+				kind: 'tool',
+				toolKind: 'ask_user_question',
+				toolName,
+				toolId,
+				input: {
+					questions: Array.isArray(input.questions)
+						? (input.questions as AskUserQuestionItem[])
+						: [],
+				},
+				rawInput: input,
+			};
+		case 'ExitPlanMode':
+			return {
+				kind: 'tool',
+				toolKind: 'exit_plan_mode',
+				toolName,
+				toolId,
+				input: {
+					plan: typeof input.plan === 'string' ? input.plan : undefined,
+					summary: typeof input.summary === 'string' ? input.summary : undefined,
+				},
+				rawInput: input,
+			};
+		case 'TodoWrite':
+			return {
+				kind: 'tool',
+				toolKind: 'todo_write',
+				toolName,
+				toolId,
+				input: {
+					todos: Array.isArray(input.todos) ? (input.todos as TodoItem[]) : [],
+				},
+				rawInput: input,
+			};
+		case 'Skill':
+			return {
+				kind: 'tool',
+				toolKind: 'skill',
+				toolName,
+				toolId,
+				input: {
+					skill: typeof input.skill === 'string' ? input.skill : '',
+				},
+				rawInput: input,
+			};
+		case 'Glob':
+			return {
+				kind: 'tool',
+				toolKind: 'glob',
+				toolName,
+				toolId,
+				input: {
+					pattern: typeof input.pattern === 'string' ? input.pattern : '',
+				},
+				rawInput: input,
+			};
+		case 'Bash':
+			return {
+				kind: 'tool',
+				toolKind: 'bash',
+				toolName,
+				toolId,
+				input: {
+					command: typeof input.command === 'string' ? input.command : '',
+					description: typeof input.description === 'string' ? input.description : undefined,
+					timeoutMs: typeof input.timeout === 'number' ? input.timeout : undefined,
+					runInBackground: Boolean(input.run_in_background),
+				},
+				rawInput: input,
+			};
+		case 'WebSearch':
+			return {
+				kind: 'tool',
+				toolKind: 'web_search',
+				toolName,
+				toolId,
+				input: {
+					query: typeof input.query === 'string' ? input.query : '',
+				},
+				rawInput: input,
+			};
+		case 'Read':
+			return {
+				kind: 'tool',
+				toolKind: 'read_file',
+				toolName,
+				toolId,
+				input: {
+					filePath: typeof input.file_path === 'string' ? input.file_path : '',
+				},
+				rawInput: input,
+			};
+		case 'Write':
+			return {
+				kind: 'tool',
+				toolKind: 'write_file',
+				toolName,
+				toolId,
+				input: {
+					filePath: typeof input.file_path === 'string' ? input.file_path : '',
+					content: typeof input.content === 'string' ? input.content : '',
+				},
+				rawInput: input,
+			};
+		case 'Edit':
+			return {
+				kind: 'tool',
+				toolKind: 'edit_file',
+				toolName,
+				toolId,
+				input: {
+					filePath: typeof input.file_path === 'string' ? input.file_path : '',
+					oldString: typeof input.old_string === 'string' ? input.old_string : '',
+					newString: typeof input.new_string === 'string' ? input.new_string : '',
+				},
+				rawInput: input,
+			};
+	}
+
+	const mcpMatch = toolName.match(/^mcp__(.+?)__(.+)$/);
+	if (mcpMatch) {
+		return {
+			kind: 'tool',
+			toolKind: 'mcp_generic',
+			toolName,
+			toolId,
+			input: {
+				server: mcpMatch[1],
+				tool: mcpMatch[2],
+				payload: input,
+			},
+			rawInput: input,
+		};
+	}
+
+	if (typeof input.subagent_type === 'string') {
+		return {
+			kind: 'tool',
+			toolKind: 'subagent_task',
+			toolName,
+			toolId,
+			input: {
+				subagentType: input.subagent_type,
+			},
+			rawInput: input,
+		};
+	}
+
+	return {
+		kind: 'tool',
+		toolKind: 'unknown_tool',
+		toolId,
+		toolName,
+		input: {
+			payload: input,
+		},
+		rawInput: input,
+	};
+}
+
+function parseJsonValue(value: unknown): unknown {
+	if (typeof value !== 'string') return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+
+type ReadStructuredTextBlock = {
+	type: 'text';
+	text: string;
+};
+
+type ReadStructuredImageBlock = {
+	type: 'image';
+	data: string;
+	mimeType?: string;
+};
+
+function normalizedReadBlocks(
+	value: unknown,
+): Array<ReadStructuredTextBlock | ReadStructuredImageBlock> {
+	const blocks =
+		value &&
+		typeof value === 'object' &&
+		'content' in value &&
+		Array.isArray((value as { content?: unknown }).content)
+			? (value as { content: unknown[] }).content
+			: Array.isArray(value)
+				? value
+				: [];
+
+	const normalized: Array<ReadStructuredTextBlock | ReadStructuredImageBlock> = [];
+
+	for (const block of blocks) {
+		if (!block || typeof block !== 'object' || !('type' in block)) {
+			continue;
+		}
+
+		if (block.type === 'text' && typeof block.text === 'string') {
+			normalized.push({ type: 'text', text: block.text });
+		}
+
+		if (block.type === 'image') {
+			if ('data' in block && typeof block.data === 'string') {
+				normalized.push({
+					type: 'image',
+					data: block.data,
+					mimeType: typeof block.mimeType === 'string' ? block.mimeType : undefined,
+				});
+				continue;
+			}
+		}
+
+		if (
+			'source' in block &&
+			block.source &&
+			typeof block.source === 'object' &&
+			'type' in block.source &&
+			block.source.type === 'base64' &&
+			'data' in block.source &&
+			typeof block.source.data === 'string'
+		) {
+			normalized.push({
+				type: 'image',
+				data: block.source.data,
+				mimeType: typeof block.source.media_type === 'string' ? block.source.media_type : undefined,
+			});
+		}
+	}
+
+	return normalized;
+}
+
+export function hydrateToolResult(
+	tool: NormalizedToolCall,
+	raw: unknown,
+): HydratedToolCall['result'] {
+	const parsed = parseJsonValue(raw);
+
+	switch (tool.toolKind) {
+		case 'ask_user_question': {
+			const record = asRecord(parsed);
+			const answers = asRecord(record?.answers) ?? (record ? record : {});
+			return {
+				answers: Object.fromEntries(
+					Object.entries(answers).map(([key, value]) => {
+						if (Array.isArray(value)) {
+							return [key, value.map((entry) => String(entry))];
+						}
+
+						if (
+							value &&
+							typeof value === 'object' &&
+							Array.isArray((value as { answers?: unknown }).answers)
+						) {
+							return [key, (value as { answers: unknown[] }).answers.map((entry) => String(entry))];
+						}
+
+						if (value == null || value === '') {
+							return [key, []];
+						}
+						return [key, [String(value)]];
+					}),
+				) as AskUserQuestionAnswerMap,
+				...(record?.discarded === true ? { discarded: true } : {}),
+			} satisfies AskUserQuestionToolResult;
+		}
+		case 'exit_plan_mode': {
+			const record = asRecord(parsed);
+			return {
+				confirmed: typeof record?.confirmed === 'boolean' ? record.confirmed : undefined,
+				clearContext: typeof record?.clearContext === 'boolean' ? record.clearContext : undefined,
+				message: typeof record?.message === 'string' ? record.message : undefined,
+				...(record?.discarded === true ? { discarded: true } : {}),
+			};
+		}
+		case 'read_file': {
+			if (typeof parsed === 'string') return parsed;
+
+			const blocks = normalizedReadBlocks(parsed);
+			if (blocks.length > 0) {
+				return {
+					content: blocks.flatMap((block) => (block.type === 'text' ? [block.text] : [])).join(''),
+					blocks,
+				} satisfies ReadFileToolResult;
+			}
+
+			const record = asRecord(parsed);
+			return {
+				content:
+					typeof record?.content === 'string' ? record.content : JSON.stringify(parsed, null, 2),
+			} satisfies ReadFileToolResult;
+		}
+		default:
+			return parsed;
+	}
+}