@townco/core 0.0.3 → 0.0.5

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./logger.js";

package/dist/logger.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Browser-compatible logger
+ * Outputs structured JSON logs to console with color-coding
+ * Also captures logs to a global store for in-app viewing
+ * In Node.js environment with logsDir option, also writes to .logs/ directory
+ */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export interface LogEntry {
+    id: string;
+    timestamp: string;
+    level: LogLevel;
+    service: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Get all captured logs
+ */
+export declare function getCapturedLogs(): LogEntry[];
+/**
+ * Clear all captured logs
+ */
+export declare function clearCapturedLogs(): void;
+/**
+ * Subscribe to log updates
+ */
+type LogSubscriber = (entry: LogEntry) => void;
+export declare function subscribeToLogs(callback: LogSubscriber): () => void;
+/**
+ * Configure global logs directory for file writing
+ * Must be called before creating any loggers (typically at TUI startup)
+ */
+export declare function configureLogsDir(logsDir: string): void;
+export declare class Logger {
+    private service;
+    private minLevel;
+    private logFilePath?;
+    private logsDir?;
+    private writeQueue;
+    private isWriting;
+    constructor(service: string, minLevel?: LogLevel);
+    private setupFileLogging;
+    private writeToFile;
+    private shouldLog;
+    private log;
+    trace(message: string, metadata?: Record<string, unknown>): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    fatal(message: string, metadata?: Record<string, unknown>): void;
+}
+/**
+ * Create a logger instance for a service
+ * @param service - Service name (e.g., "gui", "http-agent", "tui")
+ * @param minLevel - Minimum log level to display (default: "debug")
+ */
+export declare function createLogger(service: string, minLevel?: LogLevel): Logger;
+export {};

package/dist/logger.js

@@ -0,0 +1,191 @@
+/**
+ * Browser-compatible logger
+ * Outputs structured JSON logs to console with color-coding
+ * Also captures logs to a global store for in-app viewing
+ * In Node.js environment with logsDir option, also writes to .logs/ directory
+ */
+// Check if running in Node.js
+const isNode = typeof process !== "undefined" && process.versions?.node;
+// Global logs directory configuration (set once at app startup for TUI)
+let globalLogsDir;
+// Global log store
+const globalLogStore = [];
+let logIdCounter = 0;
+/**
+ * Get all captured logs
+ */
+export function getCapturedLogs() {
+    return [...globalLogStore];
+}
+/**
+ * Clear all captured logs
+ */
+export function clearCapturedLogs() {
+    globalLogStore.length = 0;
+}
+const logSubscribers = new Set();
+export function subscribeToLogs(callback) {
+    logSubscribers.add(callback);
+    return () => logSubscribers.delete(callback);
+}
+function notifyLogSubscribers(entry) {
+    for (const callback of logSubscribers) {
+        callback(entry);
+    }
+}
+/**
+ * Configure global logs directory for file writing
+ * Must be called before creating any loggers (typically at TUI startup)
+ */
+export function configureLogsDir(logsDir) {
+    globalLogsDir = logsDir;
+}
+const LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    fatal: 5,
+};
+const _LOG_COLORS = {
+    trace: "#6B7280", // gray
+    debug: "#3B82F6", // blue
+    info: "#10B981", // green
+    warn: "#F59E0B", // orange
+    error: "#EF4444", // red
+    fatal: "#DC2626", // dark red
+};
+const _LOG_STYLES = {
+    trace: "color: #6B7280",
+    debug: "color: #3B82F6; font-weight: bold",
+    info: "color: #10B981; font-weight: bold",
+    warn: "color: #F59E0B; font-weight: bold",
+    error: "color: #EF4444; font-weight: bold",
+    fatal: "color: #DC2626; font-weight: bold; background: #FEE2E2",
+};
+export class Logger {
+    service;
+    minLevel;
+    logFilePath;
+    logsDir;
+    writeQueue = [];
+    isWriting = false;
+    constructor(service, minLevel = "debug") {
+        this.service = service;
+        this.minLevel = minLevel;
+        // In production, suppress trace and debug logs
+        if (typeof process !== "undefined" &&
+            process.env?.NODE_ENV === "production") {
+            this.minLevel = "info";
+        }
+        // Note: File logging setup is done lazily in log() method
+        // This allows loggers created before configureLogsDir() to still write to files
+    }
+    setupFileLogging() {
+        if (!isNode || !globalLogsDir)
+            return;
+        try {
+            // Dynamic import for Node.js modules
+            const path = require("node:path");
+            const fs = require("node:fs");
+            this.logsDir = globalLogsDir;
+            this.logFilePath = path.join(this.logsDir, `${this.service}.log`);
+            // Create logs directory if it doesn't exist
+            if (!fs.existsSync(this.logsDir)) {
+                fs.mkdirSync(this.logsDir, { recursive: true });
+            }
+        }
+        catch (_error) {
+            // Silently fail if we can't set up file logging
+        }
+    }
+    async writeToFile(content) {
+        if (!this.logFilePath || !isNode)
+            return;
+        this.writeQueue.push(content);
+        if (this.isWriting) {
+            return;
+        }
+        this.isWriting = true;
+        while (this.writeQueue.length > 0) {
+            const batch = this.writeQueue.splice(0, this.writeQueue.length);
+            const data = `${batch.join("\n")}\n`;
+            try {
+                // Dynamic import for Node.js modules
+                const fs = require("node:fs");
+                await fs.promises.appendFile(this.logFilePath, data, "utf-8");
+            }
+            catch (_error) {
+                // Silently fail
+            }
+        }
+        this.isWriting = false;
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
+    }
+    log(level, message, metadata) {
+        if (!this.shouldLog(level)) {
+            return;
+        }
+        const entry = {
+            id: `log_${++logIdCounter}`,
+            timestamp: new Date().toISOString(),
+            level,
+            service: this.service,
+            message,
+            ...(metadata && { metadata }),
+        };
+        // Store in global log store
+        globalLogStore.push(entry);
+        // Notify subscribers
+        notifyLogSubscribers(entry);
+        // Write to file in Node.js (for logs tab to read)
+        // Lazily set up file logging if globalLogsDir was configured after this logger was created
+        if (isNode && !this.logFilePath && globalLogsDir) {
+            this.setupFileLogging();
+        }
+        if (isNode && this.logFilePath) {
+            // Write as JSON without the id field (to match expected format)
+            const fileEntry = {
+                timestamp: entry.timestamp,
+                level: entry.level,
+                service: entry.service,
+                message: entry.message,
+                ...(entry.metadata && { metadata: entry.metadata }),
+            };
+            this.writeToFile(JSON.stringify(fileEntry)).catch(() => {
+                // Silently fail
+            });
+        }
+        // No console output - logs are only captured and displayed in UI
+        // This prevents logs from polluting stdout/stderr in TUI mode
+    }
+    trace(message, metadata) {
+        this.log("trace", message, metadata);
+    }
+    debug(message, metadata) {
+        this.log("debug", message, metadata);
+    }
+    info(message, metadata) {
+        this.log("info", message, metadata);
+    }
+    warn(message, metadata) {
+        this.log("warn", message, metadata);
+    }
+    error(message, metadata) {
+        this.log("error", message, metadata);
+    }
+    fatal(message, metadata) {
+        this.log("fatal", message, metadata);
+    }
+}
+/**
+ * Create a logger instance for a service
+ * @param service - Service name (e.g., "gui", "http-agent", "tui")
+ * @param minLevel - Minimum log level to display (default: "debug")
+ */
+export function createLogger(service, minLevel = "debug") {
+    return new Logger(service, minLevel);
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@townco/core",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "core",
   "license": "UNLICENSED",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "repository": "github:townco/town",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -15,7 +18,7 @@
   },
   "devDependencies": {
     "typescript": "^5.9.3",
-    "@townco/tsconfig": "0.1.22"
+    "@townco/tsconfig": "0.1.24"
   },
   "scripts": {
     "build": "tsc",

package/src/logger.ts

@@ -1,253 +0,0 @@
-/**
- * Browser-compatible logger
- * Outputs structured JSON logs to console with color-coding
- * Also captures logs to a global store for in-app viewing
- * In Node.js environment with logsDir option, also writes to .logs/ directory
- */
-
-export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
-
-// Check if running in Node.js
-const isNode = typeof process !== "undefined" && process.versions?.node;
-
-// Global logs directory configuration (set once at app startup for TUI)
-let globalLogsDir: string | undefined;
-
-export interface LogEntry {
-  id: string;
-  timestamp: string;
-  level: LogLevel;
-  service: string;
-  message: string;
-  metadata?: Record<string, unknown>;
-}
-
-// Global log store
-const globalLogStore: LogEntry[] = [];
-let logIdCounter = 0;
-
-/**
- * Get all captured logs
- */
-export function getCapturedLogs(): LogEntry[] {
-  return [...globalLogStore];
-}
-
-/**
- * Clear all captured logs
- */
-export function clearCapturedLogs(): void {
-  globalLogStore.length = 0;
-}
-
-/**
- * Subscribe to log updates
- */
-type LogSubscriber = (entry: LogEntry) => void;
-const logSubscribers: Set<LogSubscriber> = new Set();
-
-export function subscribeToLogs(callback: LogSubscriber): () => void {
-  logSubscribers.add(callback);
-  return () => logSubscribers.delete(callback);
-}
-
-function notifyLogSubscribers(entry: LogEntry): void {
-  for (const callback of logSubscribers) {
-    callback(entry);
-  }
-}
-
-/**
- * Configure global logs directory for file writing
- * Must be called before creating any loggers (typically at TUI startup)
- */
-export function configureLogsDir(logsDir: string): void {
-  globalLogsDir = logsDir;
-}
-
-const LOG_LEVELS: Record<LogLevel, number> = {
-  trace: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-  fatal: 5,
-};
-
-const _LOG_COLORS: Record<LogLevel, string> = {
-  trace: "#6B7280", // gray
-  debug: "#3B82F6", // blue
-  info: "#10B981", // green
-  warn: "#F59E0B", // orange
-  error: "#EF4444", // red
-  fatal: "#DC2626", // dark red
-};
-
-const _LOG_STYLES: Record<LogLevel, string> = {
-  trace: "color: #6B7280",
-  debug: "color: #3B82F6; font-weight: bold",
-  info: "color: #10B981; font-weight: bold",
-  warn: "color: #F59E0B; font-weight: bold",
-  error: "color: #EF4444; font-weight: bold",
-  fatal: "color: #DC2626; font-weight: bold; background: #FEE2E2",
-};
-
-export class Logger {
-  private service: string;
-  private minLevel: LogLevel;
-  private logFilePath?: string;
-  private logsDir?: string;
-  private writeQueue: string[] = [];
-  private isWriting = false;
-
-  constructor(service: string, minLevel: LogLevel = "debug") {
-    this.service = service;
-    this.minLevel = minLevel;
-
-    // In production, suppress trace and debug logs
-    if (
-      typeof process !== "undefined" &&
-      process.env?.NODE_ENV === "production"
-    ) {
-      this.minLevel = "info";
-    }
-
-    // Note: File logging setup is done lazily in log() method
-    // This allows loggers created before configureLogsDir() to still write to files
-  }
-
-  private setupFileLogging(): void {
-    if (!isNode || !globalLogsDir) return;
-
-    try {
-      // Dynamic import for Node.js modules
-      const path = require("node:path");
-      const fs = require("node:fs");
-
-      this.logsDir = globalLogsDir;
-      this.logFilePath = path.join(this.logsDir, `${this.service}.log`);
-
-      // Create logs directory if it doesn't exist
-      if (!fs.existsSync(this.logsDir)) {
-        fs.mkdirSync(this.logsDir, { recursive: true });
-      }
-    } catch (_error) {
-      // Silently fail if we can't set up file logging
-    }
-  }
-
-  private async writeToFile(content: string): Promise<void> {
-    if (!this.logFilePath || !isNode) return;
-
-    this.writeQueue.push(content);
-
-    if (this.isWriting) {
-      return;
-    }
-
-    this.isWriting = true;
-
-    while (this.writeQueue.length > 0) {
-      const batch = this.writeQueue.splice(0, this.writeQueue.length);
-      const data = `${batch.join("\n")}\n`;
-
-      try {
-        // Dynamic import for Node.js modules
-        const fs = require("node:fs");
-        await fs.promises.appendFile(this.logFilePath, data, "utf-8");
-      } catch (_error) {
-        // Silently fail
-      }
-    }
-
-    this.isWriting = false;
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return LOG_LEVELS[level] >= LOG_LEVELS[this.minLevel];
-  }
-
-  private log(
-    level: LogLevel,
-    message: string,
-    metadata?: Record<string, unknown>,
-  ): void {
-    if (!this.shouldLog(level)) {
-      return;
-    }
-
-    const entry: LogEntry = {
-      id: `log_${++logIdCounter}`,
-      timestamp: new Date().toISOString(),
-      level,
-      service: this.service,
-      message,
-      ...(metadata && { metadata }),
-    };
-
-    // Store in global log store
-    globalLogStore.push(entry);
-
-    // Notify subscribers
-    notifyLogSubscribers(entry);
-
-    // Write to file in Node.js (for logs tab to read)
-    // Lazily set up file logging if globalLogsDir was configured after this logger was created
-    if (isNode && !this.logFilePath && globalLogsDir) {
-      this.setupFileLogging();
-    }
-
-    if (isNode && this.logFilePath) {
-      // Write as JSON without the id field (to match expected format)
-      const fileEntry = {
-        timestamp: entry.timestamp,
-        level: entry.level,
-        service: entry.service,
-        message: entry.message,
-        ...(entry.metadata && { metadata: entry.metadata }),
-      };
-      this.writeToFile(JSON.stringify(fileEntry)).catch(() => {
-        // Silently fail
-      });
-    }
-
-    // No console output - logs are only captured and displayed in UI
-    // This prevents logs from polluting stdout/stderr in TUI mode
-  }
-
-  trace(message: string, metadata?: Record<string, unknown>): void {
-    this.log("trace", message, metadata);
-  }
-
-  debug(message: string, metadata?: Record<string, unknown>): void {
-    this.log("debug", message, metadata);
-  }
-
-  info(message: string, metadata?: Record<string, unknown>): void {
-    this.log("info", message, metadata);
-  }
-
-  warn(message: string, metadata?: Record<string, unknown>): void {
-    this.log("warn", message, metadata);
-  }
-
-  error(message: string, metadata?: Record<string, unknown>): void {
-    this.log("error", message, metadata);
-  }
-
-  fatal(message: string, metadata?: Record<string, unknown>): void {
-    this.log("fatal", message, metadata);
-  }
-}
-
-/**
- * Create a logger instance for a service
- * @param service - Service name (e.g., "gui", "http-agent", "tui")
- * @param minLevel - Minimum log level to display (default: "debug")
- */
-export function createLogger(
-  service: string,
-  minLevel: LogLevel = "debug",
-): Logger {
-  return new Logger(service, minLevel);
-}

package/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "@townco/tsconfig",
-  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", ".sst"]
-}