agent-tail-core 0.3.9 → 0.4.0

package/README.md

@@ -14,6 +14,8 @@ Each service gets its own log file (`fe.log`, `api.log`) plus a `combined.log` w
 
 ```bash
 tail -f tmp/logs/latest/combined.log
+# or
+agent-tail tail combined -f
 ```
 
 ## CLI commands
@@ -21,6 +23,7 @@ tail -f tmp/logs/latest/combined.log
 - **`agent-tail run`** — spawn services with unified logging (recommended)
 - **`agent-tail init`** — create a session directory
 - **`agent-tail wrap`** — pipe a single command into an existing session
+- **`agent-tail tail`** — resolve the latest session, then forward to system `tail`
 
 ## Options
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as cmd_run, r as cmd_wrap, t as cmd_init } from "./commands-Bw4eTFz0.mjs";
+import { i as cmd_wrap, n as cmd_run, r as cmd_tail, t as cmd_init } from "./commands-Bv44Rf77.mjs";
 import { parseArgs } from "node:util";
 
 //#region src/cli.ts
@@ -10,8 +10,9 @@ const HELP = `
     agent-tail init                          Create a new log session
     agent-tail wrap <name> -- <command...>   Wrap a command, pipe output to <name>.log
     agent-tail run <config...>               Run multiple services concurrently
+    agent-tail tail [query] [--] [tail args...]  Tail the latest session's logs via system tail
 
-  \x1b[1mOptions:\x1b[0m
+  \x1b[1mShared Options:\x1b[0m
     --log-dir <dir>       Log directory relative to cwd (default: tmp/logs)
     --max-sessions <n>    Max sessions to keep (default: 10)
     --no-combined         Don't write to combined.log
@@ -19,11 +20,18 @@ const HELP = `
     --mute <name>         Mute a service from terminal and combined.log (repeatable, still logs to <name>.log)
     -h, --help            Show this help
 
+  \x1b[1mTail:\x1b[0m
+    agent-tail tail        Tail every .log file in the latest session
+    agent-tail tail <log>  Tail a specific log by exact or partial name
+    tail args              Forwarded directly to system tail (for example: -f, -n 50)
+
   \x1b[1mExamples:\x1b[0m
     agent-tail init
     agent-tail wrap api -- uv run fastapi-server
     agent-tail wrap worker -- python -m celery worker
     agent-tail run "fe: npm run dev" "api: uv run server" "worker: uv run worker"
+    agent-tail tail -f
+    agent-tail tail browser -n 50
 `;
 function parse_cli_options(args) {
 	const dash_index = args.indexOf("--");
@@ -77,6 +85,45 @@ function parse_cli_options(args) {
 		rest
 	};
 }
+function parse_tail_options(args) {
+	let log_dir = "tmp/logs";
+	let query;
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (arg === "--") {
+			i += 1;
+			break;
+		}
+		if (!arg.startsWith("-") || arg === "-") break;
+		switch (arg) {
+			case "--log-dir":
+				log_dir = args[i + 1] ?? "";
+				if (!log_dir) throw new Error(`Missing value for ${arg}`);
+				i += 2;
+				continue;
+			case "--help":
+			case "-h":
+				console.log(HELP);
+				process.exit(0);
+			default: return {
+				log_dir,
+				query,
+				tail_args: args.slice(i)
+			};
+		}
+	}
+	if (args[i] && !args[i].startsWith("-")) {
+		query = args[i];
+		i += 1;
+	}
+	if (args[i] === "--") i += 1;
+	return {
+		log_dir,
+		query,
+		tail_args: args.slice(i)
+	};
+}
 async function main() {
 	const args = process.argv.slice(2);
 	if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
@@ -84,24 +131,33 @@ async function main() {
 		process.exit(0);
 	}
 	const subcommand = args[0];
-	const { options, positionals, rest } = parse_cli_options(args.slice(1));
+	const sub_args = args.slice(1);
 	const project_root = process.cwd();
 	try {
 		switch (subcommand) {
 			case "init": {
+				const { options } = parse_cli_options(sub_args);
 				const session_dir = cmd_init(project_root, options);
 				console.log(session_dir);
 				break;
 			}
 			case "wrap": {
+				const { options, positionals, rest } = parse_cli_options(sub_args);
 				const code = await cmd_wrap(project_root, positionals[0], rest, options);
 				process.exit(code);
 				break;
 			}
-			case "run":
+			case "run": {
+				const { options, positionals } = parse_cli_options(sub_args);
 				await cmd_run(project_root, positionals, options);
 				process.exit(0);
 				break;
+			}
+			case "tail": {
+				const code = await cmd_tail(project_root, parse_tail_options(sub_args));
+				process.exit(code);
+				break;
+			}
 			default:
 				console.error(`\x1b[36m[agent-tail]\x1b[0m Unknown command: ${subcommand}`);
 				console.log(HELP);

package/dist/{commands-Bw4eTFz0.mjs → commands-Bv44Rf77.mjs}

@@ -86,6 +86,15 @@ var LogManager = class {
 	* points to a valid directory, return it. Otherwise create a new session.
 	*/
 	resolve_session(project_root) {
+		const existing = this.find_session(project_root);
+		if (existing) return existing;
+		const log_path = this.initialize(project_root);
+		return path.dirname(log_path);
+	}
+	/**
+	* Find the current session directory if one already exists.
+	*/
+	find_session(project_root) {
 		const log_dir = path.resolve(project_root, this.options.logDir);
 		const latest_link = path.join(log_dir, "latest");
 		try {
@@ -93,11 +102,10 @@ var LogManager = class {
 			let target;
 			if (stat.isSymbolicLink()) target = fs.realpathSync(latest_link);
 			else if (stat.isFile()) target = fs.readFileSync(latest_link, "utf-8").trim();
-			else throw new Error("unexpected latest type");
+			else return null;
 			if (fs.existsSync(target) && fs.statSync(target).isDirectory()) return target;
 		} catch {}
-		const log_path = this.initialize(project_root);
-		return path.dirname(log_path);
+		return null;
 	}
 	check_gitignore(project_root) {
 		const gitignore_path = path.join(project_root, ".gitignore");
@@ -178,6 +186,42 @@ function cmd_init(project_root, options = DEFAULT_CLI_OPTIONS) {
 function resolve_session_dir(project_root, options = DEFAULT_CLI_OPTIONS) {
 	return create_manager(options).resolve_session(project_root);
 }
+function find_session_dir(project_root, log_dir = DEFAULT_CLI_OPTIONS.log_dir) {
+	return create_manager({
+		...DEFAULT_CLI_OPTIONS,
+		log_dir
+	}).find_session(project_root);
+}
+function forward_signals_to_children(children) {
+	const signal_handlers = ["SIGINT", "SIGTERM"].map((signal) => {
+		const handler = () => {
+			for (const child of children) child.kill(signal);
+		};
+		process.on(signal, handler);
+		return [signal, handler];
+	});
+	return () => {
+		for (const [signal, handler] of signal_handlers) process.off(signal, handler);
+	};
+}
+function resolve_tail_paths(project_root, options) {
+	const session_dir = find_session_dir(project_root, options.log_dir);
+	const resolved_log_dir = path.resolve(project_root, options.log_dir);
+	if (!session_dir) throw new Error(`No log session found in ${resolved_log_dir}. Run "agent-tail run", "agent-tail wrap", or start a framework plugin first.`);
+	const log_files = fs.readdirSync(session_dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+	if (log_files.length === 0) throw new Error(`No .log files found in ${session_dir}.`);
+	if (!options.query) return log_files.map((file_name) => path.join(session_dir, file_name));
+	const normalized_query = options.query.toLowerCase();
+	const exact_names = new Set([normalized_query, normalized_query.endsWith(".log") ? normalized_query : `${normalized_query}.log`]);
+	const exact_matches = log_files.filter((file_name) => exact_names.has(file_name.toLowerCase()));
+	if (exact_matches.length > 0) return exact_matches.map((file_name) => path.join(session_dir, file_name));
+	const partial_matches = log_files.filter((file_name) => {
+		const normalized_name = file_name.toLowerCase();
+		return normalized_name.includes(normalized_query) || path.basename(normalized_name, ".log").includes(normalized_query);
+	});
+	if (partial_matches.length > 0) return partial_matches.map((file_name) => path.join(session_dir, file_name));
+	throw new Error(`No logs found for "${options.query}" in ${session_dir}. Available logs: ${log_files.join(", ")}`);
+}
 function parse_service_configs(args) {
 	return args.map((arg) => {
 		const colon_index = arg.indexOf(":");
@@ -189,6 +233,28 @@ function parse_service_configs(args) {
 	});
 }
 /**
+* Tail the latest session's logs by forwarding to the system tail command.
+*/
+function cmd_tail(project_root, options) {
+	const log_paths = resolve_tail_paths(project_root, options);
+	const child = spawn("tail", [...options.tail_args, ...log_paths], { stdio: "inherit" });
+	const cleanup_signal_handlers = forward_signals_to_children([child]);
+	return new Promise((resolve, reject) => {
+		child.on("close", (code) => {
+			cleanup_signal_handlers();
+			resolve(code ?? 0);
+		});
+		child.on("error", (err) => {
+			cleanup_signal_handlers();
+			if (err.code === "ENOENT") {
+				reject(/* @__PURE__ */ new Error("System \"tail\" command not found. \"agent-tail tail\" requires a POSIX-style tail binary."));
+				return;
+			}
+			reject(err);
+		});
+	});
+}
+/**
 * Write data to a log stream and optionally to combined.log with a prefix.
 */
 function write_to_logs(chunk, name, log_stream, combined_stream, excludes = []) {
@@ -238,20 +304,20 @@ function cmd_wrap(project_root, name, command, options = DEFAULT_CLI_OPTIONS) {
 		process.stderr.write(chunk);
 		write_to_logs(chunk, name, log_stream, combined_stream, options.excludes);
 	});
+	const cleanup_signal_handlers = forward_signals_to_children([child]);
 	return new Promise((resolve, reject) => {
 		child.on("close", (code) => {
+			cleanup_signal_handlers();
 			log_stream.end();
 			combined_stream?.end();
 			resolve(code ?? 0);
 		});
 		child.on("error", (err) => {
+			cleanup_signal_handlers();
 			log_stream.end();
 			combined_stream?.end();
 			reject(err);
 		});
-		for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
-			child.kill(signal);
-		});
 	});
 }
 const COLORS = [
@@ -332,13 +398,15 @@ function cmd_run(project_root, service_args, options = DEFAULT_CLI_OPTIONS) {
 			});
 		});
 	});
-	for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
-		for (const child of children) child.kill(signal);
-	});
+	const cleanup_signal_handlers = forward_signals_to_children(children);
 	return Promise.all(promises).then(() => {
+		cleanup_signal_handlers();
 		combined_stream?.end();
+	}, (error) => {
+		cleanup_signal_handlers();
+		throw error;
 	});
 }
 
 //#endregion
-export { resolve_session_dir as a, LogManager as c, parse_service_configs as i, SESSION_ENV_VAR as l, cmd_run as n, DEFAULT_OPTIONS as o, cmd_wrap as r, resolve_options as s, cmd_init as t, should_exclude as u };
+export { parse_service_configs as a, resolve_options as c, should_exclude as d, cmd_wrap as i, LogManager as l, cmd_run as n, resolve_session_dir as o, cmd_tail as r, DEFAULT_OPTIONS as s, cmd_init as t, SESSION_ENV_VAR as u };

package/dist/index.d.mts

@@ -65,6 +65,10 @@ declare class LogManager {
    * points to a valid directory, return it. Otherwise create a new session.
    */
   resolve_session(project_root: string): string;
+  /**
+   * Find the current session directory if one already exists.
+   */
+  find_session(project_root: string): string | null;
   check_gitignore(project_root: string): void;
 }
 //#endregion

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as resolve_session_dir, c as LogManager, i as parse_service_configs, l as SESSION_ENV_VAR, n as cmd_run, o as DEFAULT_OPTIONS, r as cmd_wrap, s as resolve_options, t as cmd_init, u as should_exclude } from "./commands-Bw4eTFz0.mjs";
+import { a as parse_service_configs, c as resolve_options, d as should_exclude, i as cmd_wrap, l as LogManager, n as cmd_run, o as resolve_session_dir, s as DEFAULT_OPTIONS, t as cmd_init, u as SESSION_ENV_VAR } from "./commands-Bv44Rf77.mjs";
 
 //#region src/formatter.ts
 function format_log_line(entry) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-tail-core",
   "type": "module",
-  "version": "0.3.9",
+  "version": "0.4.0",
   "description": "Core utilities for agent-tail log capture plugins.",
   "license": "MIT",
   "repository": {