@tracemarketplace/cli 0.0.13 → 0.0.17

package/src/cli.ts

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import { program } from "commander";
 import { loginCommand } from "./commands/login.js";
-import { registerCommand } from "./commands/register.js";
 import { whoamiCommand } from "./commands/whoami.js";
 import { submitCommand } from "./commands/submit.js";
 import { statusCommand } from "./commands/status.js";
@@ -9,37 +11,44 @@ import { historyCommand } from "./commands/history.js";
 import { autoSubmitCommand } from "./commands/auto-submit.js";
 import { setupHookCommand } from "./commands/setup-hook.js";
 import { daemonCommand } from "./commands/daemon.js";
+import { removeHookCommand } from "./commands/remove-hook.js";
+import { removeDaemonCommand } from "./commands/remove-daemon.js";
+import { CLI_NAME, DEFAULT_PROFILE, PROD_SERVER_URL } from "./constants.js";
+
+const profileOptionDescription = `Config profile (default: ${DEFAULT_PROFILE})`;
+const packageVersion = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../package.json"), "utf-8")
+).version;
 
 program
-  .name("trace")
+  .name(CLI_NAME)
   .description("Trace Marketplace CLI — submit AI coding sessions, get paid")
-  .version("0.0.1");
+  .version(packageVersion);
 
 program
   .command("login")
-  .description("Sign in via browser — opens tracemarketplace.dev, no key needed")
-  .action(() => loginCommand().catch(handleError));
-
-program
-  .command("register")
-  .description("Register your email and get an API key")
-  .option("--server-url <url>", "Server URL (default: https://trace-marketplace-api.fly.dev)")
-  .action((opts) => registerCommand({ serverUrl: opts.serverUrl }).catch(handleError));
+  .description("Sign in via browser and save your API key")
+  .option("--profile <name>", profileOptionDescription)
+  .option("--server-url <url>", `Server URL (default prod: ${PROD_SERVER_URL})`)
+  .action((opts) => loginCommand({ profile: opts.profile, serverUrl: opts.serverUrl }).catch(handleError));
 
 program
   .command("whoami")
   .description("Show your account info and balance")
-  .action(() => whoamiCommand().catch(handleError));
+  .option("--profile <name>", profileOptionDescription)
+  .action((opts) => whoamiCommand({ profile: opts.profile }).catch(handleError));
 
 program
   .command("submit")
   .description("Auto-detect and submit traces from Claude Code, Codex CLI, and Cursor")
+  .option("--profile <name>", profileOptionDescription)
   .option("--tool <tool>", "Only submit from specific tool (claude-code|codex|cursor)")
   .option("--session <id>", "Only submit a specific session ID")
   .option("--dry-run", "Preview without submitting")
   .option("--created-since <duration>", "Only include sessions created within duration (e.g. 30d, 12h, 30m)", "30d")
   .action((opts) =>
     submitCommand({
+      profile: opts.profile,
       tool: opts.tool,
       session: opts.session,
       dryRun: opts.dryRun,
@@ -50,31 +59,58 @@ program
 program
   .command("status")
   .description("Show pending submissions and balance")
-  .action(() => statusCommand().catch(handleError));
+  .option("--profile <name>", profileOptionDescription)
+  .action((opts) => statusCommand({ profile: opts.profile }).catch(handleError));
 
 program
   .command("history")
   .description("Show submission history")
-  .action(() => historyCommand().catch(handleError));
+  .option("--profile <name>", profileOptionDescription)
+  .action((opts) => historyCommand({ profile: opts.profile }).catch(handleError));
 
 program
-  .command("auto-submit")
+  .command("auto-submit", { hidden: true })
   .description("Submit the current session (called by tool hooks — do not run manually)")
+  .option("--profile <name>", profileOptionDescription)
   .option("--tool <tool>", "Tool that triggered the hook (claude-code|cursor|codex)")
   .option("--session <id>", "Session ID (for cursor/codex hooks)")
   .option("--file <path>", "Direct path to session file (for claude-code)")
-  .action((opts) => autoSubmitCommand({ tool: opts.tool, session: opts.session, file: opts.file }));
+  .action((opts) => autoSubmitCommand({ profile: opts.profile, tool: opts.tool, session: opts.session, file: opts.file }));
 
 program
   .command("daemon")
-  .description("Watch session directories and auto-submit new sessions as they appear")
-  .action(() => daemonCommand().catch(handleError));
+  .description("Poll for new sessions and auto-submit them; use --once for cron or --watch for live mode")
+  .option("--profile <name>", profileOptionDescription)
+  .option("--interval <seconds>", "Polling interval in seconds", "60")
+  .option("--once", "Run one polling pass and exit")
+  .option("--watch", "Use live filesystem watch mode instead of polling")
+  .action((opts) =>
+    daemonCommand({
+      profile: opts.profile,
+      interval: opts.interval,
+      once: opts.once,
+      watch: opts.watch,
+    }).catch(handleError)
+  );
 
 program
   .command("setup-hook")
   .description("Install session-end hooks for Claude Code, Cursor, and Codex CLI")
+  .option("--profile <name>", profileOptionDescription)
   .option("--tool <tool>", "Only set up hook for specific tool (claude-code|cursor|codex)")
-  .action((opts) => setupHookCommand({ tool: opts.tool }).catch(handleError));
+  .action((opts) => setupHookCommand({ profile: opts.profile, tool: opts.tool }).catch(handleError));
+
+program
+  .command("remove-hook")
+  .description("Remove tracemp hooks from Claude Code, Cursor, and Codex CLI")
+  .option("--tool <tool>", "Only remove hook for specific tool (claude-code|cursor|codex)")
+  .action((opts) => removeHookCommand({ tool: opts.tool }).catch(handleError));
+
+program
+  .command("remove-daemon")
+  .description("Stop a running tracemp daemon")
+  .option("--profile <name>", profileOptionDescription)
+  .action((opts) => removeDaemonCommand({ profile: opts.profile }).catch(handleError));
 
 function handleError(e: unknown) {
   console.error((e as Error).message ?? String(e));

package/src/commands/auto-submit.ts

@@ -1,36 +1,48 @@
 /**
  * auto-submit — called by tool hooks (Claude Code Stop, Cursor sessionEnd).
  * Non-interactive: never prompts, always exits 0 so it never blocks the user's tool.
- * Logs results to ~/.config/tracemarketplace/auto-submit.log
+ * Logs results to ~/.config/tracemarketplace/auto-submit(.<profile>).log
  */
 import { readFileSync, appendFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { loadConfig } from "../config.js";
+import { getAutoSubmitLogPath, getConfigDir, loadConfig, resolveProfile } from "../config.js";
 import { findLatestFile, findCodexFileById } from "../sessions.js";
-import { submitFile, submitCursorSession } from "../submitter.js";
+import { loginCommandForProfile, DEFAULT_PROFILE } from "../constants.js";
+import {
+  buildCursorSessionSource,
+  buildFileSessionSource,
+  flushTrackedSessions,
+  type SessionSource,
+} from "../flush.js";
 
 interface AutoSubmitOptions {
+  profile?: string;
   tool?: string;
   session?: string;  // session ID (for cursor)
   file?: string;     // direct path (for claude-code when not via hook)
 }
 
-export function log(msg: string) {
-  const dir = join(homedir(), ".config", "tracemarketplace");
-  mkdirSync(dir, { recursive: true });
+export function log(msg: string, profile = DEFAULT_PROFILE) {
+  mkdirSync(getConfigDir(), { recursive: true });
   try {
-    appendFileSync(join(dir, "auto-submit.log"), `[${new Date().toISOString()}] ${msg}\n`);
+    appendFileSync(getAutoSubmitLogPath(profile), `[${new Date().toISOString()}] ${msg}\n`);
   } catch {}
 }
 
 export async function autoSubmitCommand(opts: AutoSubmitOptions): Promise<void> {
-  try { await run(opts); } catch (err) { log(`ERROR: ${String(err)}`); }
+  try {
+    await run(opts);
+  } catch (err) {
+    log(`ERROR: ${String(err)}`, resolveProfile(opts.profile));
+  }
 }
 
 async function run(opts: AutoSubmitOptions): Promise<void> {
-  const config = loadConfig();
-  if (!config) { log("Not registered — run: trace register"); return; }
+  const profile = resolveProfile(opts.profile);
+  const config = loadConfig(profile);
+  if (!config) {
+    log(`Not authenticated — run: ${loginCommandForProfile(profile)}`, profile);
+    return;
+  }
 
   // Read hook payload from stdin
   let hookPayload: Record<string, unknown> = {};
@@ -40,51 +52,79 @@ async function run(opts: AutoSubmitOptions): Promise<void> {
   } catch {}
 
   const tool = opts.tool ?? inferTool(hookPayload);
-  if (!tool) { log("Could not determine tool"); return; }
+  const triggerSource = resolveTriggerSource(tool, opts, hookPayload);
+  if (!triggerSource && !tool) {
+    log("Could not determine tool", profile);
+    return;
+  }
+
+  log(`auto-submit triggered for profile=${profile} tool=${tool ?? "unknown"}`, profile);
+
+  const result = await flushTrackedSessions(
+    config,
+    triggerSource ? [triggerSource] : [],
+    { includeIdleTracked: true }
+  );
+
+  logFlushResult(result, profile);
+}
+
+function logFlushResult(
+  result: Awaited<ReturnType<typeof flushTrackedSessions>>,
+  profile: string
+) {
+  for (const session of result.results) {
+    if (session.error && session.error !== "Empty session") {
+      log(`${session.source.label}: ${session.error}`, profile);
+      continue;
+    }
+
+    if (session.uploadedChunks > 0 || session.duplicateChunks > 0) {
+      const status = session.uploadedChunks > 0 ? "uploaded" : "duplicate";
+      log(
+        `${session.source.label}: ${status} chunks=${session.uploadedChunks + session.duplicateChunks} pending=${session.pending} payout=$${(session.payoutCents / 100).toFixed(2)}`,
+        profile
+      );
+    }
+  }
+
+  if (result.uploadedChunks === 0 && result.duplicateChunks === 0) {
+    log(`no finalized chunks ready; pending_sessions=${result.pendingSessions}`, profile);
+  }
+}
 
-  log(`auto-submit triggered for tool=${tool}`);
+function resolveTriggerSource(
+  tool: string | null,
+  opts: AutoSubmitOptions,
+  hookPayload: Record<string, unknown>
+): SessionSource | null {
+  if (!tool) {
+    return null;
+  }
 
   if (tool === "claude-code" || tool === "claude_code") {
-    // Claude Code Stop hook sends { session_id, transcript_path }
     const filePath = opts.file
       ?? hookPayload["transcript_path"] as string
       ?? findLatestFile("claude_code");
 
-    if (!filePath) { log("Claude Code: no session file found"); return; }
-
-    const result = await submitFile("claude_code", filePath, config);
-    logResult(result, filePath);
+    return filePath ? buildFileSessionSource("claude_code", filePath) : null;
+  }
 
-  } else if (tool === "cursor") {
+  if (tool === "cursor") {
     const sessionId = opts.session ?? hookPayload["sessionId"] as string;
-    if (!sessionId) { log("Cursor: no sessionId"); return; }
-
-    const result = await submitCursorSession(sessionId, config);
-    logResult(result, sessionId);
+    return sessionId ? buildCursorSessionSource(sessionId) : null;
+  }
 
-  } else if (tool === "codex" || tool === "codex_cli") {
-    // after_agent payload: { "thread-id": "...", "turn-id": "...", "cwd": "...", "last-assistant-message": "..." }
-    // Legacy / manual: session_path or session_id
+  if (tool === "codex" || tool === "codex_cli") {
     const threadId = hookPayload["thread-id"] as string ?? "";
     const filePath = opts.file
       ?? hookPayload["session_path"] as string
       ?? findCodexFileById(opts.session ?? hookPayload["session_id"] as string ?? threadId ?? "");
 
-    if (!filePath) { log("Codex: no session file found"); return; }
-
-    const result = await submitFile("codex_cli", filePath, config);
-    logResult(result, filePath);
-
-  } else {
-    log(`Unknown tool: ${tool}`);
+    return filePath ? buildFileSessionSource("codex_cli", filePath) : null;
   }
-}
 
-function logResult(result: Awaited<ReturnType<typeof submitFile>>, label: string) {
-  if (result.error) { log(`${label}: ${result.error}`); return; }
-  if (result.duplicate) { log(`${label}: already captured — skipped`); return; }
-  if (result.superseded) { log(`${label}: updated (${result.turnCount} turns) — $${(result.payoutCents / 100).toFixed(2)}`); return; }
-  log(`${label}: accepted (${result.turnCount} turns) — $${(result.payoutCents / 100).toFixed(2)}`);
+  return null;
 }
 
 function inferTool(payload: Record<string, unknown>): string | null {

package/src/commands/daemon.ts

@@ -1,34 +1,112 @@
 /**
- * trace daemon — watches ~/.claude and ~/.codex session dirs and auto-submits on change.
- * Keeps a state file so already-submitted unchanged files are skipped on restart.
+ * tracemp daemon — scans local session dirs and auto-submits new work.
  *
- * State: ~/.config/tracemarketplace/daemon-state.json
- *   { [filePath]: { mtime: number, size: number } }
+ * Default mode polls on an interval, which makes it cron-friendly and simpler
+ * to reason about than a long-lived filesystem watcher. `--once` runs a single
+ * pass and exits. `--watch` preserves the old live-watch behavior.
  *
- * On startup: backfills any files newer than last run.
- * While running: submits files 5s after they stop changing (debounce in watchDirs).
- * Server handles dedup/supersession — daemon just fires on change.
+ * State: ~/.config/tracemarketplace/daemon-state(.<profile>).json
+ *   { [filePath]: { mtime: number; size: number } }
+ *
+ * PID: ~/.config/tracemarketplace/daemon(.<profile>).pid
  */
-import { readFileSync, writeFileSync, mkdirSync, statSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, statSync, existsSync, unlinkSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import chalk from "chalk";
-import { loadConfig } from "../config.js";
+import {
+  type Config,
+  getConfigDir,
+  getDaemonPidPath,
+  getDaemonStatePath,
+  loadConfig,
+  resolveProfile,
+} from "../config.js";
 import { findFiles, watchDirs } from "../sessions.js";
-import { submitFile } from "../submitter.js";
 import { log } from "./auto-submit.js";
-
-const STATE_PATH = join(homedir(), ".config", "tracemarketplace", "daemon-state.json");
+import { CLI_NAME, DEFAULT_PROFILE, loginCommandForProfile } from "../constants.js";
+import { buildFileSessionSource, flushTrackedSessions } from "../flush.js";
 
 type DaemonState = Record<string, { mtime: number; size: number }>;
+const DEFAULT_INTERVAL_SECONDS = 60;
+const BACKFILL_LOOKBACK_DAYS = 7;
+
+interface DaemonOptions {
+  profile?: string;
+  interval?: string | number;
+  once?: boolean;
+  watch?: boolean;
+}
+
+function readDaemonPid(profile: string): number | null {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return null;
+
+  try {
+    const parsed = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+function removeDaemonPidFile(profile: string, expectedPid?: number) {
+  const pidPath = getDaemonPidPath(profile);
+  if (!existsSync(pidPath)) return;
+
+  try {
+    if (expectedPid !== undefined) {
+      const currentPid = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      if (currentPid !== expectedPid) return;
+    }
+    unlinkSync(pidPath);
+  } catch {}
+}
+
+function reserveDaemonPid(profile: string): () => void {
+  const existingPid = readDaemonPid(profile);
+  if (existingPid !== null) {
+    if (isProcessRunning(existingPid)) {
+      const profileArg = profile === DEFAULT_PROFILE ? "" : ` --profile ${profile}`;
+      throw new Error(
+        `Daemon already running for profile '${profile}' (pid ${existingPid}). Run: ${CLI_NAME} remove-daemon${profileArg}`
+      );
+    }
+    removeDaemonPidFile(profile);
+  } else {
+    removeDaemonPidFile(profile);
+  }
+
+  mkdirSync(getConfigDir(), { recursive: true });
+  writeFileSync(getDaemonPidPath(profile), `${process.pid}\n`, "utf-8");
+
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    removeDaemonPidFile(profile, process.pid);
+  };
+
+  process.once("exit", release);
+  return release;
+}
 
-function loadState(): DaemonState {
-  try { return JSON.parse(readFileSync(STATE_PATH, "utf-8")); } catch { return {}; }
+function loadState(profile: string): DaemonState {
+  try { return JSON.parse(readFileSync(getDaemonStatePath(profile), "utf-8")); } catch { return {}; }
 }
 
-function saveState(state: DaemonState) {
-  mkdirSync(join(homedir(), ".config", "tracemarketplace"), { recursive: true });
-  writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+function saveState(state: DaemonState, profile: string) {
+  mkdirSync(getConfigDir(), { recursive: true });
+  writeFileSync(getDaemonStatePath(profile), JSON.stringify(state, null, 2) + "\n");
 }
 
 function hasChanged(filePath: string, state: DaemonState): boolean {
@@ -50,33 +128,28 @@ function recordFile(filePath: string, state: DaemonState): DaemonState {
 async function processFile(
   tool: "claude_code" | "codex_cli",
   filePath: string,
-  state: DaemonState
+  state: DaemonState,
+  config: Config
 ): Promise<DaemonState> {
-  const config = loadConfig();
-  if (!config) return state;
-
-  const result = await submitFile(tool, filePath, config);
+  const result = await flushTrackedSessions(
+    config,
+    [buildFileSessionSource(tool, filePath)],
+    { includeIdleTracked: true }
+  );
   const updated = recordFile(filePath, state);
 
-  if (result.error && result.error !== "Empty session") {
-    log(`daemon: ${filePath}: ${result.error}`);
-  } else if (result.duplicate) {
-    // Already current — no log noise
-  } else if (result.superseded) {
-    log(`daemon: updated ${filePath} (${result.turnCount} turns) +$${(result.payoutCents / 100).toFixed(2)}`);
-    console.log(chalk.cyan(`  ↑ updated`), chalk.gray(filePath.split("/").slice(-2).join("/")), chalk.green(`+$${(result.payoutCents / 100).toFixed(2)}`));
-  } else if (result.accepted) {
-    log(`daemon: accepted ${filePath} (${result.turnCount} turns) +$${(result.payoutCents / 100).toFixed(2)}`);
-    console.log(chalk.green(`  ✓ new`), chalk.gray(filePath.split("/").slice(-2).join("/")), chalk.green(`+$${(result.payoutCents / 100).toFixed(2)}`));
+  for (const session of result.results) {
+    logDaemonResult(session, config.profile);
   }
 
   return updated;
 }
 
-export async function daemonCommand(): Promise<void> {
-  const config = loadConfig();
+export async function daemonCommand(opts: DaemonOptions = {}): Promise<void> {
+  const profile = resolveProfile(opts.profile);
+  const config = loadConfig(profile);
   if (!config) {
-    console.error(chalk.red("Not registered. Run: trace register"));
+    console.error(chalk.red(`Not authenticated for profile '${profile}'. Run: ${loginCommandForProfile(profile)}`));
     process.exit(1);
   }
 
@@ -89,40 +162,150 @@ export async function daemonCommand(): Promise<void> {
     return;
   }
 
-  console.log(chalk.bold("Trace daemon starting"));
-  console.log(chalk.gray(`Watching: ${tools.join(", ")}`));
-  console.log(chalk.gray("Press Ctrl+C to stop\n"));
+  const intervalSeconds = parseIntervalSeconds(opts.interval);
+  let state = loadState(config.profile);
+  const releasePid = opts.once ? null : reserveDaemonPid(config.profile);
+
+  console.log(chalk.bold("tracemp daemon starting"));
+  console.log(chalk.gray(`Profile: ${config.profile}`));
+  console.log(chalk.gray(`Server: ${config.serverUrl}`));
+  console.log(chalk.gray(`Sources: ${tools.join(", ")}`));
+
+  if (opts.watch) {
+    console.log(chalk.gray("Mode: live watch"));
+    console.log(chalk.gray("Press Ctrl+C to stop\n"));
+    await runWatchLoop(config, tools, state, releasePid ?? (() => {}));
+    return;
+  }
+
+  console.log(chalk.gray(`Mode: poll every ${intervalSeconds}s${opts.once ? " (one shot)" : ""}\n`));
+
+  state = await runScanPass(config, tools, state, { logWhenEmpty: true });
+  if (opts.once) return;
 
-  let state = loadState();
+  let shuttingDown = false;
+  const stop = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    releasePid?.();
+    console.log(chalk.gray("\nDaemon stopped."));
+    process.exit(0);
+  };
+
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+
+  while (!shuttingDown) {
+    await sleep(intervalSeconds * 1000);
+    state = await runScanPass(config, tools, state);
+  }
+}
+
+async function runScanPass(
+  config: Config,
+  tools: Array<"claude_code" | "codex_cli">,
+  state: DaemonState,
+  opts: { logWhenEmpty?: boolean } = {}
+): Promise<DaemonState> {
+  let nextState = state;
+  let processed = 0;
 
-  // Backfill: submit any files from the last 7 days that have changed since last run
-  console.log(chalk.gray("Backfilling new/changed sessions..."));
-  let backfilled = 0;
   for (const tool of tools) {
-    for (const filePath of findFiles(tool, 7)) {
-      if (hasChanged(filePath, state)) {
-        state = await processFile(tool, filePath, state);
-        backfilled++;
-      }
+    for (const filePath of findFiles(tool, BACKFILL_LOOKBACK_DAYS)) {
+      if (!hasChanged(filePath, nextState)) continue;
+      nextState = await processFile(tool, filePath, nextState, config);
+      processed++;
+    }
+  }
+
+  const idleResults = await flushTrackedSessions(config, [], { includeIdleTracked: true });
+  for (const session of idleResults.results) {
+    if (session.uploadedChunks > 0 || session.duplicateChunks > 0) {
+      logDaemonResult(session, config.profile);
     }
   }
-  saveState(state);
-  if (backfilled === 0) console.log(chalk.gray("  Nothing new.\n"));
-  else console.log();
 
-  // Watch for ongoing changes
+  saveState(nextState, config.profile);
+
+  if (
+    opts.logWhenEmpty &&
+    processed === 0 &&
+    idleResults.uploadedChunks === 0 &&
+    idleResults.duplicateChunks === 0
+  ) {
+    console.log(chalk.gray("Nothing new.\n"));
+  }
+
+  return nextState;
+}
+
+async function runWatchLoop(
+  config: Config,
+  tools: Array<"claude_code" | "codex_cli">,
+  state: DaemonState,
+  releasePid: () => void
+): Promise<void> {
+  let nextState = await runScanPass(config, tools, state, { logWhenEmpty: true });
   const stop = watchDirs(tools, async (tool, filePath) => {
-    if (!hasChanged(filePath, state)) return;
-    state = await processFile(tool, filePath, state);
-    saveState(state);
+    if (!hasChanged(filePath, nextState)) return;
+    nextState = await processFile(tool, filePath, nextState, config);
+    saveState(nextState, config.profile);
   });
 
-  console.log(chalk.gray("Watching for new sessions...\n"));
-
-  // Graceful shutdown
-  process.on("SIGINT", () => { stop(); console.log(chalk.gray("\nDaemon stopped.")); process.exit(0); });
-  process.on("SIGTERM", () => { stop(); process.exit(0); });
+  process.on("SIGINT", () => {
+    stop();
+    releasePid();
+    console.log(chalk.gray("\nDaemon stopped."));
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stop();
+    releasePid();
+    process.exit(0);
+  });
 
-  // Keep alive
   await new Promise(() => {});
 }
+
+function logDaemonResult(
+  session: Awaited<ReturnType<typeof flushTrackedSessions>>["results"][number],
+  profile: string
+) {
+  if (session.error && session.error !== "Empty session") {
+    log(`daemon: ${session.source.label}: ${session.error}`, profile);
+    return;
+  }
+
+  if (session.uploadedChunks > 0) {
+    log(
+      `daemon: accepted ${session.source.label} chunks=${session.uploadedChunks} +$${(session.payoutCents / 100).toFixed(2)}`,
+      profile
+    );
+    console.log(
+      chalk.green("  ✓ new"),
+      chalk.gray(session.source.label.split("/").slice(-2).join("/") || session.source.label),
+      chalk.green(`+$${(session.payoutCents / 100).toFixed(2)}`)
+    );
+    return;
+  }
+
+  if (session.duplicateChunks > 0) {
+    console.log(
+      chalk.cyan("  ↑ current"),
+      chalk.gray(session.source.label.split("/").slice(-2).join("/") || session.source.label)
+    );
+  }
+}
+
+function parseIntervalSeconds(raw: string | number | undefined): number {
+  if (raw === undefined) return DEFAULT_INTERVAL_SECONDS;
+  const value = typeof raw === "number" ? raw : Number.parseInt(String(raw), 10);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Daemon interval must be a positive integer number of seconds.");
+  }
+  return value;
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}