@pixelzx/genesis 2026.6.4 → 2026.6.6

package/dist/logs-cli-zoBIelUH.js

@@ -0,0 +1,265 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DPP_aYVc.js";
+import { t as clearActiveProgressLine } from "./progress-line-DcAxckOW.js";
+import { f as formatTimestamp, p as isValidTimeZone } from "./logger-BRmjL88V.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { n as isRich, r as theme, t as colorize } from "./theme-DD6pQv2_.js";
+import { t as formatCliCommand } from "./command-format-B3Q5KD9o.js";
+import { a as isLoopbackHost } from "./net-BzaeD_3Q.js";
+import { d as readConnectPairingRequiredMessage } from "./connect-error-details-dpux1X7K.js";
+import { n as buildGatewayConnectionDetails } from "./call-wY43fzOF.js";
+import { n as callGatewayFromCli, t as addGatewayClientOptions } from "./gateway-rpc-dyJV2osv.js";
+import { t as readConfiguredLogTail } from "./log-tail-Dj4pV1FF.js";
+import { t as parseLogLine } from "./parse-log-line-Bcsm3sK8.js";
+import { setTimeout } from "node:timers/promises";
+//#region src/terminal/stream-writer.ts
+function isBrokenPipeError(err) {
+	const code = err?.code;
+	return code === "EPIPE" || code === "EIO";
+}
+function createSafeStreamWriter(options = {}) {
+	let closed = false;
+	let notified = false;
+	const noteBrokenPipe = (err, stream) => {
+		if (notified) return;
+		notified = true;
+		options.onBrokenPipe?.(err, stream);
+	};
+	const handleError = (err, stream) => {
+		if (!isBrokenPipeError(err)) throw err;
+		closed = true;
+		noteBrokenPipe(err, stream);
+		return false;
+	};
+	const write = (stream, text) => {
+		if (closed) return false;
+		try {
+			options.beforeWrite?.();
+		} catch (err) {
+			return handleError(err, process.stderr);
+		}
+		try {
+			stream.write(text);
+			return !closed;
+		} catch (err) {
+			return handleError(err, stream);
+		}
+	};
+	const writeLine = (stream, text) => write(stream, `${text}\n`);
+	return {
+		write,
+		writeLine,
+		reset: () => {
+			closed = false;
+			notified = false;
+		},
+		isClosed: () => closed
+	};
+}
+//#endregion
+//#region src/cli/logs-cli.ts
+let logsCliRuntimePromise;
+async function loadLogsCliRuntime() {
+	logsCliRuntimePromise ??= import("./logs-cli.runtime-DxKNxXAz.js");
+	return logsCliRuntimePromise;
+}
+const LOCAL_FALLBACK_NOTICE = "Gateway pairing required; reading local log file instead.";
+function parsePositiveInt(value, fallback) {
+	if (!value) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+async function fetchLogs(opts, cursor, showProgress) {
+	const limit = parsePositiveInt(opts.limit, 200);
+	const maxBytes = parsePositiveInt(opts.maxBytes, 25e4);
+	try {
+		const payload = await callGatewayFromCli("logs.tail", opts, {
+			cursor,
+			limit,
+			maxBytes
+		}, { progress: showProgress });
+		if (!payload || typeof payload !== "object") throw new Error("Unexpected logs.tail response");
+		return payload;
+	} catch (error) {
+		if (!shouldUseLocalLogsFallback(opts, error)) throw error;
+		return {
+			...await readConfiguredLogTail({
+				cursor,
+				limit,
+				maxBytes
+			}),
+			localFallback: true
+		};
+	}
+}
+function normalizeErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function shouldUseLocalLogsFallback(opts, error) {
+	if (!readConnectPairingRequiredMessage(normalizeLowercaseStringOrEmpty(normalizeErrorMessage(error)))) return false;
+	if (typeof opts.url === "string" && opts.url.trim().length > 0) return false;
+	const connection = buildGatewayConnectionDetails();
+	if (connection.urlSource !== "local loopback") return false;
+	try {
+		return isLoopbackHost(new URL(connection.url).hostname);
+	} catch {
+		return false;
+	}
+}
+function formatLogTimestamp(value, mode = "plain", localTime = false) {
+	if (!value) return "";
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime())) return value;
+	if (mode === "pretty") return formatTimestamp(parsed, {
+		style: "short",
+		timeZone: localTime ? void 0 : "UTC"
+	});
+	return localTime ? formatTimestamp(parsed, { style: "long" }) : parsed.toISOString();
+}
+function formatLogLine(raw, opts) {
+	const parsed = parseLogLine(raw);
+	if (!parsed) return raw;
+	const label = parsed.subsystem ?? parsed.module ?? "";
+	const time = formatLogTimestamp(parsed.time, opts.pretty ? "pretty" : "plain", opts.localTime);
+	const level = parsed.level ?? "";
+	const levelLabel = level.padEnd(5).trim();
+	const message = parsed.message || parsed.raw;
+	if (!opts.pretty) return [
+		time,
+		level,
+		label,
+		message
+	].filter(Boolean).join(" ").trim();
+	const timeLabel = colorize(opts.rich, theme.muted, time);
+	const labelValue = colorize(opts.rich, theme.accent, label);
+	const levelValue = level === "error" || level === "fatal" ? colorize(opts.rich, theme.error, levelLabel) : level === "warn" ? colorize(opts.rich, theme.warn, levelLabel) : level === "debug" || level === "trace" ? colorize(opts.rich, theme.muted, levelLabel) : colorize(opts.rich, theme.info, levelLabel);
+	const messageValue = level === "error" || level === "fatal" ? colorize(opts.rich, theme.error, message) : level === "warn" ? colorize(opts.rich, theme.warn, message) : level === "debug" || level === "trace" ? colorize(opts.rich, theme.muted, message) : colorize(opts.rich, theme.info, message);
+	return [[
+		timeLabel,
+		levelValue,
+		labelValue
+	].filter(Boolean).join(" "), messageValue].filter(Boolean).join(" ").trim();
+}
+function createLogWriters() {
+	const writer = createSafeStreamWriter({
+		beforeWrite: () => clearActiveProgressLine(),
+		onBrokenPipe: (err, stream) => {
+			const code = err.code ?? "EPIPE";
+			const message = `genesis logs: output ${stream === process.stdout ? "stdout" : "stderr"} closed (${code}). Stopping tail.`;
+			try {
+				clearActiveProgressLine();
+				process.stderr.write(`${message}\n`);
+			} catch {}
+		}
+	});
+	return {
+		logLine: (text) => writer.writeLine(process.stdout, text),
+		errorLine: (text) => writer.writeLine(process.stderr, text),
+		emitJsonLine: (payload, toStdErr = false) => writer.write(toStdErr ? process.stderr : process.stdout, `${JSON.stringify(payload)}\n`)
+	};
+}
+async function emitGatewayError(err, opts, mode, rich, emitJsonLine, errorLine) {
+	const runtime = await loadLogsCliRuntime();
+	const message = "Gateway not reachable. Is it running and accessible?";
+	const hint = `Hint: run \`${formatCliCommand("genesis doctor")}\`.`;
+	const errorText = formatErrorMessage(err);
+	const details = runtime.buildGatewayConnectionDetails({ url: opts.url });
+	if (mode === "json") {
+		if (!emitJsonLine({
+			type: "error",
+			message,
+			error: errorText,
+			details,
+			hint
+		}, true)) return;
+		return;
+	}
+	if (!errorLine(colorize(rich, theme.error, message))) return;
+	if (!errorLine(details.message)) return;
+	errorLine(colorize(rich, theme.muted, hint));
+}
+function registerLogsCli(program) {
+	const logs = program.command("logs").description("Tail gateway file logs via RPC").option("--limit <n>", "Max lines to return", "200").option("--max-bytes <n>", "Max bytes to read", "250000").option("--follow", "Follow log output", false).option("--interval <ms>", "Polling interval in ms", "1000").option("--json", "Emit JSON log lines", false).option("--plain", "Plain text output (no ANSI styling)", false).option("--no-color", "Disable ANSI colors").option("--local-time", "Display timestamps in local timezone", false).addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/logs", "genesis.pixelzx.com/docs/cli/logs")}\n`);
+	addGatewayClientOptions(logs);
+	logs.action(async (opts) => {
+		const { logLine, errorLine, emitJsonLine } = createLogWriters();
+		const interval = parsePositiveInt(opts.interval, 1e3);
+		let cursor;
+		let first = true;
+		const jsonMode = Boolean(opts.json);
+		const pretty = !jsonMode && process.stdout.isTTY && !opts.plain;
+		const rich = isRich() && opts.color !== false;
+		const localTime = Boolean(opts.localTime) || !!process.env.TZ && isValidTimeZone(process.env.TZ);
+		while (true) {
+			let payload;
+			const showProgress = first && !opts.follow;
+			try {
+				payload = await fetchLogs(opts, cursor, showProgress);
+			} catch (err) {
+				await emitGatewayError(err, opts, jsonMode ? "json" : "text", rich, emitJsonLine, errorLine);
+				process.exit(1);
+				return;
+			}
+			const lines = Array.isArray(payload.lines) ? payload.lines : [];
+			if (jsonMode) {
+				if (first) {
+					if (!emitJsonLine({
+						type: "meta",
+						file: payload.file,
+						cursor: payload.cursor,
+						size: payload.size
+					})) return;
+				}
+				for (const line of lines) {
+					const parsed = parseLogLine(line);
+					if (parsed) {
+						if (!emitJsonLine({
+							type: "log",
+							...parsed
+						})) return;
+					} else if (!emitJsonLine({
+						type: "raw",
+						raw: line
+					})) return;
+				}
+				if (payload.truncated) {
+					if (!emitJsonLine({
+						type: "notice",
+						message: "Log tail truncated (increase --max-bytes)."
+					})) return;
+				}
+				if (payload.reset) {
+					if (!emitJsonLine({
+						type: "notice",
+						message: "Log cursor reset (file rotated)."
+					})) return;
+				}
+			} else {
+				if (first && payload.file && payload.localFallback === true) {
+					if (!errorLine(colorize(rich, theme.warn, LOCAL_FALLBACK_NOTICE))) return;
+				}
+				if (first && payload.file) {
+					if (!logLine(`${pretty ? colorize(rich, theme.muted, "Log file:") : "Log file:"} ${payload.file}`)) return;
+				}
+				for (const line of lines) if (!logLine(formatLogLine(line, {
+					pretty,
+					rich,
+					localTime
+				}))) return;
+				if (payload.truncated) {
+					if (!errorLine("Log tail truncated (increase --max-bytes).")) return;
+				}
+				if (payload.reset) {
+					if (!errorLine("Log cursor reset (file rotated).")) return;
+				}
+			}
+			cursor = typeof payload.cursor === "number" && Number.isFinite(payload.cursor) ? payload.cursor : cursor;
+			first = false;
+			if (!opts.follow) return;
+			await setTimeout(interval);
+		}
+	});
+}
+//#endregion
+export { formatLogTimestamp, registerLogsCli };

package/dist/logs-cli.runtime-DxKNxXAz.js

@@ -0,0 +1,2 @@
+import { n as buildGatewayConnectionDetails } from "./call-wY43fzOF.js";
+export { buildGatewayConnectionDetails };

package/dist/logs-cli.runtime.js

@@ -1 +1 @@
-export * from "./logs-cli.runtime-k0UtiaRP.js";
+export * from "./logs-cli.runtime-DxKNxXAz.js";

package/dist/main-session-restart-recovery-DWZfkOzH.js

@@ -0,0 +1,206 @@
+import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
+import { _ as resolveStateDir } from "./paths-Bv2rGpO9.js";
+import { i as isCronSessionKey, n as isAcpSessionKey, o as isSubagentSessionKey } from "./session-key-utils-DDwuwYKT.js";
+import { t as loadSessionStore } from "./store-load-CZTVJ-lZ.js";
+import { t as resolveAgentSessionDirs } from "./session-dirs-BYTpfRfq.js";
+import { o as updateSessionStore } from "./store-4uu5L7Eg.js";
+import "./sessions-qbJQTdke.js";
+import { i as readSessionMessages } from "./session-utils.fs-BWnHyjEg.js";
+import { r as callGateway } from "./call-wY43fzOF.js";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region src/agents/main-session-restart-recovery.ts
+/**
+* Post-restart recovery for main sessions interrupted while holding a transcript lock.
+*/
+const log = createSubsystemLogger("main-session-restart-recovery");
+const DEFAULT_RECOVERY_DELAY_MS = 5e3;
+const MAX_RECOVERY_RETRIES = 3;
+const RETRY_BACKOFF_MULTIPLIER = 2;
+function shouldSkipMainRecovery(entry, sessionKey) {
+	if (typeof entry.spawnDepth === "number" && entry.spawnDepth > 0) return true;
+	if (entry.subagentRole != null) return true;
+	return isSubagentSessionKey(sessionKey) || isCronSessionKey(sessionKey) || isAcpSessionKey(sessionKey);
+}
+function sessionIdFromLockPath(lockPath) {
+	const fileName = path.basename(lockPath);
+	if (!fileName.endsWith(".jsonl.lock")) return;
+	return fileName.slice(0, -11).trim() || void 0;
+}
+function getMessageRole(message) {
+	if (!message || typeof message !== "object") return;
+	const role = message.role;
+	return typeof role === "string" ? role : void 0;
+}
+function isMeaningfulTailMessage(message) {
+	const role = getMessageRole(message);
+	if (!role || role === "system") return false;
+	return true;
+}
+function isResumableTailMessage(message) {
+	const role = getMessageRole(message);
+	return role === "user" || role === "tool" || role === "toolResult";
+}
+function isMainSessionResumable(messages) {
+	const lastMeaningful = messages.toReversed().find(isMeaningfulTailMessage);
+	return lastMeaningful ? isResumableTailMessage(lastMeaningful) : false;
+}
+function buildResumeMessage() {
+	return "[System] Your previous turn was interrupted by a gateway restart while Genesis was waiting on tool/model work. Continue from the existing transcript and finish the interrupted response.";
+}
+async function markSessionFailed(params) {
+	await updateSessionStore(params.storePath, (store) => {
+		const entry = store[params.sessionKey];
+		if (!entry || entry.status !== "running") return;
+		entry.status = "failed";
+		entry.abortedLastRun = true;
+		entry.endedAt = Date.now();
+		entry.updatedAt = entry.endedAt;
+		store[params.sessionKey] = entry;
+	}, { skipMaintenance: true });
+	log.warn(`marked interrupted main session failed: ${params.sessionKey} (${params.reason})`);
+}
+async function resumeMainSession(params) {
+	try {
+		await callGateway({
+			method: "agent",
+			params: {
+				message: buildResumeMessage(),
+				sessionKey: params.sessionKey,
+				idempotencyKey: crypto.randomUUID(),
+				deliver: false,
+				lane: "main"
+			},
+			timeoutMs: 1e4
+		});
+		await updateSessionStore(params.storePath, (store) => {
+			const entry = store[params.sessionKey];
+			if (!entry) return;
+			entry.abortedLastRun = false;
+			entry.updatedAt = Date.now();
+			store[params.sessionKey] = entry;
+		}, { skipMaintenance: true });
+		log.info(`resumed interrupted main session: ${params.sessionKey}`);
+		return true;
+	} catch (err) {
+		log.warn(`failed to resume interrupted main session ${params.sessionKey}: ${String(err)}`);
+		return false;
+	}
+}
+async function markRestartAbortedMainSessionsFromLocks(params) {
+	const result = {
+		marked: 0,
+		skipped: 0
+	};
+	const interruptedSessionIds = new Set(params.cleanedLocks.map((lock) => sessionIdFromLockPath(lock.lockPath)).filter((sessionId) => Boolean(sessionId)));
+	if (interruptedSessionIds.size === 0) return result;
+	await updateSessionStore(path.join(path.resolve(params.sessionsDir), "sessions.json"), (store) => {
+		for (const [sessionKey, entry] of Object.entries(store)) {
+			if (!entry || entry.status !== "running") continue;
+			if (shouldSkipMainRecovery(entry, sessionKey)) {
+				result.skipped++;
+				continue;
+			}
+			if (!interruptedSessionIds.has(entry.sessionId)) continue;
+			entry.abortedLastRun = true;
+			store[sessionKey] = entry;
+			result.marked++;
+		}
+	}, { skipMaintenance: true });
+	if (result.marked > 0) log.warn(`marked ${result.marked} interrupted main session(s) from stale transcript locks`);
+	return result;
+}
+async function recoverStore(params) {
+	const result = {
+		recovered: 0,
+		failed: 0,
+		skipped: 0
+	};
+	let store;
+	try {
+		store = loadSessionStore(params.storePath);
+	} catch (err) {
+		log.warn(`failed to load session store ${params.storePath}: ${String(err)}`);
+		result.failed++;
+		return result;
+	}
+	for (const [sessionKey, entry] of Object.entries(store).toSorted(([a], [b]) => a.localeCompare(b))) {
+		if (!entry || entry.status !== "running" || entry.abortedLastRun !== true) continue;
+		if (shouldSkipMainRecovery(entry, sessionKey)) {
+			result.skipped++;
+			continue;
+		}
+		if (params.resumedSessionKeys.has(sessionKey)) {
+			result.skipped++;
+			continue;
+		}
+		let messages;
+		try {
+			messages = readSessionMessages(entry.sessionId, params.storePath, entry.sessionFile);
+		} catch (err) {
+			log.warn(`failed to read transcript for ${sessionKey}: ${String(err)}`);
+			result.failed++;
+			continue;
+		}
+		if (!isMainSessionResumable(messages)) {
+			await markSessionFailed({
+				storePath: params.storePath,
+				sessionKey,
+				reason: "transcript tail is not resumable"
+			});
+			result.failed++;
+			continue;
+		}
+		if (await resumeMainSession({
+			storePath: params.storePath,
+			sessionKey
+		})) {
+			params.resumedSessionKeys.add(sessionKey);
+			result.recovered++;
+		} else result.failed++;
+	}
+	return result;
+}
+async function recoverRestartAbortedMainSessions(params = {}) {
+	const result = {
+		recovered: 0,
+		failed: 0,
+		skipped: 0
+	};
+	const resumedSessionKeys = params.resumedSessionKeys ?? /* @__PURE__ */ new Set();
+	const sessionDirs = await resolveAgentSessionDirs(params.stateDir ?? resolveStateDir(process.env));
+	for (const sessionsDir of sessionDirs) {
+		const storeResult = await recoverStore({
+			storePath: path.join(sessionsDir, "sessions.json"),
+			resumedSessionKeys
+		});
+		result.recovered += storeResult.recovered;
+		result.failed += storeResult.failed;
+		result.skipped += storeResult.skipped;
+	}
+	if (result.recovered > 0 || result.failed > 0) log.info(`main-session restart recovery complete: recovered=${result.recovered} failed=${result.failed} skipped=${result.skipped}`);
+	return result;
+}
+function scheduleRestartAbortedMainSessionRecovery(params = {}) {
+	const initialDelay = params.delayMs ?? DEFAULT_RECOVERY_DELAY_MS;
+	const maxRetries = params.maxRetries ?? MAX_RECOVERY_RETRIES;
+	const resumedSessionKeys = /* @__PURE__ */ new Set();
+	const attemptRecovery = (attempt, delay) => {
+		setTimeout(() => {
+			recoverRestartAbortedMainSessions({
+				stateDir: params.stateDir,
+				resumedSessionKeys
+			}).then((result) => {
+				if (result.failed > 0 && attempt < maxRetries) attemptRecovery(attempt + 1, delay * RETRY_BACKOFF_MULTIPLIER);
+			}).catch((err) => {
+				if (attempt < maxRetries) {
+					log.warn(`main-session restart recovery failed: ${String(err)}`);
+					attemptRecovery(attempt + 1, delay * RETRY_BACKOFF_MULTIPLIER);
+				} else log.warn(`main-session restart recovery gave up: ${String(err)}`);
+			});
+		}, delay).unref?.();
+	};
+	attemptRecovery(1, initialDelay);
+}
+//#endregion
+export { markRestartAbortedMainSessionsFromLocks, scheduleRestartAbortedMainSessionRecovery };

package/dist/managed-image-attachments-DLDa1aE2.js

@@ -0,0 +1,2 @@
+import { a as handleManagedOutgoingImageHttpRequest, i as createManagedOutgoingImageBlocks, n as attachManagedOutgoingImagesToMessage, o as resolveManagedImageAttachmentLimits, r as cleanupManagedOutgoingImageRecords, t as DEFAULT_MANAGED_IMAGE_ATTACHMENT_LIMITS } from "./managed-image-attachments-a4v60Bk3.js";
+export { DEFAULT_MANAGED_IMAGE_ATTACHMENT_LIMITS, attachManagedOutgoingImagesToMessage, cleanupManagedOutgoingImageRecords, createManagedOutgoingImageBlocks, handleManagedOutgoingImageHttpRequest, resolveManagedImageAttachmentLimits };