awarts 0.1.0 → 0.2.1

package/dist/index.js

@@ -4718,11 +4718,11 @@ import os3 from "node:os";
 var AWARTS_DIR = path2.join(os3.homedir(), ".awarts");
 var AUTH_FILE = path2.join(AWARTS_DIR, "auth.json");
 async function ensureDir() {
-  await fs6.mkdir(AWARTS_DIR, { recursive: true });
+  await fs6.mkdir(AWARTS_DIR, { recursive: true, mode: 448 });
 }
 async function saveAuth(data) {
   await ensureDir();
-  await fs6.writeFile(AUTH_FILE, JSON.stringify(data, null, 2), "utf-8");
+  await fs6.writeFile(AUTH_FILE, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
 }
 async function loadAuth() {
   try {
@@ -4747,7 +4747,7 @@ async function getToken() {
 }
 
 // src/lib/api.ts
-var DEFAULT_API_URL = "http://localhost:3001";
+var DEFAULT_API_URL = "https://honorable-bee-242.convex.site";
 async function readConfigUrl() {
   try {
     const configPath = path3.join(os4.homedir(), ".awarts", "config.json");
@@ -5816,13 +5816,15 @@ async function startDeviceAuth() {
     dim("Is the backend running? Check AWARTS_API_URL or ~/.awarts/config.json");
     return;
   }
+  const FRONTEND_URL = process.env.AWARTS_FRONTEND_URL ?? "https://awarts.vercel.app";
+  const verifyUrl = `${FRONTEND_URL}/cli/verify?code=${initData.code}`;
   console.log();
   console.log(`  ${source_default.bold("Your verification code:")}  ${source_default.bgWhite.black.bold(` ${initData.code} `)}`);
   console.log();
-  info(`Open this URL to verify:  ${source_default.cyan.underline(initData.verify_url)}`);
+  info(`Open this URL to verify:  ${source_default.cyan.underline(verifyUrl)}`);
   console.log();
   try {
-    await open_default(initData.verify_url);
+    await open_default(verifyUrl);
     dim("Browser opened automatically. Waiting for verification...");
   } catch {
     dim("Could not open browser. Please visit the URL above manually.");
@@ -6492,6 +6494,195 @@ async function syncCommand() {
   }
 }
 
+// src/lib/daemon.ts
+import fs12 from "node:fs/promises";
+import { openSync } from "node:fs";
+import path8 from "node:path";
+import os9 from "node:os";
+import { spawn } from "node:child_process";
+var AWARTS_DIR2 = path8.join(os9.homedir(), ".awarts");
+var PID_FILE = path8.join(AWARTS_DIR2, "daemon.pid");
+var LOG_FILE = path8.join(AWARTS_DIR2, "daemon.log");
+var DEFAULT_INTERVAL_MS = 5 * 60 * 1000;
+async function ensureDir2() {
+  await fs12.mkdir(AWARTS_DIR2, { recursive: true });
+}
+async function readPid() {
+  try {
+    const raw = await fs12.readFile(PID_FILE, "utf-8");
+    const pid = parseInt(raw.trim(), 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+async function writePid(pid) {
+  await ensureDir2();
+  await fs12.writeFile(PID_FILE, String(pid), "utf-8");
+}
+async function removePid() {
+  try {
+    await fs12.unlink(PID_FILE);
+  } catch {}
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function appendLog(message) {
+  await ensureDir2();
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${message}
+`;
+  await fs12.appendFile(LOG_FILE, line, "utf-8");
+}
+async function readLogTail(lines = 50) {
+  try {
+    const content = await fs12.readFile(LOG_FILE, "utf-8");
+    const allLines = content.split(`
+`).filter(Boolean);
+    return allLines.slice(-lines).join(`
+`);
+  } catch {
+    return "(no log file found)";
+  }
+}
+async function spawnDaemon(intervalMs) {
+  await ensureDir2();
+  const cliScript = process.argv[1];
+  const logFd = openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [cliScript, "daemon", "__run", "--interval", String(intervalMs)], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  const pid = child.pid;
+  if (!pid) {
+    throw new Error("Failed to spawn daemon process");
+  }
+  await writePid(pid);
+  return pid;
+}
+
+// src/commands/daemon.ts
+async function daemonStartCommand(intervalMs) {
+  banner();
+  const auth = await loadAuth();
+  if (!auth) {
+    error("Not logged in. Run  awarts login  first.");
+    return;
+  }
+  const existingPid = await readPid();
+  if (existingPid && isProcessRunning(existingPid)) {
+    warn(`Daemon is already running (PID ${existingPid}).`);
+    dim("Run  awarts daemon stop  first to restart.");
+    console.log();
+    return;
+  }
+  if (existingPid) {
+    await removePid();
+  }
+  const spin = spinner("Starting daemon...");
+  spin.start();
+  try {
+    const pid = await spawnDaemon(intervalMs);
+    spin.succeed(source_default.green(`Daemon started (PID ${pid})`));
+    console.log();
+    kv("Sync interval", `${Math.round(intervalMs / 60000)} minutes`);
+    kv("PID file", PID_FILE);
+    kv("Log file", LOG_FILE);
+    console.log();
+    dim("Run  awarts daemon status  to check health.");
+    dim("Run  awarts daemon logs    to view output.");
+    dim("Run  awarts daemon stop    to stop.");
+    console.log();
+  } catch (err) {
+    spin.fail("Failed to start daemon.");
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function daemonStopCommand() {
+  banner();
+  const pid = await readPid();
+  if (!pid) {
+    info("No daemon PID file found. Daemon is not running.");
+    console.log();
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    info(`Daemon process ${pid} is not running (stale PID file).`);
+    await removePid();
+    success("Cleaned up stale PID file.");
+    console.log();
+    return;
+  }
+  const killed = killProcess(pid);
+  if (killed) {
+    success(`Daemon stopped (PID ${pid}).`);
+    await removePid();
+  } else {
+    error(`Failed to stop daemon (PID ${pid}).`);
+  }
+  console.log();
+}
+async function daemonStatusCommand() {
+  banner();
+  const pid = await readPid();
+  console.log(`  ${source_default.bold.underline("Daemon Status")}`);
+  console.log();
+  if (!pid) {
+    warn("Daemon is not running (no PID file).");
+    dim("Start with:  awarts daemon start");
+    console.log();
+    return;
+  }
+  if (isProcessRunning(pid)) {
+    success(`Daemon is running (PID ${pid})`);
+    kv("PID file", PID_FILE);
+    kv("Log file", LOG_FILE);
+  } else {
+    warn(`Daemon is not running (stale PID ${pid}).`);
+    await removePid();
+    dim("Cleaned up stale PID file. Start with:  awarts daemon start");
+  }
+  console.log();
+}
+async function daemonLogsCommand(lines) {
+  const tail = await readLogTail(lines);
+  console.log(tail);
+}
+async function daemonRunLoop(intervalMs) {
+  await appendLog(`Daemon started. Interval: ${intervalMs}ms (${Math.round(intervalMs / 60000)} min)`);
+  const runSync = async () => {
+    await appendLog("Starting sync...");
+    try {
+      await syncCommand();
+      await appendLog("Sync completed successfully.");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await appendLog(`Sync failed: ${msg}`);
+    }
+  };
+  await runSync();
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await runSync();
+  }
+}
+
 // src/index.ts
 var program2 = new Command;
 program2.name("awarts").description("Track your AI coding spend across Claude, Codex, Gemini & Antigravity").version("0.1.0");
@@ -6542,6 +6733,49 @@ program2.command("logout").description("Clear stored credentials").action(async
     process.exit(1);
   }
 });
+var daemon = program2.command("daemon").description("Manage the background auto-sync daemon");
+daemon.command("start").description("Start the background sync daemon").option("--interval <minutes>", "Sync interval in minutes", "5").action(async (opts) => {
+  try {
+    const minutes = Number(opts.interval);
+    const intervalMs = isNaN(minutes) || minutes < 1 ? DEFAULT_INTERVAL_MS : minutes * 60 * 1000;
+    await daemonStartCommand(intervalMs);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+daemon.command("stop").description("Stop the running daemon").action(async () => {
+  try {
+    await daemonStopCommand();
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+daemon.command("status").description("Check if the daemon is running").action(async () => {
+  try {
+    await daemonStatusCommand();
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+daemon.command("logs").description("Show recent daemon log output").option("-n, --lines <count>", "Number of lines to show", "50").action(async (opts) => {
+  try {
+    await daemonLogsCommand(Number(opts.lines) || 50);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+daemon.command("__run", { hidden: true }).option("--interval <ms>", "Interval in milliseconds").action(async (opts) => {
+  try {
+    await daemonRunLoop(Number(opts.interval) || DEFAULT_INTERVAL_MS);
+  } catch (err) {
+    console.error(`Daemon error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+});
 program2.parseAsync(process.argv).catch((err) => {
   error(err instanceof Error ? err.message : String(err));
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "awarts",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Track your AI coding across Claude, Codex, Gemini & Antigravity",
   "type": "module",
   "bin": {