@agentuity/cli 0.1.33 → 0.1.35

package/src/internal-logger.ts

@@ -0,0 +1,411 @@
+/**
+ * Internal Logger for CLI command tracing
+ *
+ * This logger captures all CLI execution details for debugging purposes.
+ * It maintains two files per command execution:
+ * 1. session.json - Command metadata, environment, and system info
+ * 2. logs.jsonl - JSON Lines format log entries
+ *
+ * The logger automatically cleans up old logs, keeping only the most recent execution.
+ */
+
+import {
+	appendFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	rmSync,
+	writeFileSync,
+	readFileSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, platform, arch, cpus, totalmem } from 'node:os';
+import type { Logger, LogLevel } from '@agentuity/core';
+import { randomUUID } from 'node:crypto';
+
+// Sensitive environment variable patterns to mask
+const SENSITIVE_ENV_PATTERNS = [
+	/KEY/i, // Any env var with KEY in the name
+	/SECRET/i,
+	/TOKEN/i,
+	/PASSWORD/i,
+	/^AWS_/i,
+	/^GCP_/i,
+	/^AZURE_/i,
+	/^CLOUDFLARE_/i,
+	/^DATABASE_URL$/i,
+	/^DB_/i,
+	/^QUILL_/i, // Code signing keys
+	/^MACOS_/i, // macOS signing keys
+	/_P12$/i, // Certificate files
+	/BEARER/i,
+	/CREDENTIALS?/i,
+	/AUTH/i,
+];
+
+interface SessionMetadata {
+	sessionId: string;
+	command: string;
+	args: string[];
+	timestamp: string;
+	cli: {
+		version: string;
+		name: string;
+	};
+	system: {
+		platform: string;
+		arch: string;
+		cpus: number;
+		memory: number;
+		bunPath: string;
+		bunVersion: string;
+	};
+	environment: Record<string, string>;
+	cwd: string;
+	userId?: string;
+	projectId?: string;
+	orgId?: string;
+}
+
+interface LogEntry {
+	timestamp: string;
+	level: LogLevel;
+	message: string;
+	context?: Record<string, unknown>;
+}
+
+/**
+ * Mask sensitive values in environment variables
+ */
+function maskEnvironment(): Record<string, string> {
+	const masked: Record<string, string> = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (!value) continue;
+
+		// Check if this env var matches sensitive patterns
+		const isSensitive = SENSITIVE_ENV_PATTERNS.some((pattern) => pattern.test(key));
+
+		if (isSensitive) {
+			// Show only first and last 4 chars for keys/tokens, or just mask completely
+			if (value.length > 12) {
+				masked[key] = `${value.slice(0, 4)}...${value.slice(-4)}`;
+			} else {
+				masked[key] = '***MASKED***';
+			}
+		} else {
+			masked[key] = value;
+		}
+	}
+	return masked;
+}
+
+/**
+ * Get the logs directory path
+ */
+function getLogsDir(): string {
+	return join(homedir(), '.config', 'agentuity', 'logs');
+}
+
+/**
+ * Clean up old log directories, keeping only the most recent one
+ */
+function cleanupOldLogs(currentSessionId: string): void {
+	const logsDir = getLogsDir();
+	if (!existsSync(logsDir)) {
+		return;
+	}
+
+	try {
+		const entries = readdirSync(logsDir, { withFileTypes: true });
+		const dirs = entries
+			.filter((e) => e.isDirectory())
+			.map((e) => e.name)
+			.filter((name) => name !== currentSessionId);
+
+		// Remove all directories except the current one
+		for (const dir of dirs) {
+			const dirPath = join(logsDir, dir);
+			try {
+				rmSync(dirPath, { recursive: true, force: true });
+			} catch (err) {
+				// Ignore errors during cleanup
+				console.debug(`Failed to remove old log directory ${dir}: ${err}`);
+			}
+		}
+	} catch (err) {
+		// Ignore errors during cleanup
+		console.debug(`Failed to cleanup old logs: ${err}`);
+	}
+}
+
+/**
+ * Internal logger for capturing all CLI command execution details
+ */
+export class InternalLogger implements Logger {
+	private sessionId: string;
+	private sessionDir: string;
+	private sessionFile: string;
+	private logsFile: string;
+	private initialized = false;
+	private disabled = false;
+
+	constructor(
+		private cliVersion: string,
+		private cliName: string
+	) {
+		this.sessionId = randomUUID();
+		this.sessionDir = join(getLogsDir(), this.sessionId);
+		this.sessionFile = join(this.sessionDir, 'session.json');
+		this.logsFile = join(this.sessionDir, 'logs.jsonl');
+	}
+
+	/**
+	 * Initialize the internal logger with command metadata
+	 * @param command - The command being executed
+	 * @param args - Command line arguments
+	 * @param userId - Optional user ID (set later via setUserId if not provided)
+	 * @param projectDir - Optional project directory from --dir flag (defaults to process.cwd())
+	 */
+	init(command: string, args: string[], userId?: string, projectDir?: string): void {
+		if (this.disabled) return;
+
+		try {
+			// Create logs directory
+			mkdirSync(this.sessionDir, { recursive: true, mode: 0o700 });
+
+			// Clean up old logs (keep only this session)
+			cleanupOldLogs(this.sessionId);
+
+			// Determine project directory: use provided projectDir, or fall back to cwd
+			let workingDir = projectDir || process.cwd();
+
+			// Handle home directory expansion (~/path -> /home/user/path)
+			if (workingDir.startsWith('~/')) {
+				workingDir = join(homedir(), workingDir.slice(2));
+			}
+
+			// Resolve to absolute path
+			workingDir = resolve(workingDir);
+
+			// Check for agentuity.json in the determined directory
+			let projectId: string | undefined;
+			let orgId: string | undefined;
+
+			try {
+				const agentuityJsonPath = join(workingDir, 'agentuity.json');
+				if (existsSync(agentuityJsonPath)) {
+					const agentuityJson = JSON.parse(readFileSync(agentuityJsonPath, 'utf-8'));
+					projectId = agentuityJson.projectId;
+					orgId = agentuityJson.orgId;
+				}
+			} catch {
+				// Ignore errors reading agentuity.json
+			}
+
+			// Use workingDir as cwd in session metadata
+			const cwd = workingDir;
+
+			// Gather session metadata
+			const sessionMetadata: SessionMetadata = {
+				sessionId: this.sessionId,
+				command,
+				args,
+				timestamp: new Date().toISOString(),
+				cli: {
+					version: this.cliVersion,
+					name: this.cliName,
+				},
+				system: {
+					platform: platform(),
+					arch: arch(),
+					cpus: cpus().length,
+					memory: totalmem(),
+					bunPath: process.execPath || '',
+					bunVersion: Bun.version || process.version,
+				},
+				environment: maskEnvironment(),
+				cwd,
+				...(userId && { userId }),
+				...(projectId && { projectId }),
+				...(orgId && { orgId }),
+			};
+
+			// Write session metadata
+			writeFileSync(this.sessionFile, JSON.stringify(sessionMetadata, null, 2));
+			this.initialized = true;
+		} catch (err) {
+			// If we fail to initialize, disable the logger
+			console.debug(`Failed to initialize internal logger: ${err}`);
+			this.disabled = true;
+		}
+	}
+
+	/**
+	 * Write a log entry to the logs file
+	 */
+	private writeLog(level: LogLevel, message: unknown, args: unknown[]): void {
+		if (!this.initialized || this.disabled) return;
+
+		try {
+			// Format the message
+			let formattedMessage: string;
+			if (typeof message === 'string') {
+				// Simple sprintf-style formatting for %s and %d
+				formattedMessage = message;
+				let argIndex = 0;
+				formattedMessage = formattedMessage.replace(/%[sd]/g, () => {
+					if (argIndex < args.length) {
+						return String(args[argIndex++]);
+					}
+					return '';
+				});
+				// Append any remaining args
+				if (argIndex < args.length) {
+					formattedMessage += ' ' + args.slice(argIndex).map(String).join(' ');
+				}
+			} else {
+				formattedMessage = [message, ...args].map(String).join(' ');
+			}
+
+			// Strip ANSI color codes since this is going to JSON
+			if (typeof Bun !== 'undefined' && typeof Bun.stripANSI === 'function') {
+				formattedMessage = Bun.stripANSI(formattedMessage);
+			}
+
+			// Extract context from args (look for objects)
+			const context: Record<string, unknown> = {};
+			for (const arg of args) {
+				if (arg && typeof arg === 'object' && !Array.isArray(arg)) {
+					Object.assign(context, arg);
+				}
+			}
+
+			const entry: LogEntry = {
+				timestamp: new Date().toISOString(),
+				level,
+				message: formattedMessage,
+				...(Object.keys(context).length > 0 && { context }),
+			};
+
+			appendFileSync(this.logsFile, JSON.stringify(entry) + '\n');
+		} catch (err) {
+			// If write fails, disable the logger to prevent repeated errors
+			console.debug(`Failed to write log entry: ${err}`);
+			this.disabled = true;
+		}
+	}
+
+	trace(message: unknown, ...args: unknown[]): void {
+		this.writeLog('trace', message, args);
+	}
+
+	debug(message: unknown, ...args: unknown[]): void {
+		this.writeLog('debug', message, args);
+	}
+
+	info(message: unknown, ...args: unknown[]): void {
+		this.writeLog('info', message, args);
+	}
+
+	warn(message: unknown, ...args: unknown[]): void {
+		this.writeLog('warn', message, args);
+	}
+
+	error(message: unknown, ...args: unknown[]): void {
+		this.writeLog('error', message, args);
+	}
+
+	fatal(message: unknown, ...args: unknown[]): never {
+		this.writeLog('error', message, args);
+		process.exit(1);
+	}
+
+	child(_opts: Record<string, unknown>): Logger {
+		// Return the same logger - we don't need separate child loggers for internal logging
+		return this;
+	}
+
+	/**
+	 * Get the session ID for this logger
+	 */
+	getSessionId(): string {
+		return this.sessionId;
+	}
+
+	/**
+	 * Get the session directory path
+	 */
+	getSessionDir(): string {
+		return this.sessionDir;
+	}
+
+	/**
+	 * Check if the logger is disabled
+	 */
+	isDisabled(): boolean {
+		return this.disabled;
+	}
+
+	/**
+	 * Update the session with user ID after authentication
+	 */
+	setUserId(userId: string): void {
+		if (!this.initialized || this.disabled) return;
+
+		try {
+			// Read existing session data
+			const existingData = JSON.parse(readFileSync(this.sessionFile, 'utf-8'));
+			existingData.userId = userId;
+			// Write updated session data
+			writeFileSync(this.sessionFile, JSON.stringify(existingData, null, 2));
+		} catch (err) {
+			// Ignore errors - this is a best-effort update
+			console.debug(`Failed to update userId in session: ${err}`);
+		}
+	}
+
+	/**
+	 * Disable the internal logger (prevents init and logging)
+	 */
+	disable(): void {
+		this.disabled = true;
+	}
+}
+
+/**
+ * Create a new internal logger instance
+ */
+export function createInternalLogger(cliVersion: string, cliName: string): InternalLogger {
+	return new InternalLogger(cliVersion, cliName);
+}
+
+/**
+ * Get the latest log session directory (if any)
+ */
+export function getLatestLogSession(): string | null {
+	const logsDir = getLogsDir();
+	if (!existsSync(logsDir)) {
+		return null;
+	}
+
+	try {
+		const entries = readdirSync(logsDir, { withFileTypes: true });
+		const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+
+		if (dirs.length === 0) {
+			return null;
+		}
+
+		// Return the first directory (should be the only one due to cleanup)
+		return join(logsDir, dirs[0]);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get the logs directory path (exported for external use)
+ */
+export function getLogsDirPath(): string {
+	return getLogsDir();
+}

package/src/types.ts

@@ -457,6 +457,7 @@ export function createSubcommand<
 	banner?: true;
 	aliases?: string[];
 	toplevel?: boolean;
+	skipInternalLogging?: boolean;
 	requires?: R;
 	optional?: O;
 	examples?: CommandExample[];
@@ -503,6 +504,7 @@ export function createCommand<
 	executable?: boolean;
 	skipUpgradeCheck?: boolean;
 	passThroughArgs?: boolean;
+	skipInternalLogging?: boolean;
 	requires?: R;
 	optional?: O;
 	examples?: CommandExample[];
@@ -545,6 +547,7 @@ type CommandDefBase =
 			skipUpgradeCheck?: boolean;
 			passThroughArgs?: boolean;
 			skipSkill?: boolean;
+			skipInternalLogging?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];
@@ -564,6 +567,7 @@ type CommandDefBase =
 			skipUpgradeCheck?: boolean;
 			passThroughArgs?: boolean;
 			skipSkill?: boolean;
+			skipInternalLogging?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];
@@ -583,6 +587,7 @@ type SubcommandDefBase =
 			toplevel?: boolean;
 			banner?: boolean;
 			skipSkill?: boolean;
+			skipInternalLogging?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];
@@ -600,6 +605,7 @@ type SubcommandDefBase =
 			toplevel?: boolean;
 			banner?: boolean;
 			skipSkill?: boolean;
+			skipInternalLogging?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];

package/src/utils/installation-type.ts

@@ -2,10 +2,26 @@
  * Detects how the CLI was installed and is being run
  */
 
+import fs from 'node:fs';
 import os from 'node:os';
 
 export type InstallationType = 'global' | 'local' | 'source';
 
+/**
+ * Resolve a path to its real path (following symlinks) and normalize to POSIX separators.
+ * Returns the original path if resolution fails.
+ */
+function resolveRealPath(path: string): string {
+	if (!path) return '';
+	try {
+		// fs.realpathSync resolves symlinks (e.g., /tmp -> /private/tmp on macOS)
+		return fs.realpathSync(path).replace(/\\/g, '/');
+	} catch {
+		// If the path doesn't exist or can't be resolved, return normalized original
+		return path.replace(/\\/g, '/');
+	}
+}
+
 /**
  * Determines the installation type based on how the CLI is being executed
  *
@@ -14,34 +30,57 @@ export type InstallationType = 'global' | 'local' | 'source';
  * @returns 'source' - Running from source code (development)
  */
 export function getInstallationType(): InstallationType {
-	// Normalize paths to POSIX separators for cross-platform compatibility
+	// Bun.main already returns the resolved real path, just normalize separators
 	const mainPath = Bun.main.replace(/\\/g, '/');
-	// Bun.argv[1] contains the original invocation path (before symlink resolution)
-	const invokedPath = (Bun.argv[1] ?? '').replace(/\\/g, '/');
 
-	// Get bun's global bin directory from BUN_INSTALL or default to ~/.bun/bin
-	// Use os.homedir() as primary fallback to avoid "undefined/.bun" paths
-	const home = os.homedir() ?? process.env.HOME ?? process.env.USERPROFILE ?? '';
-	const bunInstall = (process.env.BUN_INSTALL ?? (home ? `${home}/.bun` : '')).replace(/\\/g, '/');
-	const globalBinDir = bunInstall ? `${bunInstall}/bin/` : '';
+	// Get home directory reliably and resolve symlinks
+	// On macOS, os.homedir() returns /Users/xxx which is already real
+	const home = resolveRealPath(os.homedir() ?? process.env.HOME ?? process.env.USERPROFILE ?? '');
 
-	// Global install: invoked from bun's global bin directory (e.g., ~/.bun/bin/agentuity)
-	// This handles symlinks created by `bun add -g @agentuity/cli`
-	if (globalBinDir && invokedPath.startsWith(globalBinDir)) {
-		return 'global';
+	// Get bun install directory from BUN_INSTALL or default to ~/.bun
+	// Resolve symlinks to handle cases like BUN_INSTALL=/tmp/... on macOS where /tmp -> /private/tmp
+	const bunInstallRaw = process.env.BUN_INSTALL ?? (home ? `${home}/.bun` : '');
+	const bunInstall = resolveRealPath(bunInstallRaw);
+
+	// GLOBAL DETECTION: Check if running from bun's global install location
+	// When installed via `bun add -g`, the CLI lives at ~/.bun/node_modules/@agentuity/cli/
+	// or ~/.bun/install/global/node_modules/@agentuity/cli/
+	if (bunInstall) {
+		// Check for ~/.bun/node_modules/@agentuity/cli/ (common bun global layout)
+		if (mainPath.startsWith(`${bunInstall}/node_modules/@agentuity/cli/`)) {
+			return 'global';
+		}
+		// Check for ~/.bun/install/global/node_modules/@agentuity/cli/ (alternative layout)
+		if (mainPath.startsWith(`${bunInstall}/install/global/`)) {
+			return 'global';
+		}
+	}
+
+	// GLOBAL DETECTION: Check for legacy ~/.agentuity/ installation
+	// The install.sh script may install to ~/.agentuity/node_modules/@agentuity/cli/
+	// or create a shim at ~/.agentuity/bin/agentuity
+	if (home) {
+		const agentuityDir = resolveRealPath(`${home}/.agentuity`);
+		if (mainPath.startsWith(`${agentuityDir}/`)) {
+			return 'global';
+		}
 	}
 
-	// Also check the resolved path for explicit global install locations
-	if (mainPath.includes('/.bun/install/global/')) {
+	// GLOBAL DETECTION: Fallback check for any path containing /.bun/ before node_modules
+	// This catches edge cases where BUN_INSTALL might not match the actual path
+	if (mainPath.includes('/.bun/') && mainPath.includes('/node_modules/@agentuity/cli/')) {
 		return 'global';
 	}
 
-	// Local project install: ./node_modules/@agentuity/cli/...
+	// LOCAL DETECTION: Running from a project's node_modules
+	// This is when someone runs `bunx agentuity` or has it as a project dependency
+	// At this point, we've ruled out global installs, so any node_modules path is local
 	if (mainPath.includes('/node_modules/@agentuity/cli/')) {
 		return 'local';
 	}
 
-	// Source/development: packages/cli/bin/cli.ts or similar
+	// SOURCE DETECTION: Running from source code (development)
+	// This is when running directly from the monorepo: packages/cli/bin/cli.ts
 	return 'source';
 }
 

package/dist/cmd/ai/skills/generate.d.ts

@@ -1,3 +0,0 @@
-export declare const generateSubcommand: import("../../..").SubcommandDefinition;
-export default generateSubcommand;
-//# sourceMappingURL=generate.d.ts.map

package/dist/cmd/ai/skills/generate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/skills/generate.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,kBAAkB,yCA0D7B,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/dist/cmd/ai/skills/generate.js

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
-import * as tui from '../../../tui';
-import * as path from 'node:path';
-import { generateSkills, collectSkillsForPreview } from './generator';
-const OptionsSchema = z.object({
-    output: z.string().describe('Output directory for generated skills'),
-    includeHidden: z.boolean().default(false).describe('Include hidden commands'),
-});
-export const generateSubcommand = createSubcommand({
-    name: 'generate',
-    description: 'Generate Agent Skills from CLI schema',
-    tags: ['fast'],
-    idempotent: true,
-    examples: [
-        {
-            command: getCommand('ai skills generate --output ./skills'),
-            description: 'Generate skills to a directory',
-        },
-        {
-            command: getCommand('--dry-run ai skills generate --output ./skills'),
-            description: 'Preview without writing files',
-        },
-        {
-            command: getCommand('ai skills generate --output ./skills --include-hidden'),
-            description: 'Include hidden commands',
-        },
-    ],
-    schema: {
-        options: OptionsSchema,
-    },
-    async handler(ctx) {
-        const { logger, opts, options } = ctx;
-        const { output, includeHidden } = opts;
-        const dryRun = options.dryRun === true;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const schema = global.__CLI_SCHEMA__;
-        if (!schema) {
-            return logger.fatal('Schema not available. This is a CLI bug.', ErrorCode.INTERNAL_ERROR);
-        }
-        const baseDir = path.join(output, 'skills', 'agentuity', 'cli');
-        if (dryRun) {
-            const skills = collectSkillsForPreview(schema, output, includeHidden);
-            if (skills.length === 0) {
-                logger.warn('No skills to generate');
-                return;
-            }
-            tui.info(`Would generate ${skills.length} skills:`);
-            for (const skillPath of skills) {
-                console.log(tui.muted(`  ${skillPath}`));
-            }
-            return;
-        }
-        const created = await generateSkills(schema, output, includeHidden);
-        if (created === 0) {
-            logger.warn('No skills to generate');
-            return;
-        }
-        tui.success(`Generated ${created} skills to ${baseDir}`);
-    },
-});
-export default generateSubcommand;
-//# sourceMappingURL=generate.js.map

package/dist/cmd/ai/skills/generate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.js","sourceRoot":"","sources":["../../../../src/cmd/ai/skills/generate.ts"],"names":[],"mappings":"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"}

package/dist/cmd/ai/skills/generator.d.ts

@@ -1,4 +0,0 @@
-import type { CLISchema } from '../../../schema-generator';
-export declare function collectSkillsForPreview(schema: CLISchema, outputDir: string, includeHidden: boolean): string[];
-export declare function generateSkills(schema: CLISchema, outputDir: string, includeHidden: boolean): Promise<number>;
-//# sourceMappingURL=generator.d.ts.map

package/dist/cmd/ai/skills/generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../../src/cmd/ai/skills/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,SAAS,EAIT,MAAM,2BAA2B,CAAC;AAienC,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,OAAO,GACpB,MAAM,EAAE,CAGV;AAED,wBAAsB,cAAc,CACnC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,CAAC,CA2BjB"}