zigmini 0.9.0-beta.3 → 1.0.0-beta.1

package/src/update/state.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { PROTOCOL_VERSION, type Envelope } from "../protocol.ts";
+import { say, type Text } from "../server-text.ts";
 
 /**
  * The files the update request (gateway) and the update helper (one-shot launchd job) share under `<home>/update/`
@@ -23,18 +24,27 @@ export const STALE_MS = 20 * 60_000;
 
 export type Phase = "queued" | "pack" | "install" | "consent" | "engine" | "restart" | "health" | "rollback" | "done";
 
-export const PHASE_LABELS: Readonly<Record<Phase, string>> = {
-	queued: "업데이트 도우미를 시작하는 중",
-	pack: "지금 버전을 되돌리기용으로 저장하는 중",
-	install: "새 버전을 설치하는 중",
-	consent: "권한 동의 기록을 바꾸는 중",
-	engine: "새 엔진을 설치하는 중",
-	restart: "게이트웨이와 브리지를 다시 시작하는 중",
-	health: "새 버전의 상태를 확인하는 중",
-	rollback: "실패해 이전 버전으로 되돌리는 중",
-	done: "끝남",
+const PHASE_TEXTS: Readonly<Record<Phase, Text>> = {
+	queued: { en: "Starting the update helper", ko: "업데이트 도우미를 시작하는 중" },
+	pack: { en: "Saving the current version for rollback", ko: "지금 버전을 되돌리기용으로 저장하는 중" },
+	install: { en: "Installing the new version", ko: "새 버전을 설치하는 중" },
+	consent: { en: "Updating the permission consent record", ko: "권한 동의 기록을 바꾸는 중" },
+	engine: { en: "Installing the new engine", ko: "새 엔진을 설치하는 중" },
+	restart: { en: "Restarting the gateway and bridge", ko: "게이트웨이와 브리지를 다시 시작하는 중" },
+	health: { en: "Checking the health of the new version", ko: "새 버전의 상태를 확인하는 중" },
+	rollback: { en: "Update failed; rolling back to the previous version", ko: "실패해 이전 버전으로 되돌리는 중" },
+	done: { en: "Done", ko: "끝남" },
 };
 
+/** The Korean step labels, for the terminal command (src/update/cli.ts, out of the server-text scope). */
+export const PHASE_LABELS: Readonly<Record<Phase, string>> = Object.fromEntries(
+	Object.entries(PHASE_TEXTS).map(([phase, text]) => [phase, text.ko])) as Record<Phase, string>;
+
+/** The update progress label of a step in the saved UI language, made when it is asked for. */
+export function phaseLabel(phase: Phase): string {
+	return say(PHASE_TEXTS[phase]);
+}
+
 export type Origin = "web" | "app" | "cli";
 
 export interface UpdateRequest {
@@ -127,7 +137,7 @@ export function updateRunning(state: UpdateState | null, now: number): boolean {
 
 export function progressEnvelope(state: UpdateState, now = new Date()): Envelope<typeof UPDATE_PROGRESS, { id: string; from: string; to: string; phase: Phase; label: string }> {
 	return { v: PROTOCOL_VERSION, id: `up${now.getTime().toString(36)}`, ts: now.toISOString(), conv: "*", type: UPDATE_PROGRESS,
-		data: { id: state.id, from: state.from, to: state.to, phase: state.phase, label: PHASE_LABELS[state.phase] } };
+		data: { id: state.id, from: state.from, to: state.to, phase: state.phase, label: phaseLabel(state.phase) } };
 }
 
 export function resultEnvelope(id: string, result: UpdateResult, now = new Date()): Envelope<typeof UPDATE_RESULT, UpdateResult & { id: string }> {

package/src/update/strategy.ts

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { say, type Text } from "../server-text.ts";
 import type { UpdateRequest } from "./state.ts";
 
 /**
@@ -12,6 +13,12 @@ import type { UpdateRequest } from "./state.ts";
 
 export type RestartTarget = "bridge" | "gateway";
 
+const RESTART_FAILED: Text = { en: "Restarting {target} failed: {error}", ko: "{target} 재시작 실패: {error}" };
+const NO_REQUEST: Text = { en: "There is no update request", ko: "업데이트 요청이 없습니다" };
+const HANDOFF_FAILED_TEXT: Text = { en: "Generation handoff failed", ko: "세대 전환 실패" };
+const HANDOFF_UNREADABLE: Text = { en: "Generation handoff failed (could not read the result)", ko: "세대 전환 실패(결과를 읽지 못함)" };
+const HANDOFF_NO_RESULT: Text = { en: "The generation handoff command ended without a result (exit code {code})", ko: "세대 전환 명령이 결과 없이 끝났습니다(종료 코드 {code})" };
+
 export interface StrategyContext {
 	/** Restarts one launchd agent; resolves to an error text, or null on success. */
 	readonly restart: (target: RestartTarget) => Promise<string | null>;
@@ -38,7 +45,7 @@ export const restartAll: UpdateStrategy = {
 	async run(ctx) {
 		for (const target of ["bridge", "gateway"] as const) {
 			const error = await ctx.restart(target);
-			if (error !== null) return `${target} 재시작 실패: ${error}`;
+			if (error !== null) return say(RESTART_FAILED, { target, error });
 			ctx.log(`재시작함: ${target}`);
 		}
 		return null;
@@ -70,7 +77,7 @@ export function externalHandoff(spawn: (requestId: string) => HandoffProcess): U
 	return {
 		name: HANDOFF_STRATEGY,
 		async run(ctx) {
-			if (!ctx.request) return "업데이트 요청이 없습니다";
+			if (!ctx.request) return say(NO_REQUEST);
 			const proc = spawn(ctx.request.id);
 			child = proc;
 			for await (const line of proc.lines) {
@@ -79,14 +86,14 @@ export function externalHandoff(spawn: (requestId: string) => HandoffProcess): U
 				if (line.startsWith(HANDOFF_FAILED)) {
 					try {
 						const failure = JSON.parse(line.slice(HANDOFF_FAILED.length)) as { untouched?: unknown; message?: unknown };
-						const message = typeof failure.message === "string" ? failure.message : "세대 전환 실패";
+						const message = typeof failure.message === "string" ? failure.message : say(HANDOFF_FAILED_TEXT);
 						return failure.untouched === true ? { untouched: true, message } : message;
 					} catch {
-						return "세대 전환 실패(결과를 읽지 못함)";
+						return say(HANDOFF_UNREADABLE);
 					}
 				}
 			}
-			return `세대 전환 명령이 결과 없이 끝났습니다(종료 코드 ${await proc.exited})`;
+			return say(HANDOFF_NO_RESULT, { code: await proc.exited });
 		},
 		async settle() {
 			if (child !== null) await child.exited;

package/src/update/target.ts

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseNotice, type PermissionNotice } from "../consent/consent.ts";
 import type { Env } from "../runtime/paths.ts";
+import { say, type Text } from "../server-text.ts";
 import { parseVersion, registryUrl } from "./check.ts";
 import { HANDOFF_STRATEGY } from "./strategy.ts";
 import { engineRevision } from "../engine/build-id.ts";
@@ -28,6 +29,22 @@ export interface TargetInfo {
 
 export class TargetError extends Error {}
 
+const NO_PACKAGE_JSON: Text = { en: "The target package has no package.json", ko: "대상 패키지에 package.json이 없습니다" };
+const PACKAGE_JSON_UNREADABLE: Text = { en: "Could not read the target package's package.json", ko: "대상 패키지의 package.json을 읽지 못했습니다" };
+const NOT_ZIGMINI: Text = { en: "The target package is not zigmini", ko: "대상 패키지가 zigmini가 아닙니다" };
+const BAD_VERSION: Text = { en: "The target package's version is not valid", ko: "대상 패키지의 버전이 올바르지 않습니다" };
+const NO_NOTICE: Text = { en: "The target package has no permission notice", ko: "대상 패키지에 권한 안내문이 없습니다" };
+const BAD_REVISION: Text = { en: "The target package's engine revision is not valid", ko: "대상 패키지의 엔진 리비전이 올바르지 않습니다" };
+const NOT_A_VERSION: Text = { en: "Not a version format: {requested}", ko: "버전 형식이 아닙니다: {requested}" };
+const SOURCE_MISMATCH: Text = { en: "Version {actual} of ZIGMINI_UPDATE_SOURCE differs from the requested {requested}", ko: "ZIGMINI_UPDATE_SOURCE의 버전 {actual}이 요청 {requested}와 다릅니다" };
+const REGISTRY_UNREACHABLE: Text = { en: "Could not connect to the registry: {error}", ko: "레지스트리에 연결하지 못했습니다: {error}" };
+const REGISTRY_HTTP: Text = { en: "Registry HTTP {status}", ko: "레지스트리 HTTP {status}" };
+const NO_LATEST: Text = { en: "The registry has no latest version", ko: "레지스트리에 latest 버전이 없습니다" };
+const NO_SUCH_VERSION: Text = { en: "The registry has no {version}", ko: "레지스트리에 {version}이 없습니다" };
+const DOWNLOAD_FAILED: Text = { en: "Could not download the {version} package", ko: "{version} 패키지를 받지 못했습니다" };
+const BAD_INTEGRITY: Text = { en: "The integrity value of the {version} package does not match", ko: "{version} 패키지의 무결성 값이 맞지 않습니다" };
+const DOWNLOAD_MISMATCH: Text = { en: "The downloaded package's version {actual} differs from {version}", ko: "받은 패키지의 버전 {actual}이 {version}과 다릅니다" };
+
 export interface TargetDeps {
 	readonly env: Env;
 	readonly fetch: typeof fetch;
@@ -38,27 +55,27 @@ export interface TargetDeps {
 }
 
 export function parseTarget(pkgText: string | null, compatText: string | null, source: string, manifestText?: string | null): TargetInfo {
-	if (pkgText === null) throw new TargetError("대상 패키지에 package.json이 없습니다");
+	if (pkgText === null) throw new TargetError(say(NO_PACKAGE_JSON));
 	let pkg: { name?: unknown; version?: unknown; zigmini?: { permissionNotice?: unknown; updateStrategies?: unknown } };
 	try {
 		pkg = JSON.parse(pkgText);
 	} catch {
-		throw new TargetError("대상 패키지의 package.json을 읽지 못했습니다");
+		throw new TargetError(say(PACKAGE_JSON_UNREADABLE));
 	}
-	if (pkg.name !== "zigmini") throw new TargetError("대상 패키지가 zigmini가 아닙니다");
-	if (typeof pkg.version !== "string" || parseVersion(pkg.version) === null) throw new TargetError("대상 패키지의 버전이 올바르지 않습니다");
+	if (pkg.name !== "zigmini") throw new TargetError(say(NOT_ZIGMINI));
+	if (typeof pkg.version !== "string" || parseVersion(pkg.version) === null) throw new TargetError(say(BAD_VERSION));
 	let notice: PermissionNotice;
 	try {
 		notice = parseNotice(pkg.zigmini?.permissionNotice);
 	} catch {
-		throw new TargetError("대상 패키지에 권한 안내문이 없습니다");
+		throw new TargetError(say(NO_NOTICE));
 	}
 	let engine = parseEnginePin(compatText);
 	if (engine !== null && manifestText != null) {
 		try {
 			engine = { ...engine, revision: engineRevision(JSON.parse(manifestText).revision) };
 		} catch {
-			throw new TargetError("대상 패키지의 엔진 리비전이 올바르지 않습니다");
+			throw new TargetError(say(BAD_REVISION));
 		}
 	}
 	const strategies = pkg.zigmini?.updateStrategies;
@@ -91,32 +108,32 @@ export function integrityMatches(bytes: Uint8Array, integrity: string): boolean
 }
 
 export async function resolveTarget(requested: string, deps: TargetDeps): Promise<TargetInfo> {
-	if (requested !== "latest" && parseVersion(requested) === null) throw new TargetError(`버전 형식이 아닙니다: ${requested}`);
+	if (requested !== "latest" && parseVersion(requested) === null) throw new TargetError(say(NOT_A_VERSION, { requested }));
 	const local = deps.env.ZIGMINI_UPDATE_SOURCE;
 	if (local) {
 		const target = inspect(local, local, deps);
-		if (requested !== "latest" && requested !== target.version) throw new TargetError(`ZIGMINI_UPDATE_SOURCE의 버전 ${target.version}이 요청 ${requested}와 다릅니다`);
+		if (requested !== "latest" && requested !== target.version) throw new TargetError(say(SOURCE_MISMATCH, { actual: target.version, requested }));
 		return target;
 	}
 	const url = registryUrl(deps.env);
 	const res = await deps.fetch(url, { signal: AbortSignal.timeout(15_000) }).catch((error: unknown) => {
-		throw new TargetError(`레지스트리에 연결하지 못했습니다: ${error instanceof Error ? error.message : String(error)}`);
+		throw new TargetError(say(REGISTRY_UNREACHABLE, { error: error instanceof Error ? error.message : String(error) }));
 	});
-	if (!res.ok) throw new TargetError(`레지스트리 HTTP ${res.status}`);
+	if (!res.ok) throw new TargetError(say(REGISTRY_HTTP, { status: res.status }));
 	const doc = await res.json().catch(() => null) as { "dist-tags"?: { latest?: unknown }; versions?: Record<string, { dist?: { tarball?: unknown; integrity?: unknown } }> } | null;
 	const version = requested === "latest" ? doc?.["dist-tags"]?.latest : requested;
-	if (typeof version !== "string" || parseVersion(version) === null) throw new TargetError("레지스트리에 latest 버전이 없습니다");
+	if (typeof version !== "string" || parseVersion(version) === null) throw new TargetError(say(NO_LATEST));
 	const dist = doc?.versions?.[version]?.dist;
-	if (typeof dist?.tarball !== "string" || typeof dist.integrity !== "string") throw new TargetError(`레지스트리에 ${version}이 없습니다`);
+	if (typeof dist?.tarball !== "string" || typeof dist.integrity !== "string") throw new TargetError(say(NO_SUCH_VERSION, { version }));
 	const download = await deps.fetch(dist.tarball, { signal: AbortSignal.timeout(120_000) }).catch(() => null);
-	if (download === null || !download.ok) throw new TargetError(`${version} 패키지를 받지 못했습니다`);
+	if (download === null || !download.ok) throw new TargetError(say(DOWNLOAD_FAILED, { version }));
 	const bytes = new Uint8Array(await download.arrayBuffer());
-	if (!integrityMatches(bytes, dist.integrity)) throw new TargetError(`${version} 패키지의 무결성 값이 맞지 않습니다`);
+	if (!integrityMatches(bytes, dist.integrity)) throw new TargetError(say(BAD_INTEGRITY, { version }));
 	mkdirSync(deps.dir, { recursive: true });
 	const file = join(deps.dir, `target-${version}.tgz`);
 	writeFileSync(file, bytes);
 	const target = inspect(file, `zigmini@${version}`, deps);
-	if (target.version !== version) throw new TargetError(`받은 패키지의 버전 ${target.version}이 ${version}과 다릅니다`);
+	if (target.version !== version) throw new TargetError(say(DOWNLOAD_MISMATCH, { actual: target.version, version }));
 	return target;
 }
 

package/src/usage.ts

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { say, type Text } from "./server-text.ts";
 
 /**
  * `/usage` (improvement 30): the gateway answers it with a notice and never forwards it to omo. It reads the agent
@@ -7,9 +8,33 @@ import { join } from "node:path";
  * and asks each account's provider usage API in parallel. Tokens, emails and account ids never leave this module:
  * the report names an account by its slot name only.
  */
-export const USAGE_COMMAND = { name: "usage", description: "로그인한 모델 계정 사용량 보기 (게이트웨이가 바로 답함)", source: "extension" };
-
-export const USAGE_UNAVAILABLE = "이 실행 방식에서는 쓸 수 없습니다(이전 뒤 사용)";
+const USAGE_DESCRIPTION: Text = { en: "View usage for signed-in model accounts (answered by the gateway)", ko: "로그인한 모델 계정 사용량 보기 (게이트웨이가 바로 답함)" };
+export const USAGE_COMMAND = { name: "usage", get description() { return say(USAGE_DESCRIPTION); }, source: "extension" };
+
+const USAGE_UNAVAILABLE_TEXT: Text = { en: "Unavailable in this run mode (use after migration)", ko: "이 실행 방식에서는 쓸 수 없습니다(이전 뒤 사용)" };
+export const USAGE_UNAVAILABLE: Text = USAGE_UNAVAILABLE_TEXT;
+
+const USAGE_TEXT = {
+	title: { en: "Account usage", ko: "계정 사용량" },
+	noAccounts: { en: "No signed-in model accounts.", ko: "로그인한 모델 계정이 없습니다." },
+	emptyAuth: { en: "No signed-in model accounts (auth.json is missing from the agent folder).", ko: "로그인한 모델 계정이 없습니다 (에이전트 폴더에 auth.json 없음)." },
+	brokenAuth: { en: "Could not read auth.json (invalid JSON).", ko: "auth.json을 읽지 못했습니다 (JSON 형식 오류)." },
+	account: { en: "· {slot} ({provider}){pinned}", ko: "· {slot} ({provider}){pinned}" },
+	pinned: { en: " [pinned]", ko: " [고정]" },
+	remaining: { en: "{label} remaining {percent}%", ko: "{label} 남음 {percent}%" },
+	period: { en: "Period", ko: "기간" },
+	reset: { en: " (resets {time})", ko: " (초기화 {time})" },
+	lastUsed: { en: " · Last used {time}", ko: " · 최근 사용 {time}" },
+	failed: { en: "Lookup failed ({detail})", ko: "조회 실패 ({detail})" },
+	unknown: { en: "Unknown", ko: "알 수 없음" },
+	expired: { en: "Token expired (the engine will refresh it on next use)", ko: "토큰 만료 (엔진이 다음 사용 때 갱신)" },
+	unsupported: { en: "Usage API unavailable", ko: "사용량 API 없음" },
+	noToken: { en: "No token", ko: "토큰 없음" },
+	http: { en: "HTTP {status}", ko: "HTTP {status}" },
+	noUsage: { en: "No usage in response", ko: "응답에 사용량 없음" },
+	timeout: { en: "Timed out", ko: "시간 초과" },
+	connection: { en: "Connection failed", ko: "연결 실패" },
+} satisfies Record<string, Text>;
 
 export function isUsageCommand(text: string): boolean {
 	return /^\/usage$/i.test(text.trim());
@@ -107,7 +132,7 @@ function readAccounts(auth: unknown): Account[] {
 			accounts.push({
 				provider,
 				name,
-				slot: name.includes("@") ? `계정 ${index + 1}` : name,
+				slot: name.includes("@") ? say({ en: "Account {number}", ko: "계정 {number}" }, { number: index + 1 }) : name,
 				pinned: text(entry.pinned) === name,
 				kind: Object.hasOwn(USAGE_PROVIDERS, provider) ? USAGE_PROVIDERS[provider]! : null,
 				access,
@@ -248,19 +273,19 @@ async function lookup(account: Account, now: number, deps: UsageDeps): Promise<U
 	const base = { provider: account.provider, slot: account.slot, pinned: account.pinned, windows: [] };
 	if (account.kind === null) return { ...base, status: "unsupported" };
 	if (account.expires !== null && account.expires <= now) return { ...base, status: "expired" };
-	if (account.access === null) return { ...base, status: "failed", detail: "토큰 없음" };
+	if (account.access === null) return { ...base, status: "failed", detail: say(USAGE_TEXT.noToken) };
 	try {
 		const response = await (deps.fetch ?? fetch)((deps.endpoints ?? USAGE_ENDPOINTS)[account.kind], {
 			headers: headersFor(account),
 			redirect: "error",
 			signal: AbortSignal.timeout(deps.timeoutMs ?? 10_000),
 		});
-		if (!response.ok) return { ...base, status: "failed", detail: `HTTP ${response.status}` };
+		if (!response.ok) return { ...base, status: "failed", detail: say(USAGE_TEXT.http, { status: response.status }) };
 		const windows = windowsOf(account.kind, await response.json().catch(() => undefined), now);
-		return windows.length > 0 ? { ...base, status: "ok", windows } : { ...base, status: "failed", detail: "응답에 사용량 없음" };
+		return windows.length > 0 ? { ...base, status: "ok", windows } : { ...base, status: "failed", detail: say(USAGE_TEXT.noUsage) };
 	} catch (error) {
 		const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
-		return { ...base, status: "failed", detail: timedOut ? "시간 초과" : "연결 실패" };
+		return { ...base, status: "failed", detail: say(timedOut ? USAGE_TEXT.timeout : USAGE_TEXT.connection) };
 	}
 }
 
@@ -279,19 +304,17 @@ function stamp(ms: number, timeZone: string | undefined): string {
 	return `${part("month")}/${part("day")} ${part("hour")}:${part("minute")}`;
 }
 
-const STATUS_TEXT = { expired: "토큰 만료 (엔진이 다음 사용 때 갱신)", unsupported: "사용량 API 없음" } as const;
-
 export function formatUsageReport(rows: readonly UsageRow[], timeZone?: string): string {
-	if (rows.length === 0) return "계정 사용량\n로그인한 모델 계정이 없습니다.";
-	const lines = ["계정 사용량"];
+	if (rows.length === 0) return `${say(USAGE_TEXT.title)}\n${say(USAGE_TEXT.noAccounts)}`;
+	const lines = [say(USAGE_TEXT.title)];
 	for (const row of rows) {
-		const name = `· ${row.slot} (${row.provider})${row.pinned ? " [고정]" : ""}`;
+		const name = say(USAGE_TEXT.account, { slot: row.slot, provider: row.provider, pinned: row.pinned ? say(USAGE_TEXT.pinned) : "" });
 		let body: string;
 		if (row.status === "ok") {
-			body = row.windows.map((window) => `${window.label} 남음 ${window.remaining}%${window.resetsAt === null ? "" : ` (초기화 ${stamp(window.resetsAt, timeZone)})`}`).join(" · ");
-		} else if (row.status === "failed") body = `조회 실패 (${row.detail ?? "알 수 없음"})`;
-		else body = STATUS_TEXT[row.status];
-		const recent = row.lastUsedAt === undefined ? "" : ` · 최근 사용 ${stamp(row.lastUsedAt, timeZone)}`;
+			body = row.windows.map((window) => `${say(USAGE_TEXT.remaining, { label: window.label === "기간" ? say(USAGE_TEXT.period) : window.label, percent: window.remaining })}${window.resetsAt === null ? "" : say(USAGE_TEXT.reset, { time: stamp(window.resetsAt, timeZone) })}`).join(" · ");
+		} else if (row.status === "failed") body = say(USAGE_TEXT.failed, { detail: row.detail ?? say(USAGE_TEXT.unknown) });
+		else body = say(USAGE_TEXT[row.status]);
+		const recent = row.lastUsedAt === undefined ? "" : say(USAGE_TEXT.lastUsed, { time: stamp(row.lastUsedAt, timeZone) });
 		lines.push(`${name}: ${body}${recent}`);
 	}
 	return lines.join("\n");
@@ -318,10 +341,10 @@ export function createUsageReport(deps: UsageDeps & {
 	timeZone?: string;
 }): () => Promise<string> {
 	return async () => {
-		if (deps.inContainer) return `계정 사용량\n${USAGE_UNAVAILABLE}`;
+		if (deps.inContainer) return `${say(USAGE_TEXT.title)}\n${say(USAGE_UNAVAILABLE)}`;
 		const auth = readJson(join(deps.dir, "auth.json"));
-		if ("missing" in auth) return "계정 사용량\n로그인한 모델 계정이 없습니다 (에이전트 폴더에 auth.json 없음).";
-		if ("broken" in auth) return "계정 사용량\nauth.json을 읽지 못했습니다 (JSON 형식 오류).";
+		if ("missing" in auth) return `${say(USAGE_TEXT.title)}\n${say(USAGE_TEXT.emptyAuth)}`;
+		if ("broken" in auth) return `${say(USAGE_TEXT.title)}\n${say(USAGE_TEXT.brokenAuth)}`;
 		const pool = readJson(join(deps.dir, "credential-pool-state.json"));
 		const rows = await collectUsage(auth.value, "value" in pool ? pool.value : null, (deps.now ?? Date.now)(), deps);
 		return formatUsageReport(rows, deps.timeZone);

package/src/version.ts

@@ -1,9 +1,32 @@
 import { readFileSync } from "node:fs";
 import { CORE_NAME, ENGINE_PACKAGE, PLUGIN, OMO_REGISTRY_URL, readEnginePin, formatEnginePin, type EnginePin } from "./engine/index.ts";
+import { say, type Text } from "./server-text.ts";
 export { OMO_REGISTRY_URL } from "./engine/index.ts";
 
 /** `/version`: the gateway answers it with a notice and never forwards it to omo. */
-export const VERSION_COMMAND = { name: "version", description: "게이트웨이·엔진 버전 보기 (게이트웨이가 바로 답함)", source: "extension" };
+const VERSION_DESCRIPTION: Text = { en: "View gateway and engine versions (answered by the gateway)", ko: "게이트웨이·엔진 버전 보기 (게이트웨이가 바로 답함)" };
+export const VERSION_COMMAND = { name: "version", get description() { return say(VERSION_DESCRIPTION); }, source: "extension" };
+
+const VERSION_TEXT = {
+	title: { en: "Version information", ko: "버전 정보" },
+	unknown: { en: "Unknown", ko: "알 수 없음" },
+	build: { en: "Build commit {value}", ko: "빌드 커밋 {value}" },
+	buildUnknown: { en: "Build commit unknown", ko: "빌드 커밋 알 수 없음" },
+	gateway: { en: "· Gateway: {version} ({build})", ko: "· 게이트웨이: {version} ({build})" },
+	omoDisconnected: { en: "· Engine: check failed (engine connection status {status}){pin}", ko: "· 엔진: 확인 실패 (엔진 연결 상태 {status}){pin}" },
+	omoReady: { en: "· Engine: {install}{engine}{pin}", ko: "· 엔진: {install}{engine}{pin}" },
+	installUnknown: { en: "Install path unavailable", ko: "설치 경로 확인 실패" },
+	engineVersion: { en: " ({name} {version})", ko: " ({name} {version})" },
+	pinned: { en: " · Repository-pinned engine {version}", ko: " · 저장소 고정 엔진 {version}" },
+	pinUnavailable: { en: " · Failed to read repository-pinned version", ko: " · 저장소 고정 버전 읽기 실패" },
+	latest: { en: "· Latest engine: {version} (npm {package})", ko: "· 최신 엔진: {version} (npm {package})" },
+	update: { en: "Update available: {current} → {latest} (will not update automatically)", ko: "업데이트 가능: {current} → {latest} (자동으로 업데이트하지 않습니다)" },
+	latestFailed: { en: "· Latest engine: check failed ({detail})", ko: "· 최신 엔진: 확인 실패 ({detail})" },
+	registryHttp: { en: "npm registry HTTP {status}", ko: "npm 레지스트리 HTTP {status}" },
+	registryMissing: { en: "Version missing from npm registry response", ko: "npm 레지스트리 응답에 버전이 없음" },
+	timeout: { en: "Timed out ({seconds} seconds)", ko: "시간 초과 ({seconds}초)" },
+	networkFailure: { en: "Registry request failed", ko: "레지스트리 요청 실패" },
+} satisfies Record<string, Text>;
 
 export function isVersionCommand(text: string): boolean {
 	return /^\/version$/i.test(text.trim());
@@ -75,16 +98,16 @@ export class LatestOmoLookup {
 	private async lookup(): Promise<LatestResult> {
 		try {
 			const res = await this.fetcher(this.url, { signal: AbortSignal.timeout(this.timeoutMs), headers: { accept: "application/json" } });
-			if (!res.ok) return { error: `npm 레지스트리 HTTP ${res.status}` };
+			if (!res.ok) return { error: say(VERSION_TEXT.registryHttp, { status: res.status }) };
 			const body = (await res.json()) as { version?: unknown };
-			if (typeof body.version !== "string" || !semver(body.version)) return { error: "npm 레지스트리 응답에 버전이 없음" };
+			if (typeof body.version !== "string" || !semver(body.version)) return { error: say(VERSION_TEXT.registryMissing) };
 			this.cached = { version: body.version, at: this.now() };
 			return { version: body.version };
 		} catch (error) {
 			if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
-				return { error: `시간 초과 (${this.timeoutMs / 1000}초)` };
+				return { error: say(VERSION_TEXT.timeout, { seconds: this.timeoutMs / 1000 }) };
 			}
-			return { error: error instanceof Error ? error.message : String(error) };
+			return { error: say(VERSION_TEXT.networkFailure) };
 		}
 	}
 }
@@ -100,26 +123,26 @@ export interface VersionFacts {
 }
 
 export function formatVersionReport(facts: VersionFacts): string {
-	const lines = ["버전 정보"];
-	const build = facts.gateway.build ? `빌드 커밋 ${facts.gateway.build}` : "빌드 커밋 알 수 없음";
-	lines.push(`· 게이트웨이: ${facts.gateway.version ?? "알 수 없음"} (${build})`);
+	const lines = [say(VERSION_TEXT.title)];
+	const build = facts.gateway.build ? say(VERSION_TEXT.build, { value: facts.gateway.build }) : say(VERSION_TEXT.buildUnknown);
+	lines.push(say(VERSION_TEXT.gateway, { version: facts.gateway.version ?? say(VERSION_TEXT.unknown), build }));
 	const pin = facts.pin?.omo
-		? ` · 저장소 고정 엔진 ${formatEnginePin(facts.pin)}`
-		: " · 저장소 고정 버전 읽기 실패";
+		? say(VERSION_TEXT.pinned, { version: formatEnginePin(facts.pin) })
+		: say(VERSION_TEXT.pinUnavailable);
 	let running: string | null = null;
-	if (!facts.omo) lines.push(`· 엔진: 확인 실패 (엔진 연결 상태 ${facts.omoStatus})${pin}`);
+	if (!facts.omo) lines.push(say(VERSION_TEXT.omoDisconnected, { status: facts.omoStatus, pin }));
 	else {
 		running = facts.omo.install;
-		const engine = facts.omo.engine ? ` (${CORE_NAME} ${facts.omo.engine})` : "";
-		lines.push(`· 엔진: ${facts.omo.install ?? "설치 경로 확인 실패"}${engine}${pin}`);
+		const engine = facts.omo.engine ? say(VERSION_TEXT.engineVersion, { name: CORE_NAME, version: facts.omo.engine }) : "";
+		lines.push(say(VERSION_TEXT.omoReady, { install: facts.omo.install ?? say(VERSION_TEXT.installUnknown), engine, pin }));
 	}
 	if ("version" in facts.latest) {
-		lines.push(`· 최신 엔진: ${facts.latest.version} (npm ${ENGINE_PACKAGE})`);
+		lines.push(say(VERSION_TEXT.latest, { version: facts.latest.version, package: ENGINE_PACKAGE }));
 		const current = running ?? facts.pin?.omo ?? null;
 		if (current && isNewer(facts.latest.version, current)) {
-			lines.push(`업데이트 가능: ${current} → ${facts.latest.version} (자동으로 업데이트하지 않습니다)`);
+			lines.push(say(VERSION_TEXT.update, { current, latest: facts.latest.version }));
 		}
-	} else lines.push(`· 최신 엔진: 확인 실패 (${facts.latest.error})`);
+	} else lines.push(say(VERSION_TEXT.latestFailed, { detail: facts.latest.error }));
 	return lines.join("\n");
 }
 

package/src/voice/agents.ts

@@ -1,5 +1,6 @@
 import { dirname, join } from "node:path";
 import { type AgentSpec, agentLabel, agentState, bootstrap, type LaunchdContext, type LaunchdDeps, ownership, plistPath, plistXml } from "../cli/launchd.ts";
+import { say, type Text } from "../server-text.ts";
 import { uvEnvironment, VOICE_MODELS, type VoiceLayout } from "./install.ts";
 
 /**
@@ -11,6 +12,10 @@ import { uvEnvironment, VOICE_MODELS, type VoiceLayout } from "./install.ts";
 export const VOICE_SERVICES = ["stt", "tts"] as const;
 export type VoiceService = (typeof VOICE_SERVICES)[number];
 
+const AGENT_FOREIGN: Text = { en: "{label}: this is not a plist of this package, so it is left untouched: {path}", ko: "{label}: 이 패키지의 plist가 아니라 건드리지 않습니다: {path}" };
+const AGENT_STOP_FAILED: Text = { en: "{label} could not be stopped: {error}", ko: "{label} 중지 실패: {error}" };
+const AGENT_REGISTER_FAILED: Text = { en: "{label} could not be registered: {error}", ko: "{label} 등록 실패: {error}" };
+
 export function voiceAgentSpec(ctx: LaunchdContext, layout: VoiceLayout, name: VoiceService): AgentSpec {
 	const server = name === "stt" ? layout.sttServer : layout.ttsServer;
 	const env: Record<string, string> = name === "stt"
@@ -32,14 +37,14 @@ export async function applyVoiceAgents(deps: LaunchdDeps, ctx: LaunchdContext, l
 		const spec = voiceAgentSpec(ctx, layout, name);
 		const path = plistPath(ctx.userHome, spec.label);
 		if (ownership(deps.readAgent(path), ctx, name) === "foreign") {
-			errors.push(`${spec.label}: 이 패키지의 plist가 아니라 건드리지 않습니다: ${path}`);
+			errors.push(say(AGENT_FOREIGN, { label: spec.label, path }));
 			continue;
 		}
 		const state = agentState(deps, ctx, spec.label);
 		if (!enabled) {
 			if (state.loaded) {
 				const out = deps.launchctl(["bootout", `gui/${ctx.uid}/${spec.label}`]);
-				if (out.code !== 0) errors.push(`${spec.label} 중지 실패: ${out.stderr.trim()}`);
+				if (out.code !== 0) errors.push(say(AGENT_STOP_FAILED, { label: spec.label, error: out.stderr.trim() }));
 			}
 			if (deps.readText(path) !== null) deps.remove(path);
 			continue;
@@ -54,7 +59,7 @@ export async function applyVoiceAgents(deps: LaunchdDeps, ctx: LaunchdContext, l
 		}
 		deps.mkdir(ctx.paths.logs);
 		const booted = await bootstrap(deps, ctx, path);
-		if (booted.code !== 0) errors.push(`${spec.label} 등록 실패: ${booted.stderr.trim()}`);
+		if (booted.code !== 0) errors.push(say(AGENT_REGISTER_FAILED, { label: spec.label, error: booted.stderr.trim() }));
 	}
 	return errors;
 }

package/src/voice/install.ts

@@ -2,6 +2,7 @@ import { appendFileSync, chmodSync, cpSync, existsSync, mkdirSync, readFileSync,
 import { dirname, join } from "node:path";
 import { SYSTEM_PATH } from "../cli/launchd.ts";
 import { type Envelope, PROTOCOL_VERSION } from "../protocol.ts";
+import { say, type Text } from "../server-text.ts";
 
 /**
  * Voice on demand for an npm install (plan Todo 26). The package carries only the two Python server sources; uv, the
@@ -15,13 +16,23 @@ export type InstallStep = (typeof INSTALL_STEPS)[number];
 /** Shown before the install: whisper 3.0 GB + Qwen3-TTS 2.9 GB (measured on the dev Mac) + the Python environments. */
 export const ESTIMATED_GB = 8;
 export const UV_URL_PREFIX = "https://github.com/astral-sh/uv/releases/download/";
-export const STEP_MESSAGES: Readonly<Record<InstallStep, string>> = {
-	uv: "uv 내려받기와 무결성 확인",
-	servers: "음성 서버 파일 복사",
-	deps: "Python 의존성 설치",
-	models: "음성 모델 내려받기",
-	launchd: "음성 서버 등록",
+export const STEP_MESSAGES: Readonly<Record<InstallStep, Text>> = {
+	uv: { en: "Downloading uv and checking its integrity", ko: "uv 내려받기와 무결성 확인" },
+	servers: { en: "Copying the voice server files", ko: "음성 서버 파일 복사" },
+	deps: { en: "Installing Python dependencies", ko: "Python 의존성 설치" },
+	models: { en: "Downloading the voice models", ko: "음성 모델 내려받기" },
+	launchd: { en: "Registering the voice servers", ko: "음성 서버 등록" },
 };
+const UV_LOCK_INVALID: Text = { en: "host/voice/uv.lock.json has an invalid format", ko: "host/voice/uv.lock.json 형식이 맞지 않습니다" };
+const UV_SHA256_MISMATCH: Text = { en: "The sha256 of the uv {version} download differs from the pinned value. The install was stopped", ko: "uv {version} 내려받기의 sha256이 고정 값과 다릅니다. 설치를 중단했습니다" };
+const UV_ARCHIVE_NO_UV: Text = { en: "The uv executable is missing from the uv archive", ko: "uv 압축 파일 안에 uv 실행 파일이 없습니다" };
+const DEPS_FAILED: Text = { en: "Installing the Python dependencies of the {name} server failed (exit code {code})", ko: "{name} 서버의 Python 의존성 설치가 실패했습니다 (종료 코드 {code})" };
+const MODEL_STARTED: Text = { en: "Downloading model: {model}", ko: "모델 받는 중: {model}" };
+const MODEL_DONE: Text = { en: "Downloaded model: {model}", ko: "모델 받음: {model}" };
+const MODELS_FAILED: Text = { en: "Downloading the voice models failed (exit code {code})", ko: "음성 모델 내려받기가 실패했습니다 (종료 코드 {code})" };
+const INSTALL_DONE: Text = { en: "Voice install finished", ko: "음성 설치 완료" };
+const DOWNLOAD_FAILED: Text = { en: "Download failed: HTTP {status} {url}", ko: "내려받기 실패: HTTP {status} {url}" };
+const UNPACK_FAILED: Text = { en: "Could not unpack the uv archive (exit code {code})", ko: "uv 압축 파일을 풀지 못했습니다 (종료 코드 {code})" };
 
 export interface UvLock {
 	readonly version: string;
@@ -105,10 +116,10 @@ export function parseUvLock(text: string): UvLock {
 	const lock = JSON.parse(text) as Partial<Record<keyof UvLock, unknown>>;
 	const { version, asset, url, sha256 } = lock;
 	if (typeof version !== "string" || typeof asset !== "string" || typeof url !== "string" || typeof sha256 !== "string") {
-		throw new VoiceInstallError("uv_lock_invalid", "host/voice/uv.lock.json 형식이 맞지 않습니다");
+		throw new VoiceInstallError("uv_lock_invalid", say(UV_LOCK_INVALID));
 	}
 	if (!/^[0-9a-f]{64}$/.test(sha256) || url !== `${UV_URL_PREFIX}${version}/${asset}`) {
-		throw new VoiceInstallError("uv_lock_invalid", "host/voice/uv.lock.json 형식이 맞지 않습니다");
+		throw new VoiceInstallError("uv_lock_invalid", say(UV_LOCK_INVALID));
 	}
 	return { version, asset, url, sha256 };
 }
@@ -154,7 +165,7 @@ async function installUv(ctx: InstallContext, deps: InstallDeps): Promise<void>
 	const bytes = await deps.download(lock.url);
 	// Checked before anything is written: a wrong archive leaves no voice folder behind.
 	if (sha256Hex(bytes) !== lock.sha256) {
-		throw new VoiceInstallError("uv_sha256_mismatch", `uv ${lock.version} 내려받기의 sha256이 고정 값과 다릅니다. 설치를 중단했습니다`);
+		throw new VoiceInstallError("uv_sha256_mismatch", say(UV_SHA256_MISMATCH, { version: lock.version }));
 	}
 	rmSync(layout.download, { recursive: true, force: true });
 	mkdirSync(layout.download, { recursive: true });
@@ -162,7 +173,7 @@ async function installUv(ctx: InstallContext, deps: InstallDeps): Promise<void>
 	writeFileSync(archive, bytes);
 	await deps.extract(archive, layout.download);
 	const unpacked = join(layout.download, lock.asset.replace(/\.tar\.gz$/, ""), "uv");
-	if (!existsSync(unpacked)) throw new VoiceInstallError("uv_archive_invalid", `uv 압축 파일 안에 uv 실행 파일이 없습니다`);
+	if (!existsSync(unpacked)) throw new VoiceInstallError("uv_archive_invalid", say(UV_ARCHIVE_NO_UV));
 	mkdirSync(layout.bin, { recursive: true });
 	renameSync(unpacked, layout.uv);
 	chmodSync(layout.uv, 0o755);
@@ -180,7 +191,7 @@ async function installDeps(ctx: InstallContext, deps: InstallDeps): Promise<void
 	const { layout } = ctx;
 	for (const [name, server] of [["STT", layout.sttServer], ["TTS", layout.ttsServer]] as const) {
 		const code = await deps.run([layout.uv, "sync", "--script", server], uvEnvironment(layout), () => {});
-		if (code !== 0) throw new VoiceInstallError("deps_failed", `${name} 서버의 Python 의존성 설치가 실패했습니다 (종료 코드 ${code})`);
+		if (code !== 0) throw new VoiceInstallError("deps_failed", say(DEPS_FAILED, { name, code }));
 	}
 }
 
@@ -194,8 +205,8 @@ export function modelLine(line: string): string | null {
 	}
 	const { model, state } = (parsed ?? {}) as { model?: unknown; state?: unknown };
 	if (typeof model !== "string") return null;
-	if (state === "start") return `모델 받는 중: ${model}`;
-	if (state === "done") return `모델 받음: ${model}`;
+	if (state === "start") return say(MODEL_STARTED, { model });
+	if (state === "done") return say(MODEL_DONE, { model });
 	return null;
 }
 
@@ -206,7 +217,7 @@ async function fetchModels(ctx: InstallContext, deps: InstallDeps, index: number
 		if (message !== null) deps.progress({ state: "running", step: "models", index, total: INSTALL_STEPS.length, message });
 	};
 	const code = await deps.run([layout.uv, "run", "--script", layout.fetchModels, layout.models, VOICE_MODELS.stt, VOICE_MODELS.tts], uvEnvironment(layout), report);
-	if (code !== 0) throw new VoiceInstallError("models_failed", `음성 모델 내려받기가 실패했습니다 (종료 코드 ${code})`);
+	if (code !== 0) throw new VoiceInstallError("models_failed", say(MODELS_FAILED, { code }));
 }
 
 async function registerAgents(deps: InstallDeps): Promise<void> {
@@ -225,7 +236,7 @@ export async function installVoice(ctx: InstallContext, deps: InstallDeps): Prom
 	for (let i = 0; i < total; i++) {
 		const step = INSTALL_STEPS[i]!;
 		if (done.includes(step) && (step !== "uv" || existsSync(layout.uv))) continue;
-		deps.progress({ state: "running", step, index: i + 1, total, message: STEP_MESSAGES[step] });
+		deps.progress({ state: "running", step, index: i + 1, total, message: say(STEP_MESSAGES[step]) });
 		if (step === "uv") await installUv(ctx, deps);
 		else if (step === "servers") copyServers(ctx);
 		else if (step === "deps") await installDeps(ctx, deps);
@@ -235,7 +246,7 @@ export async function installVoice(ctx: InstallContext, deps: InstallDeps): Prom
 		writeFileSync(layout.state, `${JSON.stringify({ done })}\n`);
 	}
 	writeFileSync(layout.installed, `${JSON.stringify({ uv: ctx.lock.version, models: VOICE_MODELS, installedAt: deps.now().toISOString() }, null, 2)}\n`);
-	deps.progress({ state: "done", step: null, index: total, total, message: "음성 설치 완료" });
+	deps.progress({ state: "done", step: null, index: total, total, message: say(INSTALL_DONE) });
 }
 
 export type VoiceInstallProgress = Envelope<"voice.install.progress", InstallProgress>;
@@ -270,12 +281,12 @@ export function systemInstallDeps(log: string, rest: Pick<InstallDeps, "progress
 		...rest,
 		download: async (url) => {
 			const response = await fetch(url);
-			if (!response.ok) throw new VoiceInstallError("download_failed", `내려받기 실패: HTTP ${response.status} ${url}`);
+			if (!response.ok) throw new VoiceInstallError("download_failed", say(DOWNLOAD_FAILED, { status: response.status, url }));
 			return new Uint8Array(await response.arrayBuffer());
 		},
 		extract: async (archive, dest) => {
 			const code = await Bun.spawn(["/usr/bin/tar", "-xzf", archive, "-C", dest], { stdout: "ignore", stderr: "ignore" }).exited;
-			if (code !== 0) throw new VoiceInstallError("uv_archive_invalid", `uv 압축 파일을 풀지 못했습니다 (종료 코드 ${code})`);
+			if (code !== 0) throw new VoiceInstallError("uv_archive_invalid", say(UNPACK_FAILED, { code }));
 		},
 		run: async (args, env, onLine) => {
 			mkdirSync(dirname(log), { recursive: true });