shared-things-daemon 1.0.0

package/dist/cli.js

@@ -0,0 +1,815 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { input, select, password, confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import updateNotifier from "update-notifier";
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".shared-things");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function configExists() {
+  return fs.existsSync(CONFIG_PATH);
+}
+
+// src/things.ts
+import { execSync } from "child_process";
+function runAppleScript(script) {
+  try {
+    return execSync(`osascript -e '${script.replace(/'/g, `'"'"'`)}'`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer
+    }).trim();
+  } catch (error) {
+    throw new Error(`AppleScript failed: ${error}`);
+  }
+}
+function getTodosFromProject(projectName) {
+  const script = `
+    tell application "Things3"
+      set todoList to {}
+      set proj to project "${projectName}"
+      repeat with t in to dos of proj
+        set todoId to id of t
+        set todoTitle to name of t
+        set todoNotes to notes of t
+        set todoStatus to status of t
+        set todoDue to due date of t
+        set todoTags to tag names of t
+
+        -- Get heading if any
+        set todoHeading to ""
+        try
+          set todoHeading to id of (get area of t)
+        end try
+
+        -- Format due date
+        set dueDateStr to ""
+        if todoDue is not missing value then
+          set dueDateStr to (year of todoDue as string) & "-" & \xAC
+            (text -2 thru -1 of ("0" & (month of todoDue as integer) as string)) & "-" & \xAC
+            (text -2 thru -1 of ("0" & (day of todoDue) as string))
+        end if
+
+        -- Format status
+        set statusStr to "open"
+        if todoStatus is completed then
+          set statusStr to "completed"
+        else if todoStatus is canceled then
+          set statusStr to "canceled"
+        end if
+
+        set end of todoList to todoId & "|||" & todoTitle & "|||" & todoNotes & "|||" & dueDateStr & "|||" & todoTags & "|||" & statusStr & "|||" & todoHeading
+      end repeat
+
+      set AppleScript's text item delimiters to "^^^"
+      return todoList as string
+    end tell
+  `;
+  const result = runAppleScript(script);
+  if (!result) return [];
+  return result.split("^^^").map((line) => {
+    const [thingsId, title, notes, dueDate, tags, status, headingThingsId] = line.split("|||");
+    return {
+      thingsId,
+      title: title || "",
+      notes: notes || "",
+      dueDate: dueDate || null,
+      tags: tags ? tags.split(", ").filter(Boolean) : [],
+      status: status || "open",
+      headingThingsId: headingThingsId || null
+    };
+  });
+}
+function createTodo(projectName, todo) {
+  const params = new URLSearchParams();
+  params.set("title", todo.title);
+  if (todo.notes) params.set("notes", todo.notes);
+  if (todo.dueDate) params.set("when", todo.dueDate);
+  if (todo.tags?.length) params.set("tags", todo.tags.join(","));
+  params.set("list", projectName);
+  const url = `things:///add?${params.toString().replace(/\+/g, "%20")}`;
+  execSync(`open -g "${url}"`);
+}
+function updateTodo(authToken, thingsId, updates) {
+  const params = new URLSearchParams();
+  params.set("auth-token", authToken);
+  params.set("id", thingsId);
+  if (updates.title !== void 0) params.set("title", updates.title);
+  if (updates.notes !== void 0) params.set("notes", updates.notes);
+  if (updates.dueDate !== void 0) params.set("when", updates.dueDate);
+  if (updates.completed !== void 0) params.set("completed", updates.completed.toString());
+  if (updates.canceled !== void 0) params.set("canceled", updates.canceled.toString());
+  const url = `things:///update?${params.toString().replace(/\+/g, "%20")}`;
+  execSync(`open -g "${url}"`);
+}
+function isThingsRunning() {
+  try {
+    const result = runAppleScript(`
+      tell application "System Events"
+        return (name of processes) contains "Things3"
+      end tell
+    `);
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+function listProjects() {
+  const result = runAppleScript(`
+    tell application "Things3"
+      set projectNames to {}
+      repeat with p in projects
+        set end of projectNames to name of p
+      end repeat
+      set AppleScript's text item delimiters to "|||"
+      return projectNames as string
+    end tell
+  `);
+  if (!result) return [];
+  return result.split("|||").filter(Boolean);
+}
+
+// src/api.ts
+var ApiClient = class {
+  constructor(serverUrl, apiKey) {
+    this.serverUrl = serverUrl;
+    this.apiKey = apiKey;
+  }
+  async request(path6, options = {}) {
+    const url = `${this.serverUrl}${path6}`;
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(`API error: ${error.error || response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get full project state
+   */
+  async getState() {
+    return this.request("/state");
+  }
+  /**
+   * Get changes since timestamp
+   */
+  async getDelta(since) {
+    return this.request(`/delta?since=${encodeURIComponent(since)}`);
+  }
+  /**
+   * Push local changes
+   */
+  async push(request) {
+    return this.request("/push", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Health check
+   */
+  async health() {
+    return this.request("/health");
+  }
+  /**
+   * Reset all user data on server
+   */
+  async reset() {
+    return this.request("/reset", {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/logger.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var LOG_FILE = "daemon.log";
+var MAX_LOG_SIZE = 1024 * 1024;
+function getLogPath() {
+  return path2.join(getConfigDir(), LOG_FILE);
+}
+function rotateIfNeeded() {
+  const logPath = getLogPath();
+  if (!fs2.existsSync(logPath)) return;
+  const stats = fs2.statSync(logPath);
+  if (stats.size > MAX_LOG_SIZE) {
+    const oldLog = logPath + ".1";
+    if (fs2.existsSync(oldLog)) {
+      fs2.unlinkSync(oldLog);
+    }
+    fs2.renameSync(logPath, oldLog);
+  }
+}
+function log(message) {
+  ensureConfigDir();
+  rotateIfNeeded();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `[${timestamp}] ${message}
+`;
+  fs2.appendFileSync(getLogPath(), line);
+}
+function logError(message, error) {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  log(`ERROR: ${message}${error ? ` - ${errorMsg}` : ""}`);
+}
+function logSync(pushed, pulled, isFirstSync) {
+  if (isFirstSync) {
+    log(`First sync completed: pushed=${pushed}, pulled=${pulled}`);
+  } else if (pushed > 0 || pulled > 0) {
+    log(`Sync: pushed=${pushed}, pulled=${pulled}`);
+  } else {
+    log("Sync: no changes");
+  }
+}
+function logMapping(serverId, thingsId) {
+  log(`Mapped server ${serverId} -> local ${thingsId}`);
+}
+function logTodoCreated(title) {
+  log(`Created todo: "${title}"`);
+}
+function logTodoUpdated(thingsId, title) {
+  log(`Updated todo ${thingsId}: "${title}"`);
+}
+function logDaemonStart() {
+  log("Daemon started");
+}
+function logDaemonStop() {
+  log("Daemon stopped");
+}
+
+// src/sync.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var STATE_FILE = path3.join(getConfigDir(), "state.json");
+function loadLocalState() {
+  if (!fs3.existsSync(STATE_FILE)) {
+    return {
+      lastSyncedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      todos: /* @__PURE__ */ new Map(),
+      serverIdToThingsId: /* @__PURE__ */ new Map()
+    };
+  }
+  try {
+    const content = fs3.readFileSync(STATE_FILE, "utf-8");
+    const data = JSON.parse(content);
+    return {
+      lastSyncedAt: data.lastSyncedAt,
+      todos: new Map(Object.entries(data.todos || {})),
+      serverIdToThingsId: new Map(Object.entries(data.serverIdToThingsId || {}))
+    };
+  } catch {
+    return {
+      lastSyncedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      todos: /* @__PURE__ */ new Map(),
+      serverIdToThingsId: /* @__PURE__ */ new Map()
+    };
+  }
+}
+function saveLocalState(state) {
+  const data = {
+    lastSyncedAt: state.lastSyncedAt,
+    todos: Object.fromEntries(state.todos),
+    serverIdToThingsId: Object.fromEntries(state.serverIdToThingsId)
+  };
+  fs3.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+}
+async function runSync() {
+  const config = loadConfig();
+  if (!config) {
+    throw new Error('Not configured. Run "shared-things init" first.');
+  }
+  const api = new ApiClient(config.serverUrl, config.apiKey);
+  const localState = loadLocalState();
+  const isFirstSync = localState.lastSyncedAt === (/* @__PURE__ */ new Date(0)).toISOString();
+  const currentTodos = getTodosFromProject(config.projectName);
+  const currentTodosMap = new Map(currentTodos.map((t) => [t.thingsId, t]));
+  const localChanges = {
+    upserted: [],
+    deleted: []
+  };
+  for (const [thingsId, todo] of currentTodosMap) {
+    const prev = localState.todos.get(thingsId);
+    if (!prev || hasChanged(prev, todo)) {
+      localChanges.upserted.push(todo);
+    }
+  }
+  for (const thingsId of localState.todos.keys()) {
+    if (!currentTodosMap.has(thingsId)) {
+      localChanges.deleted.push(thingsId);
+    }
+  }
+  const thingsIdToServerId = /* @__PURE__ */ new Map();
+  for (const [serverId, thingsId] of localState.serverIdToThingsId) {
+    thingsIdToServerId.set(thingsId, serverId);
+  }
+  let pushed = 0;
+  if (localChanges.upserted.length > 0 || localChanges.deleted.length > 0) {
+    const pushRequest = {
+      headings: { upserted: [], deleted: [] },
+      todos: {
+        upserted: localChanges.upserted.map((t, idx) => ({
+          // Include serverId if we know it (for updates)
+          serverId: thingsIdToServerId.get(t.thingsId),
+          thingsId: t.thingsId,
+          title: t.title,
+          notes: t.notes,
+          dueDate: t.dueDate,
+          tags: t.tags,
+          status: t.status,
+          headingId: t.headingThingsId,
+          position: idx
+        })),
+        // Convert thingsIds to serverIds for deletions
+        deleted: localChanges.deleted.map((thingsId) => thingsIdToServerId.get(thingsId)).filter((id) => id !== void 0)
+      },
+      lastSyncedAt: localState.lastSyncedAt
+    };
+    const pushResponse = await api.push(pushRequest);
+    pushed = localChanges.upserted.length + localChanges.deleted.length;
+    for (const serverTodo of pushResponse.state.todos) {
+      const localTodo = currentTodosMap.get(serverTodo.thingsId);
+      if (localTodo) {
+        localState.serverIdToThingsId.set(serverTodo.id, localTodo.thingsId);
+      }
+    }
+  }
+  const delta = await api.getDelta(localState.lastSyncedAt);
+  let pulled = 0;
+  for (const remoteTodo of delta.todos.upserted) {
+    const localThingsId = localState.serverIdToThingsId.get(remoteTodo.id);
+    const localTodo = localThingsId ? currentTodosMap.get(localThingsId) : null;
+    if (!localTodo) {
+      const beforeTodos = new Set(currentTodosMap.keys());
+      createTodo(config.projectName, {
+        title: remoteTodo.title,
+        notes: remoteTodo.notes,
+        dueDate: remoteTodo.dueDate || void 0,
+        tags: remoteTodo.tags
+      });
+      logTodoCreated(remoteTodo.title);
+      let newTodo;
+      for (let attempt = 0; attempt < 3; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const afterTodos = getTodosFromProject(config.projectName);
+        newTodo = afterTodos.find(
+          (t) => !beforeTodos.has(t.thingsId) && t.title === remoteTodo.title
+        );
+        if (!newTodo) {
+          newTodo = afterTodos.find((t) => !beforeTodos.has(t.thingsId));
+        }
+        if (newTodo) break;
+      }
+      if (newTodo) {
+        localState.serverIdToThingsId.set(remoteTodo.id, newTodo.thingsId);
+        currentTodosMap.set(newTodo.thingsId, newTodo);
+        logMapping(remoteTodo.id, newTodo.thingsId);
+      } else {
+        logError(`Failed to find newly created todo for server ${remoteTodo.id}`, remoteTodo.title);
+      }
+      pulled++;
+    } else if (hasRemoteChanged(localTodo, remoteTodo)) {
+      updateTodo(config.thingsAuthToken, localTodo.thingsId, {
+        title: remoteTodo.title,
+        notes: remoteTodo.notes,
+        dueDate: remoteTodo.dueDate || void 0,
+        completed: remoteTodo.status === "completed",
+        canceled: remoteTodo.status === "canceled"
+      });
+      logTodoUpdated(localTodo.thingsId, remoteTodo.title);
+      pulled++;
+    }
+  }
+  if (delta.todos.deleted.length > 0) {
+    log(`Remote deletions (manual action needed): ${delta.todos.deleted.join(", ")}`);
+  }
+  localState.lastSyncedAt = delta.syncedAt;
+  localState.todos = currentTodosMap;
+  saveLocalState(localState);
+  logSync(pushed, pulled, isFirstSync);
+  return { pushed, pulled, isFirstSync };
+}
+function hasChanged(prev, curr) {
+  return prev.title !== curr.title || prev.notes !== curr.notes || prev.dueDate !== curr.dueDate || prev.status !== curr.status || JSON.stringify(prev.tags) !== JSON.stringify(curr.tags);
+}
+function hasRemoteChanged(local, remote) {
+  return local.title !== remote.title || local.notes !== remote.notes || local.dueDate !== remote.dueDate || local.status !== remote.status || JSON.stringify(local.tags) !== JSON.stringify(remote.tags);
+}
+
+// src/launchagent.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+import { execSync as execSync2 } from "child_process";
+var PLIST_NAME = "com.shared-things.daemon.plist";
+var LAUNCH_AGENTS_DIR = path4.join(os2.homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = path4.join(LAUNCH_AGENTS_DIR, PLIST_NAME);
+function installLaunchAgent() {
+  if (!fs4.existsSync(LAUNCH_AGENTS_DIR)) {
+    fs4.mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+  }
+  let binPath;
+  try {
+    binPath = execSync2("which shared-things", { encoding: "utf-8" }).trim();
+  } catch {
+    const npmPrefix = execSync2("npm prefix -g", { encoding: "utf-8" }).trim();
+    binPath = path4.join(npmPrefix, "bin", "shared-things");
+  }
+  const logPath = path4.join(os2.homedir(), ".shared-things", "daemon.log");
+  let nodeBinDir;
+  try {
+    const nodePath = execSync2("which node", { encoding: "utf-8" }).trim();
+    nodeBinDir = path4.dirname(nodePath);
+  } catch {
+    nodeBinDir = "/usr/local/bin";
+  }
+  const envPath = [
+    nodeBinDir,
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/opt/homebrew/bin"
+  ].filter((p, i, arr) => arr.indexOf(p) === i).join(":");
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.shared-things.daemon</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${binPath}</string>
+        <string>daemon</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>${logPath}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${logPath}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${envPath}</string>
+    </dict>
+
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+</dict>
+</plist>
+`;
+  fs4.writeFileSync(PLIST_PATH, plist);
+  console.log(`Created: ${PLIST_PATH}`);
+  try {
+    execSync2(`launchctl unload "${PLIST_PATH}" 2>/dev/null || true`);
+    execSync2(`launchctl load "${PLIST_PATH}"`);
+    console.log("LaunchAgent installed and started.");
+  } catch (error) {
+    console.warn(`Warning: Could not load LaunchAgent: ${error}`);
+    console.warn("You may need to manually load it or restart your Mac.");
+  }
+}
+function uninstallLaunchAgent() {
+  if (!fs4.existsSync(PLIST_PATH)) {
+    console.log("LaunchAgent not installed.");
+    return;
+  }
+  try {
+    execSync2(`launchctl unload "${PLIST_PATH}"`);
+  } catch {
+  }
+  fs4.unlinkSync(PLIST_PATH);
+  console.log("LaunchAgent uninstalled.");
+}
+function isLaunchAgentInstalled() {
+  return fs4.existsSync(PLIST_PATH);
+}
+function getLaunchAgentStatus() {
+  if (!isLaunchAgentInstalled()) {
+    return "not-installed";
+  }
+  try {
+    const result = execSync2(`launchctl list | grep com.shared-things.daemon`, {
+      encoding: "utf-8"
+    });
+    return result.includes("com.shared-things.daemon") ? "running" : "stopped";
+  } catch {
+    return "stopped";
+  }
+}
+
+// src/cli.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { spawn } from "child_process";
+var pkg = JSON.parse(fs5.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+updateNotifier({ pkg }).notify();
+var program = new Command();
+program.name("shared-things").description("Sync a Things 3 project between multiple users").version("0.1.0");
+program.command("init").description("Setup wizard").action(async () => {
+  console.log("\n\u{1F504} shared-things Setup\n");
+  if (configExists()) {
+    const overwrite = await confirm({
+      message: "Configuration already exists. Overwrite?",
+      default: false
+    });
+    if (!overwrite) {
+      console.log(chalk.dim("Cancelled."));
+      return;
+    }
+    const statePath = path5.join(getConfigDir(), "state.json");
+    if (fs5.existsSync(statePath)) {
+      fs5.unlinkSync(statePath);
+      console.log(chalk.dim("Old sync state cleared.\n"));
+    }
+  }
+  if (!isThingsRunning()) {
+    console.log("\u26A0\uFE0F  Things 3 is not running. Please start it first.\n");
+  }
+  const serverUrl = await input({
+    message: "Server URL",
+    default: "https://things.example.com",
+    validate: (value) => {
+      if (!value) return "Server URL is required";
+      if (!value.startsWith("http://") && !value.startsWith("https://")) {
+        return "URL must start with http:// or https://";
+      }
+      return true;
+    }
+  });
+  const apiKey = await password({
+    message: "API Key",
+    mask: "*",
+    validate: (value) => value ? true : "API key is required"
+  });
+  console.log("\n\u23F3 Verifying connection...");
+  const api = new ApiClient(serverUrl, apiKey);
+  try {
+    await api.health();
+    console.log("\u2705 Server reachable");
+  } catch (error) {
+    console.error(`\u274C Failed to connect to server: ${error}`);
+    process.exit(1);
+  }
+  console.log("\u23F3 Verifying API key...");
+  try {
+    await api.getState();
+    console.log("\u2705 API key valid!\n");
+  } catch (error) {
+    console.error(`\u274C Invalid API key: ${error}`);
+    process.exit(1);
+  }
+  const projects = listProjects();
+  if (projects.length === 0) {
+    console.error("\u274C No Things projects found. Create a project in Things first.");
+    process.exit(1);
+  }
+  const projectName = await select({
+    message: "Things project to sync",
+    choices: projects.map((p) => ({ name: p, value: p }))
+  });
+  console.log("\n\u23F3 Checking Things project...");
+  const todos = getTodosFromProject(projectName);
+  console.log(`\u2705 Found ${todos.length} todo${todos.length === 1 ? "" : "s"} in "${projectName}"
+`);
+  console.log("\u{1F4CB} Find your Things Auth Token in:");
+  console.log("   Things \u2192 Settings \u2192 General \u2192 Things URLs \u2192 Manage\n");
+  const thingsAuthToken = await password({
+    message: "Things Auth Token",
+    mask: "*",
+    validate: (value) => value ? true : "Auth token is required for updating tasks"
+  });
+  console.log(chalk.yellow("\n\u26A0\uFE0F  Auth token will be verified on first sync.\n"));
+  saveConfig({
+    serverUrl,
+    apiKey,
+    projectName,
+    pollInterval: 30,
+    thingsAuthToken
+  });
+  console.log("\n\u2705 Configuration saved!\n");
+  console.log("Next steps:");
+  console.log('  1. Run "shared-things install" to start the daemon');
+  console.log('  2. Or run "shared-things sync" for a one-time sync\n');
+});
+program.command("install").description("Install launchd daemon (auto-start at login)").action(() => {
+  if (!configExists()) {
+    console.error('Not configured. Run "shared-things init" first.');
+    process.exit(1);
+  }
+  installLaunchAgent();
+});
+program.command("uninstall").description("Remove launchd daemon").action(() => {
+  uninstallLaunchAgent();
+});
+program.command("status").description("Show sync status").action(async () => {
+  if (!configExists()) {
+    console.log(chalk.yellow("\u26A0\uFE0F  Not configured"));
+    console.log(chalk.dim('Run "shared-things init" to get started.'));
+    return;
+  }
+  const config = loadConfig();
+  const daemonStatus = getLaunchAgentStatus();
+  const isRunning = daemonStatus === "running";
+  console.log(chalk.bold("\n\u{1F4CA} shared-things Status\n"));
+  const api = new ApiClient(config.serverUrl, config.apiKey);
+  let serverReachable = false;
+  try {
+    await api.health();
+    serverReachable = true;
+  } catch {
+    serverReachable = false;
+  }
+  console.log(`${chalk.dim("Server:")}    ${chalk.cyan(config.serverUrl)} ${serverReachable ? chalk.green("\u25CF") : chalk.red("\u25CB")}`);
+  console.log(`${chalk.dim("Project:")}   ${chalk.white(config.projectName)}`);
+  console.log(`${chalk.dim("Interval:")}  ${config.pollInterval}s`);
+  console.log(`${chalk.dim("Daemon:")}    ${isRunning ? chalk.green("\u25CF running") : chalk.red("\u25CB stopped")}`);
+  const statePath = path5.join(getConfigDir(), "state.json");
+  if (fs5.existsSync(statePath)) {
+    const state = JSON.parse(fs5.readFileSync(statePath, "utf-8"));
+    const lastSync = new Date(state.lastSyncedAt);
+    const ago = formatTimeAgo(lastSync);
+    console.log(`${chalk.dim("Last sync:")} ${ago}`);
+  } else {
+    console.log(`${chalk.dim("Last sync:")} ${chalk.yellow("never")}`);
+  }
+  console.log();
+});
+function formatTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+program.command("sync").description("Manual one-time sync").action(async () => {
+  if (!configExists()) {
+    console.error('Not configured. Run "shared-things init" first.');
+    process.exit(1);
+  }
+  try {
+    const result = await runSync();
+    if (result.isFirstSync) {
+      console.log(chalk.cyan("\u{1F4E5} First sync completed!"));
+    }
+    console.log(chalk.green(`\u2705 Done! Pushed: ${result.pushed}, Pulled: ${result.pulled}`));
+  } catch (error) {
+    logError("Manual sync failed", error);
+    console.error(chalk.red(`\u274C Sync failed: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("daemon").description("Run sync daemon (used by launchd)").action(async () => {
+  if (!configExists()) {
+    console.error('Not configured. Run "shared-things init" first.');
+    process.exit(1);
+  }
+  const config = loadConfig();
+  logDaemonStart();
+  log(`Polling interval: ${config.pollInterval}s`);
+  console.log(`Daemon started. Syncing every ${config.pollInterval}s...`);
+  const shutdown = () => {
+    logDaemonStop();
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  try {
+    await runSync();
+    log("Initial sync complete");
+  } catch (error) {
+    logError("Initial sync failed", error);
+  }
+  setInterval(async () => {
+    try {
+      await runSync();
+    } catch (error) {
+      logError("Sync failed", error);
+    }
+  }, config.pollInterval * 1e3);
+});
+program.command("logs").description("Show daemon logs").option("-f, --follow", "Follow log output").action((options) => {
+  const logPath = path5.join(getConfigDir(), "daemon.log");
+  if (!fs5.existsSync(logPath)) {
+    console.log("No logs yet.");
+    return;
+  }
+  if (options.follow) {
+    spawn("tail", ["-f", logPath], { stdio: "inherit" });
+  } else {
+    const logs = fs5.readFileSync(logPath, "utf-8");
+    console.log(logs);
+  }
+});
+program.command("reset").description("Reset sync state (next sync will be a fresh start)").option("-s, --server", "Also delete all data on the server").action(async (options) => {
+  if (!configExists()) {
+    console.log(chalk.yellow("Not configured. Nothing to reset."));
+    return;
+  }
+  const statePath = path5.join(getConfigDir(), "state.json");
+  const hasLocalState = fs5.existsSync(statePath);
+  if (!hasLocalState && !options.server) {
+    console.log(chalk.yellow("No sync state to reset."));
+    return;
+  }
+  let message = "This will clear your local sync state.";
+  if (options.server) {
+    message = "This will clear your local sync state AND delete all your data on the server.";
+  }
+  message += " Continue?";
+  const confirmed = await confirm({
+    message,
+    default: false
+  });
+  if (!confirmed) {
+    console.log(chalk.dim("Cancelled."));
+    return;
+  }
+  if (options.server) {
+    const config = loadConfig();
+    const api = new ApiClient(config.serverUrl, config.apiKey);
+    try {
+      console.log(chalk.dim("Deleting server data..."));
+      const result = await api.reset();
+      log(`Server reset: deleted ${result.deleted.todos} todos, ${result.deleted.headings} headings`);
+      console.log(chalk.green(`\u2705 Server data deleted (${result.deleted.todos} todos, ${result.deleted.headings} headings)`));
+    } catch (error) {
+      logError("Server reset failed", error);
+      console.error(chalk.red(`\u274C Failed to reset server: ${error}`));
+      return;
+    }
+  }
+  if (hasLocalState) {
+    fs5.unlinkSync(statePath);
+    log("Sync state reset by user");
+  }
+  console.log(chalk.green('\u2705 Reset complete. Run "shared-things sync" for a fresh sync.'));
+});
+program.command("purge").description("Remove all local data (config, state, logs)").action(async () => {
+  const configDir = getConfigDir();
+  if (!fs5.existsSync(configDir)) {
+    console.log(chalk.yellow("Nothing to purge."));
+    return;
+  }
+  const daemonStatus = getLaunchAgentStatus();
+  if (daemonStatus === "running") {
+    console.log(chalk.yellow("\u26A0\uFE0F  Daemon is still running. Stopping it first..."));
+    uninstallLaunchAgent();
+  }
+  const confirmed = await confirm({
+    message: `This will delete all local data in ${configDir}. You will need to run "init" again. Continue?`,
+    default: false
+  });
+  if (!confirmed) {
+    console.log(chalk.dim("Cancelled."));
+    return;
+  }
+  fs5.rmSync(configDir, { recursive: true, force: true });
+  console.log(chalk.green('\u2705 All local data removed. Run "shared-things init" to start fresh.'));
+});
+program.parse();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "shared-things-daemon",
+  "version": "1.0.0",
+  "description": "Sync Things 3 projects between multiple macOS users",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "shared-things": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx watch src/cli.ts",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "things",
+    "things3",
+    "sync",
+    "macos",
+    "productivity",
+    "todo",
+    "collaboration",
+    "daemon",
+    "launchd",
+    "cli"
+  ],
+  "author": "yungweng",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yungweng/shared-things.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yungweng/shared-things/issues"
+  },
+  "homepage": "https://github.com/yungweng/shared-things#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "chalk": "^5.6.2",
+    "commander": "^12.0.0",
+    "update-notifier": "^7.3.1"
+  },
+  "devDependencies": {
+    "@shared-things/common": "workspace:*",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}