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

package/src/omo/frame-socket.ts

@@ -0,0 +1,330 @@
+import { createHash, randomBytes } from "node:crypto";
+import type { Socket } from "bun";
+
+// Bug 221: Bun's WebSocket client misreads valid bridge frames in long sessions (1002/1011 closes on a byte stream
+// that parses cleanly). This client speaks RFC 6455 over plain TCP for ws:// bridge URLs, so frame parsing is ours.
+export const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+export const MAX_MESSAGE_BYTES = 64 * 1024 * 1024;
+const CLOSE_WAIT_MS = 1_000;
+export const HANDSHAKE_LIMIT = 16_384;
+
+export type FrameSocketState = 0 | 1 | 2 | 3;
+export interface FrameSocketClose { readonly code: number; readonly reason: string; readonly wasClean: boolean }
+
+export function acceptFor(key: string): string {
+	return createHash("sha1").update(`${key}${WS_GUID}`).digest("base64");
+}
+
+export function encodeFrame(opcode: number, payload: Uint8Array, mask: Uint8Array): Uint8Array {
+	if (mask.length !== 4) throw new Error("frame_mask_length");
+	const length = payload.length;
+	const extra = length < 126 ? 0 : length <= 0xffff ? 2 : 8;
+	const frame = new Uint8Array(2 + extra + 4 + length);
+	frame[0] = 0x80 | opcode;
+	if (extra === 0) frame[1] = 0x80 | length;
+	else if (extra === 2) {
+		frame[1] = 0x80 | 126;
+		frame[2] = length >>> 8;
+		frame[3] = length & 0xff;
+	} else {
+		frame[1] = 0x80 | 127;
+		new DataView(frame.buffer).setBigUint64(2, BigInt(length));
+	}
+	const at = 2 + extra;
+	frame.set(mask, at);
+	payload.forEach((byte, i) => { frame[at + 4 + i] = byte ^ mask[i & 3]!; });
+	return frame;
+}
+
+export type HandshakeHead =
+	| { readonly kind: "need" }
+	| { readonly kind: "too_large" }
+	| { readonly kind: "head"; readonly head: string; readonly rest: string };
+
+export function handshakeHead(text: string): HandshakeHead {
+	const end = text.indexOf("\r\n\r\n");
+	if (end === -1) return text.length > HANDSHAKE_LIMIT ? { kind: "too_large" } : { kind: "need" };
+	if (end > HANDSHAKE_LIMIT) return { kind: "too_large" };
+	return { kind: "head", head: text.slice(0, end), rest: text.slice(end + 4) };
+}
+
+export interface WriteSink { write(bytes: Uint8Array): number }
+
+export class WriteQueue {
+	private readonly pending: Uint8Array[] = [];
+
+	get size(): number {
+		return this.pending.length;
+	}
+
+	write(sink: WriteSink, bytes: Uint8Array): void {
+		if (this.pending.length > 0) {
+			this.pending.push(bytes);
+			return;
+		}
+		const written = sink.write(bytes);
+		if (written < bytes.length) this.pending.push(bytes.subarray(Math.max(0, written)));
+	}
+
+	flush(sink: WriteSink): void {
+		while (this.pending.length > 0) {
+			const head = this.pending[0]!;
+			const written = sink.write(head);
+			if (written < head.length) {
+				this.pending[0] = head.subarray(Math.max(0, written));
+				return;
+			}
+			this.pending.shift();
+		}
+	}
+}
+
+export interface ParsedFrame { readonly fin: boolean; readonly opcode: number; readonly payload: Uint8Array }
+export type ParseResult =
+	| { readonly kind: "frame"; readonly frame: ParsedFrame; readonly used: number }
+	| { readonly kind: "need"; readonly bytes: number }
+	| { readonly kind: "error"; readonly code: number; readonly reason: string };
+
+export function parseFrame(buffer: Uint8Array, maxBytes = MAX_MESSAGE_BYTES): ParseResult {
+	if (buffer.length < 2) return { kind: "need", bytes: 2 };
+	const first = buffer[0]!;
+	const second = buffer[1]!;
+	if ((first & 0x70) !== 0) return { kind: "error", code: 1002, reason: "reserved_bits_set" };
+	if ((second & 0x80) !== 0) return { kind: "error", code: 1002, reason: "masked_server_frame" };
+	const fin = (first & 0x80) !== 0;
+	const opcode = first & 0x0f;
+	if (![0, 1, 2, 8, 9, 10].includes(opcode)) return { kind: "error", code: 1002, reason: "unknown_opcode" };
+	const control = opcode >= 8;
+	let length = second & 0x7f;
+	let header = 2;
+	if (length === 126) {
+		if (buffer.length < 4) return { kind: "need", bytes: 4 };
+		length = (buffer[2]! << 8) | buffer[3]!;
+		header = 4;
+	} else if (length === 127) {
+		if (buffer.length < 10) return { kind: "need", bytes: 10 };
+		length = Number(new DataView(buffer.buffer, buffer.byteOffset + 2, 8).getBigUint64(0));
+		header = 10;
+	}
+	if (control && (!fin || length > 125)) return { kind: "error", code: 1002, reason: "invalid_control_frame" };
+	if (length > maxBytes) return { kind: "error", code: 1009, reason: "message_too_big" };
+	if (buffer.length < header + length) return { kind: "need", bytes: header + length };
+	return { kind: "frame", frame: { fin, opcode, payload: buffer.subarray(header, header + length) }, used: header + length };
+}
+
+export class FrameSocket {
+	static readonly OPEN = 1;
+	readyState: FrameSocketState = 0;
+	onopen: (() => void) | null = null;
+	onmessage: ((event: { readonly data: string }) => void) | null = null;
+	onclose: ((event: FrameSocketClose) => void) | null = null;
+	onerror: ((event: { readonly message?: string }) => void) | null = null;
+
+	private socket: Socket<undefined> | null = null;
+	private readonly key = randomBytes(16).toString("base64");
+	private handshake = "";
+	private input: Uint8Array[] = [];
+	private inputBytes = 0;
+	private inputNeeded = 2;
+	private readonly output = new WriteQueue();
+	private fragments: Uint8Array[] = [];
+	private fragmentBytes = 0;
+	private fragmentOpcode = 0;
+	private closeTimer: ReturnType<typeof setTimeout> | null = null;
+	private closed = false;
+	private readonly decoder = new TextDecoder();
+
+	constructor(url: string, private readonly headers: Readonly<Record<string, string>> = {}, private readonly maxBytes = MAX_MESSAGE_BYTES) {
+		const target = new URL(url);
+		if (target.protocol !== "ws:") throw new Error(`frame_socket_unsupported_url:${target.protocol}`);
+		for (const [name, value] of Object.entries(headers)) {
+			if (/[\r\n:]/.test(name) || /[\r\n]/.test(value)) throw new Error("frame_socket_invalid_header");
+		}
+		const port = Number(target.port || 80);
+		const path = `${target.pathname || "/"}${target.search}`;
+		const host = target.port ? `${target.hostname}:${target.port}` : target.hostname;
+		Bun.connect({
+			hostname: target.hostname.replace(/^\[|\]$/g, ""),
+			port,
+			socket: {
+				open: (socket) => {
+					this.socket = socket;
+					if (this.closed) {
+						socket.end();
+						return;
+					}
+					const lines = [`GET ${path} HTTP/1.1`, `Host: ${host}`, "Connection: Upgrade", "Upgrade: websocket",
+						"Sec-WebSocket-Version: 13", `Sec-WebSocket-Key: ${this.key}`,
+						...Object.entries(this.headers).map(([name, value]) => `${name}: ${value}`)];
+					this.write(new TextEncoder().encode(`${lines.join("\r\n")}\r\n\r\n`));
+				},
+				data: (_socket, chunk) => this.receive(chunk),
+				drain: () => this.flush(),
+				close: () => this.finish(1006, "", false),
+				error: (_socket, error) => this.fail(1006, error.message),
+				connectError: (_socket, error) => this.fail(1006, error.message),
+			},
+		}).catch((error: Error) => this.fail(1006, error.message));
+	}
+
+	send(text: string): void {
+		if (this.readyState !== FrameSocket.OPEN) throw new Error("frame_socket_not_open");
+		this.write(encodeFrame(1, new TextEncoder().encode(text), randomBytes(4)));
+	}
+
+	close(code = 1000, reason = ""): void {
+		if (this.readyState >= 2) return;
+		if (this.readyState === 0) {
+			this.finish(1006, reason, false);
+			return;
+		}
+		this.readyState = 2;
+		this.sendClose(code, reason);
+		this.closeTimer = setTimeout(() => this.finish(1006, reason, false), CLOSE_WAIT_MS);
+	}
+
+	private sendClose(code: number, reason: string): void {
+		const text = new TextEncoder().encode(reason);
+		const payload = new Uint8Array(2 + text.length);
+		payload[0] = code >>> 8;
+		payload[1] = code & 0xff;
+		payload.set(text, 2);
+		this.write(encodeFrame(8, payload, randomBytes(4)));
+	}
+
+	private write(bytes: Uint8Array): void {
+		if (this.socket) this.output.write(this.socket, bytes);
+	}
+
+	private flush(): void {
+		if (this.socket) this.output.flush(this.socket);
+	}
+
+	private receive(chunk: Uint8Array): void {
+		if (this.closed) return;
+		if (this.readyState === 0) {
+			this.handshake += Buffer.from(chunk).toString("latin1");
+			const parsed = handshakeHead(this.handshake);
+			if (parsed.kind === "need") return;
+			if (parsed.kind === "too_large") {
+				this.fail(1006, "handshake_too_large");
+				return;
+			}
+			this.handshake = "";
+			const rest = Buffer.from(parsed.rest, "latin1");
+			const [status, ...fields] = parsed.head.split("\r\n");
+			const accept = fields.find((line) => /^sec-websocket-accept:/i.test(line))?.split(":")[1]?.trim();
+			if (!/^HTTP\/1\.1 101 /.test(status ?? "")) {
+				this.fail(1006, `handshake_status:${status ?? ""}`);
+				return;
+			}
+			if (accept !== acceptFor(this.key)) {
+				this.fail(1006, "handshake_accept_mismatch");
+				return;
+			}
+			this.readyState = 1;
+			this.dispatch(() => this.onopen?.());
+			this.receive(rest);
+			return;
+		}
+		this.input.push(chunk.slice());
+		this.inputBytes += chunk.length;
+		if (this.inputBytes < this.inputNeeded) return;
+		const merged = new Uint8Array(this.inputBytes);
+		let at = 0;
+		for (const part of this.input) {
+			merged.set(part, at);
+			at += part.length;
+		}
+		let offset = 0;
+		while (!this.closed) {
+			const parsed = parseFrame(merged.subarray(offset), this.maxBytes);
+			if (parsed.kind === "need") {
+				this.inputNeeded = parsed.bytes;
+				break;
+			}
+			if (parsed.kind === "error") {
+				this.protocolError(parsed.code, parsed.reason);
+				return;
+			}
+			offset += parsed.used;
+			this.handle(parsed.frame);
+		}
+		const rest = merged.slice(offset);
+		this.input = [rest];
+		this.inputBytes = rest.length;
+	}
+
+	private handle(frame: ParsedFrame): void {
+		const { opcode, payload, fin } = frame;
+		if (opcode === 9) {
+			if (this.readyState === 1) this.write(encodeFrame(10, payload, randomBytes(4)));
+			return;
+		}
+		if (opcode === 10) return;
+		if (opcode === 8) {
+			const code = payload.length >= 2 ? (payload[0]! << 8) | payload[1]! : 1005;
+			const reason = this.decoder.decode(payload.subarray(2));
+			if (this.readyState === 1) this.sendClose(code === 1005 ? 1000 : code, "");
+			this.finish(code, reason, true);
+			return;
+		}
+		if (opcode === 0 ? this.fragmentOpcode === 0 : this.fragmentOpcode !== 0) {
+			this.protocolError(1002, "unexpected_continuation");
+			return;
+		}
+		if (opcode !== 0) this.fragmentOpcode = opcode;
+		this.fragmentBytes += payload.length;
+		if (this.fragmentBytes > this.maxBytes) {
+			this.protocolError(1009, "message_too_big");
+			return;
+		}
+		this.fragments.push(payload.slice());
+		if (!fin) return;
+		const whole = new Uint8Array(this.fragmentBytes);
+		let at = 0;
+		for (const part of this.fragments) {
+			whole.set(part, at);
+			at += part.length;
+		}
+		this.fragments = [];
+		this.fragmentBytes = 0;
+		this.fragmentOpcode = 0;
+		if (this.readyState === 1) {
+			const data = this.decoder.decode(whole);
+			this.dispatch(() => this.onmessage?.({ data }));
+		}
+	}
+
+	private protocolError(code: number, reason: string): void {
+		if (this.readyState === 1) this.sendClose(code, reason);
+		this.dispatch(() => this.onerror?.({ message: `frame_socket_protocol_error:${reason}` }));
+		this.finish(code, reason, false);
+	}
+
+	private dispatch(handler: () => void): void {
+		try {
+			handler();
+		} catch (error) {
+			queueMicrotask(() => {
+				throw error;
+			});
+		}
+	}
+
+	private fail(code: number, message: string): void {
+		if (this.closed) return;
+		this.dispatch(() => this.onerror?.({ message }));
+		this.finish(code, message, false);
+	}
+
+	private finish(code: number, reason: string, wasClean: boolean): void {
+		if (this.closed) return;
+		this.closed = true;
+		this.readyState = 3;
+		if (this.closeTimer) clearTimeout(this.closeTimer);
+		this.flush();
+		this.socket?.end();
+		this.dispatch(() => this.onclose?.({ code, reason, wasClean }));
+	}
+}

package/src/update/handoff-system.ts

@@ -10,6 +10,9 @@ import { type BridgeGeneration, type HandoffDeps, type OverlapControl, runHandof
 import { installedVersion } from "./helper.ts";
 import { initialOverlap, observe, type OverlapState } from "../runtime/overlap-policy.ts";
 import { sampleResources } from "../runtime/resource-sample.ts";
+import { agentDir } from "../model-accounts.ts";
+import { attemptRefusal, readGuardState, readStoreSchema, storeIncompatibility } from "../engine/schema-guard.ts";
+import { supportedSchema } from "../engine/thread-schema.ts";
 
 const OVERLAP_REASONS: Readonly<Record<string, string>> = {
 	critical_pressure: "메모리 압박 단계가 위험입니다",
@@ -110,6 +113,25 @@ export function systemHandoffDeps(launchd: LaunchdDeps, ctx: LaunchdContext, opt
 		writeRegistry: (registry: SlotRegistry | null) => registry === null ? rmSync(paths.slotsFile, { force: true }) : writeRegistry(paths.slotsFile, registry),
 		snapshot: () => createSnapshot(ctx.packageRoot, paths.generations, version),
 		engineFolder: () => existsSync(paths.omoCurrent) ? basename(realpathSync(paths.omoCurrent)) : null,
+		// Same agent folder rule as the bridge's own guard (process env overlaid with config.env) and its pinned engine folder.
+		preflight: (record) => {
+			let supported: number | null = null;
+			try {
+				supported = supportedSchema(record.engine === null ? paths.omoCurrent : join(paths.omo, record.engine));
+			} catch {
+				supported = null;
+			}
+			let config: Record<string, string>;
+			try {
+				config = readConfig(launchd, ctx);
+			} catch {
+				// A broken config.env is reported by startBridge, which reads it next and fails the attempt untouched.
+				return null;
+			}
+			const found = storeIncompatibility(readStoreSchema(agentDir({ ...ctx.env, ...config })), supported);
+			return found === null ? null : `저장소 스키마 ${found.store} > 엔진 지원 ${found.supported}`;
+		},
+		startRefusal: (record) => attemptRefusal(readGuardState(paths.run), { slot: record.slot, engine: record.engine, since: record.since }),
 		startBridge: async (record) => {
 			let config: Record<string, string>;
 			try {

package/src/update/handoff.ts

@@ -34,6 +34,10 @@ export interface HandoffDeps {
 	readonly writeRegistry: (registry: SlotRegistry | null) => void;
 	readonly snapshot: () => { readonly name: string; readonly dir: string };
 	readonly engineFolder: () => string | null;
+	/** Findings 214-217: why the new slot's engine cannot use the shared store, checked before it starts; null when it can. */
+	readonly preflight: (record: SlotRecord) => string | null;
+	/** The startup refusal of this attempt (this slot, engine and start time) only; a stale shared record is null. */
+	readonly startRefusal: (record: SlotRecord) => string | null;
 	readonly startBridge: (record: SlotRecord) => Promise<string | null>;
 	readonly stopBridge: (slot: RuntimeSlot) => Promise<void>;
 	readonly generation: (record: SlotRecord, action: "status" | "drain" | "terminate") => Promise<BridgeGeneration | null>;
@@ -111,14 +115,18 @@ export async function runHandoff(deps: HandoffDeps): Promise<HandoffResult> {
 		await deps.stopBridge(slot);
 		deps.writeRegistry(stored);
 	};
+	const blocked = deps.preflight(fresh);
+	if (blocked !== null) return fail(true, `새 세대(슬롯 ${slot}, 엔진 ${fresh.engine ?? "current"})를 시작하지 않았습니다: ${blocked}`);
 	deps.writeRegistry({ schema: 1, slots: [old, fresh] });
 	const started = await deps.startBridge(fresh);
 	if (started !== null) {
 		await undo();
 		return fail(true, `새 세대(슬롯 ${slot})를 시작하지 못했습니다: ${started}`);
 	}
-	const up = await until(deps, BRIDGE_START_WAIT_MS, async () => (await deps.generation(fresh, "status"))?.omo === "running");
-	const unhealthy = up ? await deps.healthCheck(fresh) : NOT_UP;
+	let refused: string | null = null;
+	const up = await until(deps, BRIDGE_START_WAIT_MS, async () => (refused = deps.startRefusal(fresh)) !== null ||
+		(await deps.generation(fresh, "status"))?.omo === "running");
+	const unhealthy = refused ?? (up ? await deps.healthCheck(fresh) : NOT_UP);
 	if (unhealthy !== null) {
 		await undo();
 		return fail(true, `새 세대(슬롯 ${slot}) 확인 실패: ${unhealthy}`);

package/src/update/helper.ts

@@ -19,6 +19,9 @@ export const STOP_WAIT_MS = 15_000;
 export const LOST_RECORDS = "업데이트 전 백업 뒤에 생긴 기록(대화 등)은 없어졌을 수 있습니다.";
 export const UPDATE_AGAIN = "옛 엔진이 공유 폴더 스키마를 읽지 못해 브리지가 멈췄습니다. 다시 업데이트하세요(새 엔진 필요).";
 
+/** The installer's refusal code (src/engine/install.ts ENGINE_SCHEMA_INCOMPATIBLE) as printed by `setup --engine-only`. */
+export const ENGINE_SCHEMA_REFUSAL = "engine_schema_incompatible";
+
 export interface CommandOutput { readonly code: number; readonly stdout: string; readonly stderr: string }
 
 export interface Probe { readonly status: number; readonly omo: string | null; readonly version: string | null }
@@ -143,7 +146,14 @@ export async function runHelper(request: UpdateRequest, deps: HelperDeps): Promi
 		}
 		if (request.engineChanged) {
 			phase("engine");
-			await bun([join(deps.packageRoot, "src/cli/main.ts"), "setup", "--non-interactive", "--engine-only"], "새 엔진 설치");
+			try {
+				await bun([join(deps.packageRoot, "src/cli/main.ts"), "setup", "--non-interactive", "--engine-only"], "새 엔진 설치");
+			} catch (error) {
+				// Findings 214-217: the installer refused before selecting the engine and nothing running was restarted.
+				if (!(error instanceof StepError) || !error.message.includes(ENGINE_SCHEMA_REFUSAL)) throw error;
+				log(`실패(실행 중인 것은 그대로): ${error.message}`);
+				return await untouchedRollback(request, deps, { failure: { untouched: true, message: error.message }, prevTgz, log, phase, bun, finish });
+			}
 		}
 		phase("restart");
 		const restarted = await deps.strategy.run({ restart: deps.restart, log, request });

package/src/update/request.ts

@@ -1,7 +1,7 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { CONSENT_WORD, type ConsentRecord, noticeSha256, type PermissionNotice, writePending } from "../consent/consent.ts";
-import { type StoreReading, updateSchemaNotice } from "../engine/schema-guard.ts";
+import { SCHEMA_INCOMPATIBLE, storeIncompatibility, type StoreReading, updateSchemaNotice } from "../engine/schema-guard.ts";
 import type { InstallKind } from "../runtime/install-kind.ts";
 import { type Origin, REQUEST_FILE, type UpdateRequest, readState, updateDir, updateRunning, writeJson, writeState } from "./state.ts";
 import { TargetError, type TargetInfo } from "./target.ts";
@@ -21,7 +21,7 @@ export const CHECKOUT_MESSAGE = "이 설치(checkout)는 저장소에서 배포
 
 export const DRAINING_MESSAGE = "이전 업데이트가 아직 이전 세대를 정리하고 있습니다. 정리가 끝난 뒤 다시 하세요";
 
-export type RefusalCode = "not_updatable" | "in_progress" | "same_version" | "busy" | "consent_on_mac" | "consent_required" | "schema_confirm" | "pending_questions";
+export type RefusalCode = "not_updatable" | "in_progress" | "same_version" | "busy" | "consent_on_mac" | "consent_required" | "schema_confirm" | "pending_questions" | typeof SCHEMA_INCOMPATIBLE;
 
 export interface Refusal {
 	readonly ok: false;
@@ -78,10 +78,23 @@ export function schemaLines(target: TargetInfo, store: StoreReading, globalEngin
 	return notice.confirm ? [...notice.lines, ROLLBACK_SCHEMA_WARNING] : null;
 }
 
+/**
+ * Findings 214-217: the target's engine cannot read the shared store, so the update is refused before any package
+ * install or engine-link change. Neither `force` nor `confirmSchema` overrides it; null when not known to be incompatible.
+ */
+export function schemaRefusal(target: TargetInfo, store: StoreReading): Refusal | null {
+	const found = storeIncompatibility(store, target.engine?.threadSchema ?? null);
+	if (found === null) return null;
+	return refuse(SCHEMA_INCOMPATIBLE, `공유 폴더 스키마 ${found.store}를 ${target.version}의 엔진 ${target.engine?.omo ?? ""}(지원 ${found.supported})이 읽지 못해 업데이트하지 않았습니다. 스키마 ${found.store}를 지원하는 버전이 필요합니다`,
+		{ lines: [`저장소 스키마 ${found.store}`, `대상 엔진 지원 ${found.supported}`] });
+}
+
 export function precheck(input: PrecheckInput): Precheck {
 	if (input.kind !== "npm") return refuse("not_updatable", CHECKOUT_MESSAGE);
 	if (input.running) return refuse("in_progress", "업데이트가 이미 진행 중입니다");
 	if (input.target.version === input.current.version) return refuse("same_version", `이미 ${input.current.version}입니다`);
+	const incompatible = schemaRefusal(input.target, input.store);
+	if (incompatible !== null) return incompatible;
 	if (input.busy && !input.force && input.target.handoff !== true) return refuse("busy", BUSY_MESSAGE);
 	const notice = input.target.notice;
 	const noticeChanged = input.consent?.noticeVersion !== notice.version;