@keystrokehq/cli 0.0.16 → 0.0.18

package/dist/keystroke.mjs

@@ -1,19 +1,527 @@
 #!/usr/bin/env node
 
-import { n as DEFAULT_CLI_WEB_URL, t as DEFAULT_CLI_SERVER_URL } from "./default-urls-BS4twrsS.mjs";
-import { Command, CommanderError, Option } from "commander";
-import * as fs from "node:fs";
-import { existsSync, writeFileSync } from "node:fs";
-import * as fsPromises from "node:fs/promises";
+import { n as getKeystrokeBaseDir } from "./paths-JzzFkXQA-CEipIeVl.mjs";
+import { n as DEFAULT_CLI_WEB_URL, t as DEFAULT_CLI_SERVER_URL } from "./default-urls-CTQqM1_A.mjs";
 import * as os from "node:os";
 import * as path$1 from "node:path";
 import path from "node:path";
+import * as fsPromises from "node:fs/promises";
+import * as fs from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
+import { Command, CommanderError, Option } from "commander";
 import { fileURLToPath } from "node:url";
 import { config } from "dotenv";
 import { z } from "zod";
 import { log } from "@clack/prompts";
+//#region ../../packages/local-memory/dist/logger/index.mjs
+const LOGS_DIR = "logs";
+const LOG_FILE = "cli.jsonl";
+/**
+* Returns the absolute path to the active CLI log file.
+*
+* Defaults to `~/.keystroke/logs/cli.jsonl`; tests pass a custom `homeDir`
+* to isolate from the real user home.
+*/
+function getLogFilePath(homeDir = os.homedir()) {
+	return path$1.join(getKeystrokeBaseDir(homeDir), LOGS_DIR, LOG_FILE);
+}
+/**
+* Clears the active CLI log file in place. Returns `true` when the file existed
+* and was truncated, `false` when no log file was present (idempotent).
+*/
+async function clearLog(homeDir) {
+	try {
+		await fsPromises.truncate(getLogFilePath(homeDir), 0);
+		return true;
+	} catch (error) {
+		if (isNotFoundError(error)) return false;
+		throw error;
+	}
+}
+function isNotFoundError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+/**
+* Original console methods, captured at module load time before any patching.
+*
+* Use these from CLI code that needs to write to the real terminal regardless
+* of whether `installConsoleCapture()` has been called (e.g. `keystroke logs`
+* pretty-printer, table renderers, spinners).
+*/
+const originalConsole = {
+	log: console.log.bind(console),
+	info: console.info.bind(console),
+	warn: console.warn.bind(console),
+	error: console.error.bind(console),
+	debug: console.debug.bind(console)
+};
+/** Methods we patch and the log level each one maps to. */
+const METHOD_LEVEL_MAP = {
+	log: "info",
+	info: "info",
+	warn: "warn",
+	error: "error",
+	debug: "debug"
+};
+let capturing = false;
+let restoreCapture = null;
+/**
+* Patches global `console.{log,info,warn,error,debug}` to capture output from
+* third-party and workspace packages. Captured output is routed through
+* `options.emit` (typically into the log file). When `forwardToConsole`
+* returns true, the original console method is also invoked so the user
+* sees the output in the terminal — used by `--debug` mode.
+*
+* Idempotent: calling twice has no additional effect and returns the active
+* restore function.
+*/
+function installConsoleCapture(options) {
+	if (capturing) return restoreCapture ?? (() => void 0);
+	capturing = true;
+	const previousConsole = {
+		log: console.log,
+		info: console.info,
+		warn: console.warn,
+		error: console.error,
+		debug: console.debug
+	};
+	for (const [method, level] of Object.entries(METHOD_LEVEL_MAP)) {
+		const original = originalConsole[method];
+		console[method] = (...args) => {
+			const message = args.map(String).join(" ");
+			options.emit(level, `[captured] ${message}`);
+			if (options.forwardToConsole?.()) original(...args);
+		};
+	}
+	restoreCapture = () => {
+		for (const method of Object.keys(METHOD_LEVEL_MAP)) console[method] = previousConsole[method];
+		capturing = false;
+		restoreCapture = null;
+	};
+	return restoreCapture;
+}
+/** Restores console methods patched by `installConsoleCapture()`, if active. */
+function restoreConsoleCapture() {
+	restoreCapture?.();
+}
+/**
+* Reads CLI log entries as parsed `LogEntry` objects. Returns an empty array
+* when the file does not exist.
+*
+* Lines that fail to parse as valid `LogEntry` JSON are dropped silently —
+* the log file is best-effort, and corrupt lines should never break
+* `keystroke logs`.
+*/
+async function readLogEntries(optionsOrCount = 100, homeDir) {
+	const options = normalizeOptions(optionsOrCount, homeDir);
+	const filePath = getLogFilePath(options.homeDir);
+	let content;
+	try {
+		content = await fsPromises.readFile(filePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	const entries = [];
+	for (const line of lines) {
+		const parsed = parseEntry(line);
+		if (parsed && matchesFilters(parsed, options)) entries.push(parsed);
+	}
+	return entries.slice(-options.count);
+}
+function normalizeOptions(optionsOrCount, homeDir) {
+	if (typeof optionsOrCount === "number") return {
+		count: optionsOrCount,
+		homeDir
+	};
+	return {
+		...optionsOrCount,
+		count: optionsOrCount.count ?? 100
+	};
+}
+function matchesFilters(entry, options) {
+	if (options.level !== void 0 && entry.level !== options.level) return false;
+	if (options.messageIncludes !== void 0 && !entry.message.includes(options.messageIncludes)) return false;
+	if (options.meta !== void 0 && !matchesMeta(entry, options.meta)) return false;
+	return true;
+}
+function matchesMeta(entry, expected) {
+	if (entry.meta === void 0) return false;
+	return Object.entries(expected).every(([key, value]) => entry.meta?.[key] === value);
+}
+function parseEntry(line) {
+	let raw;
+	try {
+		raw = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (!isPlainObject$1(raw)) return null;
+	const timestamp = raw.timestamp;
+	const level = raw.level;
+	const message = raw.message;
+	if (typeof timestamp !== "string") return null;
+	if (typeof message !== "string") return null;
+	if (!isLogLevel(level)) return null;
+	const meta = raw.meta;
+	if (meta !== void 0 && !isPlainObject$1(meta)) return null;
+	return {
+		timestamp,
+		level,
+		message,
+		...meta !== void 0 ? { meta } : {}
+	};
+}
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isLogLevel(value) {
+	return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+const REDACTED = "[REDACTED]";
+const SENSITIVE_KEYS = new Set([
+	"apikey",
+	"authorization",
+	"cookie",
+	"jwt",
+	"privatekey",
+	"session",
+	"setcookie",
+	"token",
+	"accesstoken",
+	"refreshtoken",
+	"clientsecret",
+	"secret",
+	"password",
+	"xapikey"
+]);
+function redactLogMeta(meta) {
+	return redactPlainObject(meta, /* @__PURE__ */ new WeakSet());
+}
+function redactValue(value, ancestors) {
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) return value;
+		ancestors.add(value);
+		const redacted = value.map((item) => redactValue(item, ancestors));
+		ancestors.delete(value);
+		return redacted;
+	}
+	if (isPlainObject(value)) {
+		if (ancestors.has(value)) return value;
+		ancestors.add(value);
+		const redacted = redactPlainObject(value, ancestors);
+		ancestors.delete(value);
+		return redacted;
+	}
+	return value;
+}
+function redactPlainObject(value, ancestors) {
+	const redacted = {};
+	for (const [key, childValue] of Object.entries(value)) redacted[key] = isSensitiveKey(key) ? REDACTED : redactValue(childValue, ancestors);
+	return redacted;
+}
+function isSensitiveKey(key) {
+	return SENSITIVE_KEYS.has(normalizeKey(key));
+}
+function normalizeKey(key) {
+	return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+const LEVEL_RANK = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40
+};
+/** Returns true if `entryLevel` should be emitted given the configured `minLevel`. */
+function shouldEmit(entryLevel, minLevel) {
+	return LEVEL_RANK[entryLevel] >= LEVEL_RANK[minLevel];
+}
+function createLogger(options) {
+	let currentLevel = options.level ?? "info";
+	let stream;
+	let closed = false;
+	const ownsStream = options.destination === void 0;
+	if (options.destination) stream = options.destination;
+	else {
+		fs.mkdirSync(path$1.dirname(options.filePath), { recursive: true });
+		stream = fs.createWriteStream(options.filePath, { flags: "a" });
+		stream.on("error", () => {});
+	}
+	function write(level, message, meta) {
+		if (closed || !shouldEmit(level, currentLevel)) return;
+		const redactedMeta = meta !== void 0 ? redactLogMeta(meta) : void 0;
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level,
+			message,
+			...redactedMeta !== void 0 ? { meta: redactedMeta } : {}
+		};
+		if ("destroyed" in stream && stream.destroyed) return;
+		if ("writable" in stream && stream.writable === false) return;
+		try {
+			stream.write(`${JSON.stringify(entry)}\n`);
+		} catch {}
+	}
+	function makeLogger(boundMeta) {
+		const mergeMeta = (meta) => {
+			if (Object.keys(boundMeta).length === 0) return meta;
+			return meta ? {
+				...boundMeta,
+				...meta
+			} : { ...boundMeta };
+		};
+		return {
+			debug: (msg, meta) => write("debug", msg, mergeMeta(meta)),
+			info: (msg, meta) => write("info", msg, mergeMeta(meta)),
+			warn: (msg, meta) => write("warn", msg, mergeMeta(meta)),
+			error: (msg, meta) => write("error", msg, mergeMeta(meta)),
+			child: (bindings) => makeLogger({
+				...boundMeta,
+				...bindings
+			}),
+			flush: async () => {}
+		};
+	}
+	return {
+		logger: makeLogger({}),
+		setLevel(level) {
+			currentLevel = level;
+		},
+		getLevel() {
+			return currentLevel;
+		},
+		flush: async () => {
+			if (!ownsStream) return;
+			await new Promise((resolve) => {
+				stream.write("", () => resolve());
+			});
+		},
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			if (!ownsStream) return;
+			await new Promise((resolve) => {
+				const fileStream = stream;
+				if (fileStream.destroyed) {
+					resolve();
+					return;
+				}
+				fileStream.end(() => resolve());
+			});
+		},
+		filePath: options.filePath
+	};
+}
+/**
+* Tiny ANSI helper used by the debug-mode mirror to dim log lines on stderr.
+*
+* Internal to the logger module — the wider local-memory package has no UI
+* concern. CLI consumers have richer terminal/colors libraries; we only need
+* "dim" here so the captured log lines visually fade behind the user-facing
+* output.
+*/
+const ESC = "\x1B[";
+const ANSI$1 = {
+	reset: `${ESC}0m`,
+	dim: `${ESC}2m`
+};
+/** Returns `code + s + reset`, or `s` unchanged if stderr is not a TTY. */
+function style$1(s, code) {
+	if (!process.stderr.isTTY) return s;
+	return `${code}${s}${ANSI$1.reset}`;
+}
+/**
+* Maximum number of log lines to keep when pruning. Lines beyond this count
+* (oldest first) are dropped on next prune.
+*/
+const MAX_LOG_LINES = 25e4;
+/**
+* Maximum number of bytes to read from the tail of the log file when pruning.
+* If the file is larger than this, only this many bytes are inspected — older
+* lines beyond this window are dropped wholesale.
+*/
+const MAX_PRUNE_READ_BYTES = 32 * 1024 * 1024;
+/**
+* Truncates the log file to keep only the most recent `MAX_LOG_LINES` lines.
+* Best-effort: failures are silent (the file is non-critical telemetry).
+*
+* This remains the local CLI log retention strategy: simple, dependency-free,
+* and best-effort because the file is non-critical telemetry.
+*/
+async function pruneLogFile(homeDir) {
+	const filePath = getLogFilePath(homeDir);
+	let content;
+	try {
+		content = await readTailForPrune(filePath);
+	} catch {
+		return;
+	}
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	if (lines.length <= 25e4) return;
+	const kept = lines.slice(lines.length - MAX_LOG_LINES);
+	await fsPromises.writeFile(filePath, `${kept.join("\n")}\n`);
+}
+/**
+* Reads up to the last `MAX_PRUNE_READ_BYTES` of the file. If the file is
+* larger than that, drops the first partial line so we don't try to parse
+* a half-written record.
+*/
+async function readTailForPrune(filePath) {
+	const handle = await fsPromises.open(filePath, "r");
+	try {
+		const stats = await handle.stat();
+		const bytesToRead = Math.min(stats.size, MAX_PRUNE_READ_BYTES);
+		if (bytesToRead <= 0) return "";
+		const start = Math.max(0, stats.size - bytesToRead);
+		const buffer = Buffer.alloc(bytesToRead);
+		const { bytesRead } = await handle.read(buffer, 0, bytesToRead, start);
+		let content = buffer.subarray(0, bytesRead).toString("utf8");
+		if (start > 0) {
+			const firstNewline = content.indexOf("\n");
+			if (firstNewline === -1) return "";
+			content = content.slice(firstNewline + 1);
+		}
+		return content;
+	} finally {
+		await handle.close();
+	}
+}
+let instance = null;
+let debugMode = false;
+const DEBUG_PREFIXES = {
+	debug: "[DEBUG]",
+	info: "[INFO]",
+	warn: "[WARN]",
+	error: "[ERROR]"
+};
+function formatTimestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+}
+function maybeMirrorToStderr(level, message, meta) {
+	if (!debugMode) return;
+	const ts = formatTimestamp();
+	const prefix = DEBUG_PREFIXES[level];
+	const redactedMeta = meta !== void 0 ? redactLogMeta(meta) : void 0;
+	const formatted = meta ? `${ts} ${prefix} ${message} ${JSON.stringify(redactedMeta)}` : `${ts} ${prefix} ${message}`;
+	originalConsole.info(style$1(formatted, ANSI$1.dim));
+}
+function withDebugMirroring(inner, boundMeta = {}) {
+	const mergeMeta = (meta) => {
+		if (Object.keys(boundMeta).length === 0) return meta;
+		return meta ? {
+			...boundMeta,
+			...meta
+		} : { ...boundMeta };
+	};
+	return {
+		debug: (msg, meta) => {
+			maybeMirrorToStderr("debug", msg, mergeMeta(meta));
+			inner.debug(msg, meta);
+		},
+		info: (msg, meta) => {
+			maybeMirrorToStderr("info", msg, mergeMeta(meta));
+			inner.info(msg, meta);
+		},
+		warn: (msg, meta) => {
+			maybeMirrorToStderr("warn", msg, mergeMeta(meta));
+			inner.warn(msg, meta);
+		},
+		error: (msg, meta) => {
+			maybeMirrorToStderr("error", msg, mergeMeta(meta));
+			inner.error(msg, meta);
+		},
+		child: (bindings) => withDebugMirroring(inner.child(bindings), {
+			...boundMeta,
+			...bindings
+		}),
+		flush: () => inner.flush()
+	};
+}
+function buildSingleton(options = {}) {
+	const internal = createLogger({
+		filePath: getLogFilePath(options.homeDir),
+		level: options.level ?? "info"
+	});
+	return {
+		...internal,
+		logger: withDebugMirroring(internal.logger)
+	};
+}
+/**
+* Initializes the process-wide singleton logger. Optional — the singleton is
+* lazily created on first `getLogger()` call. Use `initLogger()` explicitly
+* when you want to control the level, prune the log file, or install console
+* capture at a known point in CLI startup.
+*/
+async function initLogger(options = {}) {
+	if (instance === null && options.prune !== false) await pruneLogFile(options.homeDir).catch((error) => {
+		if (process.env.KEYSTROKE_DEBUG_LOGGER === "1") {
+			const message = error instanceof Error ? error.message : String(error);
+			originalConsole.warn(`[logger] Failed to prune CLI log file: ${message}`);
+		}
+	});
+	if (instance === null) instance = buildSingleton(options);
+	else if (options.level !== void 0) instance.setLevel(options.level);
+	if (options.captureConsole !== false) installConsoleCapture({
+		emit: (level, message) => {
+			instance?.logger[level](message);
+		},
+		forwardToConsole: () => debugMode
+	});
+	else restoreConsoleCapture();
+}
+/**
+* Returns the singleton logger. Lazily initialized on first call (with
+* default options) if `initLogger()` has not been called yet.
+*/
+function getLogger() {
+	if (instance === null) instance = buildSingleton();
+	return instance.logger;
+}
+/** Flushes pending writes and closes the underlying file stream. Idempotent. */
+async function closeLogger() {
+	if (instance === null) {
+		restoreConsoleCapture();
+		return;
+	}
+	await instance.flush();
+	await instance.close();
+	instance = null;
+	restoreConsoleCapture();
+}
+/**
+* Toggles debug mode. When enabled:
+*   - Every log line is mirrored to stderr (dimmed) for visibility.
+*   - Console capture forwards captured calls to the real console method.
+*/
+function setDebug(enabled) {
+	debugMode = enabled;
+}
+/**
+* Convenience proxy that delegates every call to the singleton logger. Lets
+* call sites use `import { logger } from '@keystroke/local-memory/logger'`
+* without thinking about lifecycle — the singleton lazily initializes on
+* first use.
+*/
+const logger = {
+	debug: (msg, meta) => getLogger().debug(msg, meta),
+	info: (msg, meta) => getLogger().info(msg, meta),
+	warn: (msg, meta) => getLogger().warn(msg, meta),
+	error: (msg, meta) => getLogger().error(msg, meta),
+	child: (bindings) => getLogger().child(bindings),
+	flush: () => getLogger().flush()
+};
+//#endregion
 //#region package.json
-var version = "0.0.16";
+var version = "0.0.18";
 //#endregion
 //#region src/command-registry.ts
 const ROOT_OPTIONS_WITH_VALUES$1 = new Set([
@@ -25,84 +533,84 @@ const ROOT_VERSION_FLAGS = new Set(["-V", "--version"]);
 const lazyCommandDefinitions = [
 	{
 		name: "agents",
-		loadCommand: async () => (await import("./agents-CbmvvOAx.mjs")).createAgentsCommand()
+		loadCommand: async () => (await import("./agents-Co6Jy_N8.mjs")).createAgentsCommand()
 	},
 	{
 		name: "admin",
-		loadCommand: async () => (await import("./admin-Bb9Hx-gO.mjs")).createAdminCommand()
+		loadCommand: async () => (await import("./admin-CYpulx_A.mjs")).createAdminCommand()
 	},
 	{
 		name: "api-keys",
-		loadCommand: async () => (await import("./api-keys-DJlyIf10.mjs")).createApiKeysCommand()
+		loadCommand: async () => (await import("./api-keys-BUCLzRv_.mjs")).createApiKeysCommand()
 	},
 	{
 		name: "auth",
-		loadCommand: async () => (await import("./auth-DpDEkJz7.mjs")).createAuthCommand()
+		loadCommand: async () => (await import("./auth-niNm-yNT.mjs")).createAuthCommand()
 	},
 	{
 		name: "connect",
-		loadCommand: async () => (await import("./connect-DzSNDSmI.mjs")).createConnectCommand()
+		loadCommand: async () => (await import("./connect-C9NMD8Ky.mjs")).createConnectCommand()
 	},
 	{
 		name: "credentials",
-		loadCommand: async () => (await import("./credentials-VidBoOd7.mjs")).createCredentialsCommand(),
+		loadCommand: async () => (await import("./credentials-fMfKVlEn.mjs")).createCredentialsCommand(),
 		copyInheritedSettings: true
 	},
 	{
 		name: "org",
-		loadCommand: async () => (await import("./org-DUCts2MV.mjs")).createOrgCommand()
+		loadCommand: async () => (await import("./org-DGS91uc-.mjs")).createOrgCommand()
 	},
 	{
 		name: "deploy",
-		loadCommand: async () => (await import("./deploy-eshEEiP-.mjs")).createDeployCommand()
+		loadCommand: async () => (await import("./deploy-B7LRWcp6.mjs")).createDeployCommand()
 	},
 	{
 		name: "init",
-		loadCommand: async () => (await import("./init-PTwX63_P.mjs")).createInitCommand()
+		loadCommand: async () => (await import("./init-jaqNLGmB.mjs")).createInitCommand()
 	},
 	{
 		name: "integrations",
-		loadCommand: async () => (await import("./integrations-B0Gv-L0s.mjs")).createIntegrationsCommand()
+		loadCommand: async () => (await import("./integrations-DRL3JmC8.mjs")).createIntegrationsCommand()
 	},
 	{
 		name: "invites",
-		loadCommand: async () => (await import("./invites-Cqi7iyIN.mjs")).createInvitesCommand()
+		loadCommand: async () => (await import("./invites-VntHNMYk.mjs")).createInvitesCommand()
 	},
 	{
 		name: "logs",
-		loadCommand: async () => (await import("./logs-DUwdYZB-.mjs")).createLogsCommand()
+		loadCommand: async () => (await import("./logs-CcYqFKRU.mjs")).createLogsCommand()
 	},
 	{
 		name: "listen",
-		loadCommand: async () => (await import("./listen-rHLiCWbn.mjs")).createListenCommand()
+		loadCommand: async () => (await import("./listen-DLGZEQRL.mjs")).createListenCommand()
 	},
 	{
 		name: "projects",
-		loadCommand: async () => (await import("./projects-CbquwUlm.mjs")).createProjectsCommand()
+		loadCommand: async () => (await import("./projects-D90_uEC2.mjs")).createProjectsCommand()
 	},
 	{
 		name: "runs",
-		loadCommand: async () => (await import("./runs-Bc3zjk7V.mjs")).createRunsCommand()
+		loadCommand: async () => (await import("./runs-Bg_qDeQi.mjs")).createRunsCommand()
 	},
 	{
 		name: "skills",
-		loadCommand: async () => (await import("./skills.command-DuL4kLUi.mjs")).createSkillsCommand()
+		loadCommand: async () => (await import("./skills.command-JwKWpGvU.mjs")).createSkillsCommand()
 	},
 	{
 		name: "sync",
-		loadCommand: async () => (await import("./sync-Pssitj6K.mjs")).createSyncCommand()
+		loadCommand: async () => (await import("./sync-CXNveL61.mjs")).createSyncCommand()
 	},
 	{
 		name: "test",
-		loadCommand: async () => (await import("./test-BISghlKg.mjs")).createTestCommand()
+		loadCommand: async () => (await import("./test-A5hz3c7j.mjs")).createTestCommand()
 	},
 	{
 		name: "upgrade",
-		loadCommand: async () => (await import("./upgrade-cH9I_pZq.mjs")).createUpgradeCommand()
+		loadCommand: async () => (await import("./upgrade-DhfpoyRV.mjs")).createUpgradeCommand()
 	},
 	{
 		name: "workflows",
-		loadCommand: async () => (await import("./workflows-CL1jYSLR.mjs")).createWorkflowsCommand()
+		loadCommand: async () => (await import("./workflows-Dy2M9bEr.mjs")).createWorkflowsCommand()
 	}
 ];
 function selectCommandRegistration(argv, commandNames = new Set(lazyCommandDefinitions.map((definition) => definition.name))) {
@@ -295,183 +803,6 @@ async function getApiErrorCode(error) {
 	}
 }
 //#endregion
-//#region src/lib/tty.ts
-function isTTY() {
-	return process.stdout.isTTY === true;
-}
-//#endregion
-//#region src/lib/terminal.ts
-const ANSI = {
-	reset: "\x1B[0m",
-	bold: "\x1B[1m",
-	dim: "\x1B[2m",
-	red: "\x1B[31m",
-	cyan: "\x1B[36m",
-	green: "\x1B[32m",
-	yellow: "\x1B[33m"
-};
-function style(text, color) {
-	if (!isTTY()) return text;
-	return `${color}${text}${ANSI.reset}`;
-}
-//#endregion
-//#region src/lib/logger.ts
-/**
-* Original console methods, saved before any patching.
-* Used by ui.ts to always write to the real terminal regardless of capture.
-*/
-const originalConsole = {
-	log: console.log.bind(console),
-	info: console.info.bind(console),
-	warn: console.warn.bind(console),
-	error: console.error.bind(console),
-	debug: console.debug.bind(console)
-};
-let stream = null;
-let debugMode = false;
-/** When true, do not open or write the log file (avoids races after {@link logger.close}). */
-let loggingClosed = false;
-const KEYSTROKE_CREDENTIALS_DIR = ".keystroke";
-const KEYSTROKE_LOGS_DIR = "logs";
-const KEYSTROKE_LOG_FILE = "cli.jsonl";
-const MAX_LOG_LINES = 25e4;
-const MAX_PRUNE_READ_BYTES = 32 * 1024 * 1024;
-const DEBUG_PREFIXES = {
-	debug: "[DEBUG]",
-	info: "[INFO]",
-	warn: "[WARN]",
-	error: "[ERROR]"
-};
-const LEVEL_MAP = {
-	log: "info",
-	info: "info",
-	warn: "warn",
-	error: "error",
-	debug: "debug"
-};
-function ensureStream() {
-	if (loggingClosed) return null;
-	if (!stream) {
-		const logFilePath = getLogFilePath();
-		fs.mkdirSync(path$1.dirname(logFilePath), { recursive: true });
-		stream = fs.createWriteStream(logFilePath, { flags: "a" });
-		stream.on("error", () => {});
-	}
-	return stream;
-}
-function getLogFilePath(homeDir = os.homedir()) {
-	return path$1.join(homeDir, KEYSTROKE_CREDENTIALS_DIR, KEYSTROKE_LOGS_DIR, KEYSTROKE_LOG_FILE);
-}
-async function readTailForPrune(filePath) {
-	const handle = await fsPromises.open(filePath, "r");
-	try {
-		const stats = await handle.stat();
-		const bytesToRead = Math.min(stats.size, MAX_PRUNE_READ_BYTES);
-		if (bytesToRead <= 0) return "";
-		const start = Math.max(0, stats.size - bytesToRead);
-		const buffer = Buffer.alloc(bytesToRead);
-		const { bytesRead } = await handle.read(buffer, 0, bytesToRead, start);
-		let content = buffer.subarray(0, bytesRead).toString("utf8");
-		if (start > 0) {
-			const firstNewline = content.indexOf("\n");
-			if (firstNewline === -1) return "";
-			content = content.slice(firstNewline + 1);
-		}
-		return content;
-	} finally {
-		await handle.close();
-	}
-}
-async function pruneLogFile() {
-	const filePath = getLogFilePath();
-	let content;
-	try {
-		content = await readTailForPrune(filePath);
-	} catch {
-		return;
-	}
-	const lines = content.split("\n");
-	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-	if (lines.length <= MAX_LOG_LINES) return;
-	const kept = lines.slice(lines.length - MAX_LOG_LINES);
-	await fsPromises.writeFile(filePath, `${kept.join("\n")}\n`);
-}
-function formatTimestamp() {
-	const now = /* @__PURE__ */ new Date();
-	return `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
-}
-function write(level, message, meta) {
-	if (loggingClosed) return;
-	const entry = {
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		level,
-		message,
-		...meta !== void 0 ? { meta } : {}
-	};
-	const s = ensureStream();
-	if (s && !s.destroyed && s.writable) try {
-		s.write(`${JSON.stringify(entry)}\n`);
-	} catch {}
-	if (debugMode) {
-		const ts = formatTimestamp();
-		const prefix = DEBUG_PREFIXES[level];
-		const formatted = meta ? `${ts} ${prefix} ${message} ${JSON.stringify(meta)}` : `${ts} ${prefix} ${message}`;
-		originalConsole.info(style(formatted, ANSI.dim));
-	}
-}
-/**
-* Patches global console methods to capture output from third-party
-* and workspace packages. Captured output is always written to the
-* log file and only forwarded to the real console when --debug is active.
-*/
-function installConsoleCapture() {
-	for (const method of [
-		"log",
-		"info",
-		"warn",
-		"error",
-		"debug"
-	]) {
-		const level = LEVEL_MAP[method] ?? "info";
-		const original = originalConsole[method];
-		console[method] = (...args) => {
-			write(level, `[captured] ${args.map(String).join(" ")}`);
-			if (debugMode) original(...args);
-		};
-	}
-}
-/**
-* Initialize the logger: install console capture and prune the log file.
-* Call once at CLI startup.
-*/
-function initLogger() {
-	installConsoleCapture();
-	pruneLogFile().catch((error) => {
-		if (process.env.KEYSTROKE_DEBUG_LOGGER === "1") {
-			const message = error instanceof Error ? error.message : String(error);
-			originalConsole.warn(`[logger] Failed to prune CLI log file: ${message}`);
-		}
-	});
-}
-const logger = {
-	debug: (msg, meta) => write("debug", msg, meta),
-	info: (msg, meta) => write("info", msg, meta),
-	warn: (msg, meta) => write("warn", msg, meta),
-	error: (msg, meta) => write("error", msg, meta),
-	/** Enable or disable debug mode (shows all log entries in the console). */
-	setDebug(enabled) {
-		debugMode = enabled;
-	},
-	/** Stop accepting log writes and tear down the log file stream. */
-	close() {
-		loggingClosed = true;
-		if (stream) {
-			stream.end();
-			stream = null;
-		}
-	}
-};
-//#endregion
 //#region src/lib/cli-telemetry.ts
 const TELEMETRY_TIMEOUT_MS = 2500;
 let state = null;
@@ -822,6 +1153,26 @@ function isNpmPackageMetadata(value) {
 	return typeof distTags.latest === "string";
 }
 //#endregion
+//#region src/lib/tty.ts
+function isTTY() {
+	return process.stdout.isTTY === true;
+}
+//#endregion
+//#region src/lib/terminal.ts
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	red: "\x1B[31m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m"
+};
+function style(text, color) {
+	if (!isTTY()) return text;
+	return `${color}${text}${ANSI.reset}`;
+}
+//#endregion
 //#region src/lib/update-notice.ts
 const CLI_PACKAGE_NAME = "@keystrokehq/cli";
 const DEFAULT_TIMEOUT_MS = 750;
@@ -934,8 +1285,8 @@ function resolveCliExitCode(error) {
 	return 1;
 }
 async function runCli() {
-	initLogger();
-	if (process.argv.includes("--debug")) logger.setDebug(true);
+	await initLogger();
+	if (process.argv.includes("--debug")) setDebug(true);
 	if (shouldLogCliStartup(process.argv.slice(2))) logger.info("CLI started", {
 		argv: process.argv.slice(2),
 		runMode: getRunMode()
@@ -968,9 +1319,9 @@ async function main() {
 	await new Promise((resolve) => {
 		setImmediate(resolve);
 	});
-	logger.close();
+	await closeLogger();
 	process.exit(exitCode);
 }
 main();
 //#endregion
-export { InputValidationError as A, AUTH_URL_PATH as C, CLI_AUTH_COMMAND as D, CALLBACK_PATH as E, WorkflowResolutionError as M, throwReportedCliExit as N, AuthenticationError as O, AUTH_TIMEOUT_SECONDS as S, CALLBACK_LOOPBACK_ORIGIN as T, getApiErrorCode as _, getProcessEnv as a, isNetworkError as b, resolveCliWebUrl as c, originalConsole as d, ANSI as f, REAUTH_HINT as g, AUTH_HINT as h, getEnv as i, ProjectNotFoundError as j, CliExitError as k, captureCliTelemetryResolvedContext as l, isTTY as m, ui as n, isLocalMode as o, style as p, createHiddenGlobalOptions as r, resolveCliServerUrl as s, fetchLatestNpmPackageVersion as t, logger as u, getHttpStatus as v, CALLBACK_LOOPBACK_HOST as w, toErrorMessage as x, isAuthError as y };
+export { WorkflowResolutionError as A, CALLBACK_LOOPBACK_ORIGIN as C, CliExitError as D, AuthenticationError as E, originalConsole as F, readLogEntries as I, setDebug as L, clearLog as M, closeLogger as N, InputValidationError as O, logger as P, CALLBACK_LOOPBACK_HOST as S, CLI_AUTH_COMMAND as T, isAuthError as _, ui as a, AUTH_TIMEOUT_SECONDS as b, getProcessEnv as c, resolveCliWebUrl as d, captureCliTelemetryResolvedContext as f, getHttpStatus as g, getApiErrorCode as h, fetchLatestNpmPackageVersion as i, throwReportedCliExit as j, ProjectNotFoundError as k, isLocalMode as l, REAUTH_HINT as m, style as n, createHiddenGlobalOptions as o, AUTH_HINT as p, isTTY as r, getEnv as s, ANSI as t, resolveCliServerUrl as u, isNetworkError as v, CALLBACK_PATH as w, AUTH_URL_PATH as x, toErrorMessage as y };