@telora/daemon 0.12.33

package/dist/daemon-logs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Daemon log viewing utilities.
+ *
+ * Provides tail-like functionality for the daemon log file,
+ * including follow mode (like `tail -f`).
+ */
+/**
+ * Print the last N lines from a file.
+ */
+export declare function tailFile(filePath: string, lines: number): Promise<void>;
+/**
+ * Follow a log file, printing new lines as they appear.
+ * Returns a cleanup function that stops the follow.
+ *
+ * Uses fs.watchFile for polling-based watching (works across
+ * all platforms and with log rotation).
+ */
+export declare function followFile(filePath: string): () => void;
+//# sourceMappingURL=daemon-logs.d.ts.map

package/dist/daemon-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-logs.d.ts","sourceRoot":"","sources":["../src/daemon-logs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;GAEG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB7E;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,IAAI,CAkDvD"}

package/dist/daemon-logs.js

@@ -0,0 +1,81 @@
+/**
+ * Daemon log viewing utilities.
+ *
+ * Provides tail-like functionality for the daemon log file,
+ * including follow mode (like `tail -f`).
+ */
+import { createReadStream, existsSync, statSync, watchFile, unwatchFile } from 'node:fs';
+import { createInterface } from 'node:readline';
+/**
+ * Print the last N lines from a file.
+ */
+export async function tailFile(filePath, lines) {
+    if (!existsSync(filePath)) {
+        console.error(`Log file not found: ${filePath}`);
+        return;
+    }
+    // Read the entire file and print the last N lines
+    const allLines = [];
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: 'utf-8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        allLines.push(line);
+    }
+    const startIdx = Math.max(0, allLines.length - lines);
+    for (let i = startIdx; i < allLines.length; i++) {
+        console.log(allLines[i]);
+    }
+}
+/**
+ * Follow a log file, printing new lines as they appear.
+ * Returns a cleanup function that stops the follow.
+ *
+ * Uses fs.watchFile for polling-based watching (works across
+ * all platforms and with log rotation).
+ */
+export function followFile(filePath) {
+    if (!existsSync(filePath)) {
+        console.error(`Log file not found: ${filePath}`);
+        console.error('Start the daemon first, then run logs --follow');
+        process.exit(1);
+    }
+    let position = statSync(filePath).size;
+    let stopped = false;
+    const pollIntervalMs = 500;
+    watchFile(filePath, { interval: pollIntervalMs }, () => {
+        if (stopped)
+            return;
+        try {
+            const currentSize = statSync(filePath).size;
+            if (currentSize < position) {
+                // File was truncated or rotated -- start from beginning
+                position = 0;
+            }
+            if (currentSize > position) {
+                const stream = createReadStream(filePath, {
+                    start: position,
+                    encoding: 'utf-8',
+                });
+                stream.on('data', (chunk) => {
+                    process.stdout.write(chunk);
+                });
+                stream.on('end', () => {
+                    position = currentSize;
+                });
+                stream.on('error', (err) => {
+                    console.error(`Error reading log file: ${err.message}`);
+                });
+            }
+        }
+        catch {
+            // File may have been deleted during rotation
+        }
+    });
+    return () => {
+        stopped = true;
+        unwatchFile(filePath);
+    };
+}
+//# sourceMappingURL=daemon-logs.js.map

package/dist/daemon-logs.js.map

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

package/dist/daemon-process.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Daemon process management utilities for CLI commands.
+ *
+ * Provides helpers for:
+ * - Reading PID files and checking daemon liveness
+ * - Sending signals (stop, status)
+ * - Spawning the daemon as a background process
+ * - Auto-rebuilding TypeScript before starting
+ */
+/**
+ * Resolve the global daemon state directory (~/.telora/).
+ *
+ * Process-level state (PID lock, metadata, canonical log) lives here
+ * because the daemon is a user-scoped singleton -- one process per user,
+ * potentially managing multiple product repositories.
+ *
+ * Per-product state (worktrees, session logs) remains in each repo's
+ * .telora/ directory, configured via configForProduct().
+ *
+ * Override with TELORA_STATE_DIR for testing.
+ */
+export declare function resolveGlobalStateDir(): string;
+/**
+ * Ensure the global state directory (~/.telora/) exists.
+ * Called during daemon startup.
+ */
+export declare function ensureGlobalStateDir(): void;
+/**
+ * Resolve the PID file path in the global state directory (~/.telora/).
+ */
+export declare function resolvePidFilePath(): string;
+/**
+ * Read the PID from the daemon PID file.
+ * Returns null if the file doesn't exist or contains invalid data.
+ */
+export declare function readDaemonPid(pidFilePath: string): number | null;
+export interface DaemonStatus {
+    running: boolean;
+    pid: number | null;
+    pidFilePath: string;
+    logPath: string | null;
+    startedAt: string | null;
+}
+/**
+ * Metadata written alongside the PID file for daemon discoverability.
+ */
+export interface DaemonMeta {
+    pid: number;
+    logPath: string;
+    startedAt: string;
+}
+/**
+ * Check if the daemon is currently running.
+ */
+export declare function getDaemonStatus(): DaemonStatus;
+/**
+ * Send SIGTERM to the running daemon and wait for it to exit.
+ * Returns true if the daemon was stopped, false if it wasn't running.
+ * Throws if the daemon doesn't exit within the timeout.
+ */
+export declare function stopDaemon(timeoutMs?: number): Promise<boolean>;
+/**
+ * Check if dist/ is stale relative to src/ files.
+ * Returns true if any src/ file is newer than the newest dist/ file,
+ * or if dist/ doesn't exist.
+ */
+export declare function needsRebuild(): boolean;
+/**
+ * Rebuild the daemon TypeScript project.
+ * Runs `npm run build` in the daemon package directory.
+ */
+export declare function rebuildDaemon(): void;
+/**
+ * Auto-rebuild if dist/ is stale. Used by start command.
+ */
+export declare function autoRebuildIfNeeded(): void;
+export interface StartOptions {
+    /** Path to config file. */
+    config?: string;
+    /** Enable verbose logging. */
+    verbose?: boolean;
+    /** Engine filter (strategy or factory). */
+    engine?: string;
+    /** Skip crash recovery. */
+    skipRecovery?: boolean;
+    /** Disable auto-update. */
+    noAutoUpdate?: boolean;
+    /** Run in foreground (don't daemonize). */
+    foreground?: boolean;
+    /** Auto-rebuild before starting. */
+    rebuild?: boolean;
+}
+/**
+ * Resolve the path to the daemon log file in the global state directory.
+ */
+export declare function resolveDaemonLogPath(): string;
+/**
+ * Start the daemon as a background process.
+ *
+ * Spawns a detached child process that writes stdout/stderr to the
+ * daemon log file. The child process runs `telora-daemon run` with
+ * the provided options.
+ *
+ * Returns the PID of the spawned process.
+ */
+export declare function startDaemonBackground(opts: StartOptions): number;
+/**
+ * Wait for the daemon to become healthy after background start.
+ * Checks that the PID file appears and the process is running.
+ * Returns true if healthy, false if the process died or timed out.
+ */
+export declare function waitForHealthy(timeoutMs?: number): Promise<boolean>;
+/**
+ * Clean up stale PID file if the process isn't running.
+ * Returns true if a stale file was removed.
+ */
+export declare function cleanStalePidFile(): boolean;
+/**
+ * Resolve the path to the daemon metadata file in the global state directory.
+ */
+export declare function resolveDaemonMetaPath(): string;
+/**
+ * Write daemon metadata alongside the PID file.
+ * Called during daemon startup to record the log file path and start time.
+ */
+export declare function writeDaemonMeta(logPath?: string): void;
+/**
+ * Read daemon metadata. Returns null if the file doesn't exist or is invalid.
+ */
+export declare function readDaemonMeta(): DaemonMeta | null;
+/**
+ * Remove daemon metadata file. Called during shutdown alongside PID lock release.
+ */
+export declare function removeDaemonMeta(): void;
+/**
+ * Rotate the canonical daemon log on startup.
+ *
+ * Renames the existing daemon.log to daemon.log.prev so each daemon run
+ * starts with a fresh log. Only one previous log is kept — this is enough
+ * for quick debugging without accumulating unbounded history.
+ */
+export declare function rotateDaemonLog(): void;
+/**
+ * Set up canonical log file output for foreground mode.
+ *
+ * When the daemon runs in the foreground, stdout/stderr go to the terminal.
+ * This function additionally pipes both streams to the canonical log file
+ * so that `telora-daemon logs` always has something to read, regardless
+ * of how the daemon was started.
+ *
+ * Returns a cleanup function that closes the log stream.
+ */
+export declare function setupCanonicalLogTee(): () => void;
+//# sourceMappingURL=daemon-process.d.ts.map

package/dist/daemon-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-process.d.ts","sourceRoot":"","sources":["../src/daemon-process.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyBH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWhE;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAiB9C;AAMD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,SAAS,SAAS,GACjB,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAoBtC;AAuBD;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAiBpC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C;AAMD,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,2BAA2B;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAsDhE;AAMD;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,SAAS,SAAS,GACjB,OAAO,CAAC,OAAO,CAAC,CAalB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAgB3C;AAMD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAUtD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,UAAU,GAAG,IAAI,CAYlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAMD;;;;;;GAMG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAUtC;AAMD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CAwBjD"}

package/dist/daemon-process.js

@@ -0,0 +1,427 @@
+/**
+ * Daemon process management utilities for CLI commands.
+ *
+ * Provides helpers for:
+ * - Reading PID files and checking daemon liveness
+ * - Sending signals (stop, status)
+ * - Spawning the daemon as a background process
+ * - Auto-rebuilding TypeScript before starting
+ */
+import { closeSync, createWriteStream, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { spawn, execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+/**
+ * Check if a process with the given PID is currently running.
+ * Uses kill(pid, 0) for existence check without delivering a signal.
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Global state directory
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the global daemon state directory (~/.telora/).
+ *
+ * Process-level state (PID lock, metadata, canonical log) lives here
+ * because the daemon is a user-scoped singleton -- one process per user,
+ * potentially managing multiple product repositories.
+ *
+ * Per-product state (worktrees, session logs) remains in each repo's
+ * .telora/ directory, configured via configForProduct().
+ *
+ * Override with TELORA_STATE_DIR for testing.
+ */
+export function resolveGlobalStateDir() {
+    return process.env.TELORA_STATE_DIR || resolve(homedir(), '.telora');
+}
+/**
+ * Ensure the global state directory (~/.telora/) exists.
+ * Called during daemon startup.
+ */
+export function ensureGlobalStateDir() {
+    const dir = resolveGlobalStateDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+// ---------------------------------------------------------------------------
+// PID file helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the PID file path in the global state directory (~/.telora/).
+ */
+export function resolvePidFilePath() {
+    return resolve(resolveGlobalStateDir(), 'daemon.pid');
+}
+/**
+ * Read the PID from the daemon PID file.
+ * Returns null if the file doesn't exist or contains invalid data.
+ */
+export function readDaemonPid(pidFilePath) {
+    if (!existsSync(pidFilePath))
+        return null;
+    try {
+        const contents = readFileSync(pidFilePath, 'utf-8').trim();
+        const pid = parseInt(contents, 10);
+        if (isNaN(pid) || pid <= 0)
+            return null;
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the daemon is currently running.
+ */
+export function getDaemonStatus() {
+    const pidFilePath = resolvePidFilePath();
+    const pid = readDaemonPid(pidFilePath);
+    if (pid === null) {
+        return { running: false, pid: null, pidFilePath, logPath: null, startedAt: null };
+    }
+    const running = isProcessRunning(pid);
+    const meta = readDaemonMeta();
+    return {
+        running,
+        pid: running ? pid : null,
+        pidFilePath,
+        logPath: meta?.logPath ?? null,
+        startedAt: meta?.startedAt ?? null,
+    };
+}
+// ---------------------------------------------------------------------------
+// Stop
+// ---------------------------------------------------------------------------
+/**
+ * Send SIGTERM to the running daemon and wait for it to exit.
+ * Returns true if the daemon was stopped, false if it wasn't running.
+ * Throws if the daemon doesn't exit within the timeout.
+ */
+export async function stopDaemon(timeoutMs = 30_000) {
+    const status = getDaemonStatus();
+    if (!status.running || status.pid === null) {
+        return false;
+    }
+    // Send SIGTERM
+    try {
+        process.kill(status.pid, 'SIGTERM');
+    }
+    catch {
+        // Process already gone
+        return false;
+    }
+    // Wait for the process to exit
+    const startTime = Date.now();
+    const pollIntervalMs = 200;
+    while (Date.now() - startTime < timeoutMs) {
+        if (!isProcessRunning(status.pid)) {
+            return true;
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+    throw new Error(`Daemon (PID ${status.pid}) did not exit within ${Math.round(timeoutMs / 1000)}s. ` +
+        `Use 'kill -9 ${status.pid}' to force kill.`);
+}
+// ---------------------------------------------------------------------------
+// Auto-rebuild
+// ---------------------------------------------------------------------------
+/**
+ * Check if dist/ is stale relative to src/ files.
+ * Returns true if any src/ file is newer than the newest dist/ file,
+ * or if dist/ doesn't exist.
+ */
+export function needsRebuild() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const pkgRoot = resolve(thisDir, '..');
+    const distDir = resolve(pkgRoot, 'dist');
+    const srcDir = resolve(pkgRoot, 'src');
+    // If dist doesn't exist, rebuild is needed
+    if (!existsSync(distDir))
+        return true;
+    // If running from source (tsx), no rebuild needed -- dev mode
+    if (import.meta.url.endsWith('.ts'))
+        return false;
+    // Find newest src file and newest dist file
+    const newestSrc = newestMtime(srcDir);
+    const newestDist = newestMtime(distDir);
+    if (newestSrc === 0)
+        return false; // No src files?
+    if (newestDist === 0)
+        return true; // Empty dist/
+    return newestSrc > newestDist;
+}
+function newestMtime(dir) {
+    let newest = 0;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules' || entry.name === '__tests__')
+                    continue;
+                const sub = newestMtime(fullPath);
+                if (sub > newest)
+                    newest = sub;
+            }
+            else if (entry.isFile()) {
+                const stat = statSync(fullPath);
+                if (stat.mtimeMs > newest)
+                    newest = stat.mtimeMs;
+            }
+        }
+    }
+    catch {
+        // Directory may not exist
+    }
+    return newest;
+}
+/**
+ * Rebuild the daemon TypeScript project.
+ * Runs `npm run build` in the daemon package directory.
+ */
+export function rebuildDaemon() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const pkgRoot = resolve(thisDir, '..');
+    console.log('[cli] Rebuilding daemon...');
+    try {
+        execFileSync('npm', ['run', 'build'], {
+            cwd: pkgRoot,
+            stdio: 'inherit',
+            timeout: 60_000,
+        });
+        console.log('[cli] Rebuild complete');
+    }
+    catch (err) {
+        throw new Error(`Failed to rebuild daemon: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Auto-rebuild if dist/ is stale. Used by start command.
+ */
+export function autoRebuildIfNeeded() {
+    if (needsRebuild()) {
+        console.log('[cli] dist/ is stale, rebuilding...');
+        rebuildDaemon();
+    }
+}
+/**
+ * Resolve the path to the daemon log file in the global state directory.
+ */
+export function resolveDaemonLogPath() {
+    return resolve(resolveGlobalStateDir(), 'daemon.log');
+}
+/**
+ * Start the daemon as a background process.
+ *
+ * Spawns a detached child process that writes stdout/stderr to the
+ * daemon log file. The child process runs `telora-daemon run` with
+ * the provided options.
+ *
+ * Returns the PID of the spawned process.
+ */
+export function startDaemonBackground(opts) {
+    const repoPath = process.env.TELORA_REPO_PATH || process.cwd();
+    // Ensure global state directory exists
+    ensureGlobalStateDir();
+    const logPath = resolveDaemonLogPath();
+    // Rotate log BEFORE opening the fd so the child's stdout/stderr
+    // file descriptor points to the fresh daemon.log, not the rotated
+    // daemon.log.prev. The child will skip its own rotation when it
+    // detects stdout is not a TTY (background mode).
+    rotateDaemonLog();
+    // Build args for the child process
+    const args = ['run'];
+    if (opts.config) {
+        args.push('--config', opts.config);
+    }
+    if (opts.verbose) {
+        args.push('--verbose');
+    }
+    if (opts.engine) {
+        args.push('--engine', opts.engine);
+    }
+    if (opts.skipRecovery) {
+        args.push('--skip-recovery');
+    }
+    if (opts.noAutoUpdate) {
+        args.push('--no-auto-update');
+    }
+    // Resolve the daemon entry point
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const entryPoint = resolve(thisDir, 'index.js');
+    // Open log file for appending
+    const logFd = openSync(logPath, 'a');
+    const child = spawn(process.execPath, [entryPoint, ...args], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        cwd: repoPath,
+        env: { ...process.env },
+    });
+    // Let the child run independently
+    child.unref();
+    // Close our copy of the file descriptor
+    closeSync(logFd);
+    return child.pid ?? 0;
+}
+// ---------------------------------------------------------------------------
+// Health confirmation
+// ---------------------------------------------------------------------------
+/**
+ * Wait for the daemon to become healthy after background start.
+ * Checks that the PID file appears and the process is running.
+ * Returns true if healthy, false if the process died or timed out.
+ */
+export async function waitForHealthy(timeoutMs = 10_000) {
+    const startTime = Date.now();
+    const pollIntervalMs = 500;
+    while (Date.now() - startTime < timeoutMs) {
+        const status = getDaemonStatus();
+        if (status.running && status.pid !== null) {
+            return true;
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+    return false;
+}
+/**
+ * Clean up stale PID file if the process isn't running.
+ * Returns true if a stale file was removed.
+ */
+export function cleanStalePidFile() {
+    const pidFilePath = resolvePidFilePath();
+    const pid = readDaemonPid(pidFilePath);
+    if (pid === null)
+        return false;
+    if (!isProcessRunning(pid)) {
+        try {
+            unlinkSync(pidFilePath);
+            console.log(`[cli] Removed stale PID file (PID ${pid} is not running)`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Daemon metadata (log path, start time)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the path to the daemon metadata file in the global state directory.
+ */
+export function resolveDaemonMetaPath() {
+    return resolve(resolveGlobalStateDir(), 'daemon.meta.json');
+}
+/**
+ * Write daemon metadata alongside the PID file.
+ * Called during daemon startup to record the log file path and start time.
+ */
+export function writeDaemonMeta(logPath) {
+    const metaPath = resolveDaemonMetaPath();
+    const meta = {
+        pid: process.pid,
+        logPath: logPath ?? resolveDaemonLogPath(),
+        startedAt: new Date().toISOString(),
+    };
+    ensureGlobalStateDir();
+    writeFileSync(metaPath, JSON.stringify(meta, null, 2) + '\n');
+}
+/**
+ * Read daemon metadata. Returns null if the file doesn't exist or is invalid.
+ */
+export function readDaemonMeta() {
+    const metaPath = resolveDaemonMetaPath();
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        const contents = readFileSync(metaPath, 'utf-8');
+        const meta = JSON.parse(contents);
+        if (typeof meta.pid !== 'number' || typeof meta.logPath !== 'string')
+            return null;
+        return meta;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove daemon metadata file. Called during shutdown alongside PID lock release.
+ */
+export function removeDaemonMeta() {
+    const metaPath = resolveDaemonMetaPath();
+    try {
+        if (existsSync(metaPath)) {
+            unlinkSync(metaPath);
+        }
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+// ---------------------------------------------------------------------------
+// Log rotation
+// ---------------------------------------------------------------------------
+/**
+ * Rotate the canonical daemon log on startup.
+ *
+ * Renames the existing daemon.log to daemon.log.prev so each daemon run
+ * starts with a fresh log. Only one previous log is kept — this is enough
+ * for quick debugging without accumulating unbounded history.
+ */
+export function rotateDaemonLog() {
+    const logPath = resolveDaemonLogPath();
+    if (!existsSync(logPath))
+        return;
+    const prevPath = logPath + '.prev';
+    try {
+        renameSync(logPath, prevPath);
+    }
+    catch {
+        // Log file may be in use or inaccessible — not fatal
+    }
+}
+// ---------------------------------------------------------------------------
+// Canonical log tee (foreground mode)
+// ---------------------------------------------------------------------------
+/**
+ * Set up canonical log file output for foreground mode.
+ *
+ * When the daemon runs in the foreground, stdout/stderr go to the terminal.
+ * This function additionally pipes both streams to the canonical log file
+ * so that `telora-daemon logs` always has something to read, regardless
+ * of how the daemon was started.
+ *
+ * Returns a cleanup function that closes the log stream.
+ */
+export function setupCanonicalLogTee() {
+    ensureGlobalStateDir();
+    const logPath = resolveDaemonLogPath();
+    const logStream = createWriteStream(logPath, { flags: 'a' });
+    const origStdoutWrite = process.stdout.write.bind(process.stdout);
+    const origStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = function (chunk, ...args) {
+        logStream.write(chunk);
+        return origStdoutWrite(chunk, ...args);
+    };
+    process.stderr.write = function (chunk, ...args) {
+        logStream.write(chunk);
+        return origStderrWrite(chunk, ...args);
+    };
+    return () => {
+        process.stdout.write = origStdoutWrite;
+        process.stderr.write = origStderrWrite;
+        logStream.end();
+    };
+}
+//# sourceMappingURL=daemon-process.js.map