@seedvault/cli 0.1.0 → 0.1.2

package/src/commands/start.ts

@@ -1,258 +0,0 @@
-import { writeFileSync, unlinkSync } from "fs";
-import type { FSWatcher } from "chokidar";
-import {
-  loadConfig,
-  getPidPath,
-  getConfigDir,
-  normalizeConfigCollections,
-  type CollectionConfig,
-  type Config,
-} from "../config.js";
-import { createClient } from "../client.js";
-import { createWatcher, type FileEvent } from "../daemon/watcher.js";
-import { Syncer } from "../daemon/syncer.js";
-
-/**
- * sv start [-d]
- *
- *   Foreground (default): runs the daemon in the current terminal.
- *   -d: detaches as a background process.
- */
-export async function start(args: string[]): Promise<void> {
-  const daemonize = args.includes("-d") || args.includes("--daemon");
-
-  if (daemonize) {
-    return startBackground();
-  }
-
-  return startForeground();
-}
-
-/** Run daemon in the foreground */
-async function startForeground(): Promise<void> {
-  let config = loadConfig();
-  let { config: normalizedConfig, removedOverlappingCollections } = normalizeConfigCollections(config);
-  if (removedOverlappingCollections.length > 0) {
-    config = normalizedConfig;
-  }
-
-  const client = createClient(config.server, config.token);
-
-  // Verify server reachable
-  try {
-    await client.health();
-  } catch {
-    console.error(`Cannot reach server at ${config.server}`);
-    process.exit(1);
-  }
-
-  const log = (msg: string) => {
-    const ts = new Date().toISOString().slice(11, 19);
-    console.log(`[${ts}] ${msg}`);
-  };
-
-  let lastOverlapWarning = "";
-  const maybeLogOverlapWarning = (removed: CollectionConfig[]) => {
-    const summary = removed
-      .map((c) => `${c.name} (${c.path})`)
-      .sort()
-      .join(", ");
-    if (!summary) {
-      lastOverlapWarning = "";
-      return;
-    }
-    if (summary === lastOverlapWarning) return;
-    lastOverlapWarning = summary;
-    log(`Ignoring overlapping collections in config: ${summary}`);
-  };
-
-  maybeLogOverlapWarning(removedOverlappingCollections);
-
-  log("Seedvault daemon starting...");
-  log(`  Server:  ${config.server}`);
-  log(`  Contributor: ${config.contributorId}`);
-  if (config.collections.length === 0) {
-    log("  Collections: none");
-    log("  Waiting for collections to be added...");
-  } else {
-    log(`  Collections: ${config.collections.map((f) => f.name).join(", ")}`);
-  }
-
-  // Write PID file (useful for sv status / sv stop even in foreground)
-  writeFileSync(getPidPath(), String(process.pid));
-
-  const syncer = new Syncer({
-    client,
-    contributorId: config.contributorId,
-    collections: config.collections,
-    onLog: log,
-  });
-
-  if (config.collections.length > 0) {
-    // Initial sync
-    log("Running initial sync...");
-    try {
-      const { uploaded, skipped, deleted } = await syncer.initialSync();
-      log(`Initial sync complete: ${uploaded} uploaded, ${skipped} skipped, ${deleted} deleted`);
-    } catch (e: unknown) {
-      log(`Initial sync failed: ${(e as Error).message}`);
-      log("Will continue watching for changes...");
-    }
-  }
-
-  const onWatcherEvent = (event: FileEvent) => {
-    syncer.handleEvent(event).catch((e) => {
-      log(`Error handling ${event.type} for ${event.serverPath}: ${(e as Error).message}`);
-    });
-  };
-
-  let watcher: FSWatcher | null = null;
-  const rebuildWatcher = async (collections: CollectionConfig[]): Promise<void> => {
-    if (watcher) {
-      await watcher.close();
-      watcher = null;
-    }
-
-    if (collections.length === 0) {
-      log("No collections configured. Daemon idle.");
-      return;
-    }
-
-    watcher = createWatcher(collections, onWatcherEvent);
-    log(`Watching ${collections.length} collection(s): ${collections.map((f) => f.name).join(", ")}`);
-  };
-
-  await rebuildWatcher(config.collections);
-
-  let reloadingCollections = false;
-  const pollTimer = setInterval(() => {
-    if (reloadingCollections) return;
-    let nextConfig: Config;
-    try {
-      nextConfig = loadConfig();
-    } catch (e: unknown) {
-      log(`Failed to read config: ${(e as Error).message}`);
-      return;
-    }
-
-    ({ config: normalizedConfig, removedOverlappingCollections } = normalizeConfigCollections(nextConfig));
-    maybeLogOverlapWarning(removedOverlappingCollections);
-
-    reloadingCollections = true;
-
-    void (async () => {
-      try {
-        const { nextConfig: reconciledConfig, added, removed } = reconcileCollections(config, normalizedConfig);
-        if (added.length === 0 && removed.length === 0) return;
-
-        log(
-          `Collections changed: +${added.map((c) => c.name).join(", ") || "none"}, -${removed
-            .map((c) => c.name)
-            .join(", ") || "none"}`
-        );
-
-        config = reconciledConfig;
-        syncer.setCollections(reconciledConfig.collections);
-        await rebuildWatcher(reconciledConfig.collections);
-
-        for (const collection of removed) {
-          await syncer.purgeCollection(collection);
-        }
-        for (const collection of added) {
-          await syncer.syncCollection(collection);
-        }
-      } catch (e: unknown) {
-        log(`Failed to reload collections from config: ${(e as Error).message}`);
-      } finally {
-        reloadingCollections = false;
-      }
-    })();
-  }, 1500);
-
-  log("Daemon running. Press Ctrl+C to stop.");
-
-  // Handle graceful shutdown
-  const shutdown = () => {
-    log("Shutting down...");
-    clearInterval(pollTimer);
-    if (watcher) void watcher.close();
-    syncer.stop();
-
-    // Clean up PID file
-    try {
-      unlinkSync(getPidPath());
-    } catch {}
-
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-
-/** Spawn a detached background daemon */
-async function startBackground(): Promise<void> {
-  loadConfig();
-
-  // Spawn a detached child running "sv start" (foreground, no -d)
-  // We find our entry point by going up from commands/ to index.ts
-  const entryPoint = import.meta.dir + "/../index.ts";
-  const logPath = getConfigDir() + "/daemon.log";
-
-  const child = Bun.spawn({
-    cmd: ["bun", "run", entryPoint, "start"],
-    stdin: "ignore",
-    stdout: Bun.file(logPath),
-    stderr: Bun.file(logPath),
-    env: { ...process.env },
-  });
-
-  const pid = child.pid;
-  writeFileSync(getPidPath(), String(pid));
-
-  console.log(`Daemon started in background (PID ${pid}).`);
-  console.log(`  Log:  ${logPath}`);
-  console.log(`  Run 'sv status' to check, 'sv stop' to stop.`);
-
-  // Detach: don't wait for child
-  child.unref();
-}
-
-function keyByName(collections: CollectionConfig[]): Map<string, CollectionConfig> {
-  const map = new Map<string, CollectionConfig>();
-  for (const collection of collections) {
-    map.set(collection.name, collection);
-  }
-  return map;
-}
-
-function reconcileCollections(
-  prev: Config,
-  next: Config
-): { nextConfig: Config; added: CollectionConfig[]; removed: CollectionConfig[] } {
-  const prevByName = keyByName(prev.collections);
-  const nextByName = keyByName(next.collections);
-
-  const added: CollectionConfig[] = [];
-  const removed: CollectionConfig[] = [];
-
-  for (const [name, prevCollection] of prevByName) {
-    const nextCollection = nextByName.get(name);
-    if (!nextCollection) {
-      removed.push(prevCollection);
-      continue;
-    }
-    if (nextCollection.path !== prevCollection.path) {
-      removed.push(prevCollection);
-      added.push(nextCollection);
-    }
-  }
-
-  for (const [name, nextCollection] of nextByName) {
-    if (!prevByName.has(name)) {
-      added.push(nextCollection);
-    }
-  }
-
-  return { nextConfig: next, added, removed };
-}

package/src/commands/status.ts

@@ -1,63 +0,0 @@
-import { readFileSync, existsSync } from "fs";
-import { loadConfig, configExists, getPidPath } from "../config.js";
-import { createClient } from "../client.js";
-
-/**
- * sv status
- *
- * Show the current config, daemon status, and server connectivity.
- */
-export async function status(): Promise<void> {
-  if (!configExists()) {
-    console.log("Not configured. Run 'sv init' first.");
-    return;
-  }
-
-  const config = loadConfig();
-
-  console.log("Seedvault Status\n");
-
-  // Config
-  console.log(`  Server:  ${config.server}`);
-  console.log(`  Contributor: ${config.contributorId}`);
-
-  // Daemon
-  const pidPath = getPidPath();
-  if (existsSync(pidPath)) {
-    const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
-    let alive = false;
-    try {
-      process.kill(pid, 0);
-      alive = true;
-    } catch {}
-
-    if (alive) {
-      console.log(`  Daemon:  running (PID ${pid})`);
-    } else {
-      console.log(`  Daemon:  not running (stale PID file)`);
-    }
-  } else {
-    console.log("  Daemon:  not running");
-  }
-
-  // Collections
-  if (config.collections.length === 0) {
-    console.log("  Collections: none configured");
-  } else {
-    console.log(`  Collections: ${config.collections.length}`);
-    for (const f of config.collections) {
-      console.log(`    - ${f.name} -> ${f.path}`);
-    }
-  }
-
-  // Server connectivity
-  const client = createClient(config.server, config.token);
-  try {
-    await client.health();
-    console.log("  Server:  reachable");
-  } catch {
-    console.log("  Server:  unreachable");
-  }
-
-  console.log();
-}

package/src/commands/stop.ts

@@ -1,51 +0,0 @@
-import { readFileSync, unlinkSync, existsSync } from "fs";
-import { getPidPath } from "../config.js";
-
-/**
- * sv stop
- *
- * Stop the running daemon by sending SIGTERM to the PID.
- */
-export async function stop(): Promise<void> {
-  const pidPath = getPidPath();
-
-  if (!existsSync(pidPath)) {
-    console.log("No daemon is running (no PID file found).");
-    return;
-  }
-
-  const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
-
-  if (isNaN(pid)) {
-    console.error("Invalid PID file. Removing it.");
-    unlinkSync(pidPath);
-    return;
-  }
-
-  // Check if process is alive
-  try {
-    process.kill(pid, 0); // signal 0 = check existence
-  } catch {
-    console.log(`Daemon (PID ${pid}) is not running. Cleaning up PID file.`);
-    unlinkSync(pidPath);
-    return;
-  }
-
-  // Send SIGTERM
-  try {
-    process.kill(pid, "SIGTERM");
-    console.log(`Sent SIGTERM to daemon (PID ${pid}).`);
-
-    // Wait briefly and verify it stopped
-    await Bun.sleep(500);
-    try {
-      process.kill(pid, 0);
-      console.log("Daemon still running. Send SIGKILL with: kill -9 " + pid);
-    } catch {
-      console.log("Daemon stopped.");
-      try { unlinkSync(pidPath); } catch {}
-    }
-  } catch (e: unknown) {
-    console.error(`Failed to stop daemon: ${(e as Error).message}`);
-  }
-}

package/src/config.ts

@@ -1,182 +0,0 @@
-import { join, resolve, relative, isAbsolute } from "path";
-import { homedir } from "os";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-
-// --- Types ---
-
-export interface CollectionConfig {
-  path: string;
-  name: string;
-}
-
-export interface Config {
-  server: string;
-  token: string;
-  contributorId: string;
-  collections: CollectionConfig[];
-}
-
-export interface AddCollectionResult {
-  config: Config;
-  removedChildCollections: CollectionConfig[];
-}
-
-export interface NormalizeCollectionsResult {
-  config: Config;
-  removedOverlappingCollections: CollectionConfig[];
-}
-
-// --- Paths ---
-
-const CONFIG_DIR = join(homedir(), ".config", "seedvault");
-const CONFIG_PATH = join(CONFIG_DIR, "config.json");
-const PID_PATH = join(CONFIG_DIR, "daemon.pid");
-
-export function getConfigDir(): string {
-  return CONFIG_DIR;
-}
-
-export function getConfigPath(): string {
-  return CONFIG_PATH;
-}
-
-export function getPidPath(): string {
-  return PID_PATH;
-}
-
-// --- Config CRUD ---
-
-function ensureConfigDir(): void {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-
-export function configExists(): boolean {
-  return existsSync(CONFIG_PATH);
-}
-
-export function loadConfig(): Config {
-  if (!existsSync(CONFIG_PATH)) {
-    throw new Error(
-      `No config found. Run 'sv init' first.\n  Expected: ${CONFIG_PATH}`
-    );
-  }
-  const raw = readFileSync(CONFIG_PATH, "utf-8");
-  return JSON.parse(raw) as Config;
-}
-
-export function saveConfig(config: Config): void {
-  ensureConfigDir();
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-}
-
-// --- Collection management ---
-
-function isChildPath(parentPath: string, maybeChildPath: string): boolean {
-  const rel = relative(parentPath, maybeChildPath);
-  if (rel === "" || rel === ".") return false;
-  return !rel.startsWith("..") && !isAbsolute(rel);
-}
-
-function pruneOverlappingCollections(collections: CollectionConfig[]): {
-  collections: CollectionConfig[];
-  removedOverlappingCollections: CollectionConfig[];
-} {
-  const removedOverlappingCollections: CollectionConfig[] = [];
-
-  // Keep the first occurrence of an identical path.
-  const seenPaths = new Set<string>();
-  const deduped: CollectionConfig[] = [];
-  for (const collection of collections) {
-    if (seenPaths.has(collection.path)) {
-      removedOverlappingCollections.push(collection);
-      continue;
-    }
-    seenPaths.add(collection.path);
-    deduped.push(collection);
-  }
-
-  const kept: CollectionConfig[] = [];
-  for (const candidate of deduped) {
-    const hasParent = deduped.some(
-      (other) => other.path !== candidate.path && isChildPath(other.path, candidate.path)
-    );
-    if (hasParent) {
-      removedOverlappingCollections.push(candidate);
-    } else {
-      kept.push(candidate);
-    }
-  }
-
-  return { collections: kept, removedOverlappingCollections };
-}
-
-export function normalizeConfigCollections(config: Config): NormalizeCollectionsResult {
-  const { collections, removedOverlappingCollections } = pruneOverlappingCollections(config.collections);
-  if (removedOverlappingCollections.length === 0) {
-    return { config, removedOverlappingCollections: [] };
-  }
-  return {
-    config: {
-      ...config,
-      collections,
-    },
-    removedOverlappingCollections,
-  };
-}
-
-export function addCollection(config: Config, collectionPath: string, name: string): AddCollectionResult {
-  // Resolve to absolute path
-  const resolved = collectionPath.startsWith("~")
-    ? resolve(homedir(), collectionPath.slice(2))  // skip ~/
-    : resolve(collectionPath);
-
-  // Check for duplicate path
-  if (config.collections.some((f) => f.path === resolved)) {
-    throw new Error(`Collection path '${resolved}' is already configured.`);
-  }
-
-  // Reject adding a nested child under an existing parent collection.
-  const parentConflict = config.collections.find((f) => isChildPath(f.path, resolved));
-  if (parentConflict) {
-    throw new Error(
-      `Cannot add '${resolved}' because it is inside existing collection '${parentConflict.name}' (${parentConflict.path}).`
-    );
-  }
-
-  // If adding a parent path, remove existing child collections first.
-  const removedChildCollections = config.collections.filter((f) => isChildPath(resolved, f.path));
-  const retainedCollections = config.collections.filter((f) => !isChildPath(resolved, f.path));
-
-  // Check for duplicate name against retained (non-overlapping) collections.
-  if (retainedCollections.some((f) => f.name === name)) {
-    throw new Error(`A collection named '${name}' already exists. Use --name to pick a different name.`);
-  }
-
-  return {
-    config: {
-      ...config,
-      collections: [...retainedCollections, { path: resolved, name }],
-    },
-    removedChildCollections,
-  };
-}
-
-export function removeCollection(config: Config, name: string): Config {
-  const filtered = config.collections.filter((f) => f.name !== name);
-  if (filtered.length === config.collections.length) {
-    throw new Error(`No collection named '${name}' found.`);
-  }
-  return { ...config, collections: filtered };
-}
-
-/** Derive a name from a collection path (its basename) */
-export function defaultCollectionName(collectionPath: string): string {
-  const abs = collectionPath.startsWith("~")
-    ? join(homedir(), collectionPath.slice(1))
-    : collectionPath;
-  const base = abs.split("/").filter(Boolean).pop();
-  if (!base) throw new Error(`Cannot derive name from path: ${collectionPath}`);
-  return base;
-}

package/src/daemon/queue.ts

@@ -1,107 +0,0 @@
-import type { SeedvaultClient } from "../client.js";
-import { ApiError } from "../client.js";
-
-// --- Types ---
-
-export interface QueuedOperation {
-  type: "put" | "delete";
-  contributorId: string;
-  serverPath: string;
-  /** For put operations, the file content. Null for deletes. */
-  content: string | null;
-  /** Timestamp when the operation was queued */
-  queuedAt: string;
-}
-
-// --- Queue ---
-
-const MIN_BACKOFF = 1000;   // 1s
-const MAX_BACKOFF = 60000;  // 60s
-
-export class RetryQueue {
-  private items: QueuedOperation[] = [];
-  private flushing = false;
-  private backoff = MIN_BACKOFF;
-  private flushTimer: ReturnType<typeof setTimeout> | null = null;
-  private client: SeedvaultClient;
-  private onStatus: (msg: string) => void;
-
-  constructor(client: SeedvaultClient, onStatus: (msg: string) => void = () => {}) {
-    this.client = client;
-    this.onStatus = onStatus;
-  }
-
-  /** Enqueue an operation. If online, flushes immediately. */
-  enqueue(op: QueuedOperation): void {
-    this.items.push(op);
-    this.scheduleFlush(0);
-  }
-
-  /** Number of pending operations */
-  get pending(): number {
-    return this.items.length;
-  }
-
-  /** Stop the queue (cancel pending flush) */
-  stop(): void {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-  }
-
-  // --- Internal ---
-
-  private scheduleFlush(delayMs: number): void {
-    if (this.flushing || this.flushTimer) return;
-    if (this.items.length === 0) return;
-
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      this.flush();
-    }, delayMs);
-  }
-
-  private async flush(): Promise<void> {
-    if (this.flushing || this.items.length === 0) return;
-    this.flushing = true;
-
-    while (this.items.length > 0) {
-      const op = this.items[0];
-      try {
-        if (op.type === "put" && op.content !== null) {
-          await this.client.putFile(op.contributorId, op.serverPath, op.content);
-        } else if (op.type === "delete") {
-          await this.client.deleteFile(op.contributorId, op.serverPath);
-        }
-
-        // Success — remove from queue and reset backoff
-        this.items.shift();
-        this.backoff = MIN_BACKOFF;
-      } catch (e: unknown) {
-        // API errors (4xx) mean the server is reachable but the op is invalid —
-        // drop the op and continue flushing.
-        if (e instanceof ApiError && e.status >= 400 && e.status < 500) {
-          this.onStatus(`Dropping failed op: ${op.type} ${op.serverPath} (${e.status})`);
-          this.items.shift();
-          continue;
-        }
-
-        // Network error — stop flushing, schedule retry
-        const errMsg = e instanceof Error ? e.message : String(e);
-        this.onStatus(
-          `Server unreachable (${errMsg}), ${this.items.length} op(s) queued. Retry in ${this.backoff / 1000}s.`
-        );
-        this.flushing = false;
-        this.scheduleFlush(this.backoff);
-        this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF);
-        return;
-      }
-    }
-
-    this.flushing = false;
-    if (this.items.length === 0) {
-      this.onStatus("Queue flushed — all synced.");
-    }
-  }
-}