@rigxyz/tapd 0.1.0

package/dist/bin.js

@@ -0,0 +1,886 @@
+#!/usr/bin/env node
+import {
+  AlreadyInitializedError,
+  AlreadyJoinedError,
+  InvalidInviteUrlError,
+  NotInitializedError,
+  RelayClient,
+  STATE_KEY_CONFLICT_COUNT,
+  bindingConfigFile,
+  computeLocalDiff,
+  findConflictSidecars,
+  init,
+  join,
+  list,
+  loadIgnore,
+  mint,
+  openStateDb,
+  readBindingConfig,
+  revoke,
+  start
+} from "./chunk-RQC73B5Y.js";
+
+// src/bin.ts
+import { join as pathJoin, resolve } from "path";
+import kleur from "kleur";
+
+// src/pidfile.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname } from "path";
+var PidfileLockError = class extends Error {
+  constructor(pidfilePath, pid) {
+    super(`pidfile ${pidfilePath} held by live process ${pid}`);
+    this.pidfilePath = pidfilePath;
+    this.pid = pid;
+    this.name = "PidfileLockError";
+  }
+  pidfilePath;
+  pid;
+};
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+function readLivePid(path) {
+  if (!existsSync(path)) return null;
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8").trim();
+  } catch {
+    return null;
+  }
+  const pid = Number.parseInt(raw, 10);
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  return isProcessAlive(pid) ? pid : null;
+}
+function acquire(path) {
+  const livePid = readLivePid(path);
+  if (livePid !== null) {
+    throw new PidfileLockError(path, livePid);
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, String(process.pid), { mode: 384 });
+}
+function release(path) {
+  if (!existsSync(path)) return;
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8").trim();
+  } catch {
+    return;
+  }
+  const pid = Number.parseInt(raw, 10);
+  if (pid !== process.pid) return;
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
+// src/status.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/version.ts
+var TAPD_VERSION = "0.1.0";
+
+// src/status.ts
+var STATE_KEY_LAST_APPLY_ERROR = "last_apply_error";
+var STATE_KEY_LAST_APPLY_ERROR_AT = "last_apply_error_at";
+var DAEMON_PIDFILE_REL = ".rig/tap/daemon.pid";
+var PENDING_PROBE_LIMIT = 100;
+var STATUS_PROTOCOL_VERSION = 1;
+function statusToJson(report) {
+  return {
+    protocolVersion: STATUS_PROTOCOL_VERSION,
+    version: TAPD_VERSION,
+    bindingId: report.config.bindingId,
+    relayUrl: report.config.relayUrl,
+    deviceId: report.config.deviceId,
+    daemon: report.daemon,
+    cursor: report.cursor,
+    remoteCursor: report.remoteCursor,
+    trackedPaths: report.trackedPaths,
+    pendingApplies: report.pendingApplies,
+    pendingUploads: report.pendingUploads,
+    conflicts: report.conflicts,
+    lastApplyError: report.lastApplyError,
+    offline: report.offline
+  };
+}
+async function status(opts) {
+  const config = readBindingConfig(opts.rootDir);
+  if (!config) {
+    throw new NotInitializedError(opts.rootDir);
+  }
+  const db = openStateDb(join2(opts.rootDir, ".rig", "tap", "state.local.db"));
+  try {
+    const cursor = db.getCursor();
+    const tracked = db.listPaths().length;
+    const conflictCount = Number.parseInt(
+      db.getMeta(STATE_KEY_CONFLICT_COUNT) ?? "0",
+      10
+    );
+    const lastErrJson = db.getMeta(STATE_KEY_LAST_APPLY_ERROR);
+    const lastErrAt = db.getMeta(STATE_KEY_LAST_APPLY_ERROR_AT);
+    const lastApplyError = lastErrJson ? safeParseLastError(lastErrJson, lastErrAt) : null;
+    const pidfilePath = join2(opts.rootDir, DAEMON_PIDFILE_REL);
+    const livePid = readLivePid(pidfilePath);
+    const daemon = livePid !== null ? { running: true, pid: livePid } : { running: false };
+    const client = new RelayClient({
+      baseUrl: config.relayUrl,
+      bindingId: config.bindingId,
+      token: config.token,
+      fetch: opts.fetch
+    });
+    let remoteEvents = [];
+    let offline = false;
+    try {
+      const probe = await client.listChanges({
+        after: cursor,
+        limit: PENDING_PROBE_LIMIT
+      });
+      remoteEvents = probe.events;
+    } catch {
+      offline = true;
+    }
+    const peekLimit = opts.peekLimit ?? 5;
+    const pendingPeek = remoteEvents.slice(0, peekLimit);
+    const pendingApplies = remoteEvents.length;
+    const remoteCursor = remoteEvents.length > 0 ? remoteEvents[remoteEvents.length - 1].id : cursor;
+    let pendingUploads = 0;
+    if (existsSync2(opts.rootDir)) {
+      const ignore = loadIgnore(opts.rootDir);
+      const diff = await computeLocalDiff({ rootDir: opts.rootDir, stateDb: db, ignore });
+      pendingUploads = diff.writes.length + diff.deletes.length + diff.mkdirs.length + diff.rmdirs.length;
+    }
+    const conflicts = findConflictSidecars(opts.rootDir);
+    return {
+      config,
+      cursor,
+      remoteCursor,
+      trackedPaths: tracked,
+      pendingPeek,
+      pendingApplies,
+      pendingUploads,
+      conflicts,
+      conflictCount,
+      lastApplyError,
+      daemon,
+      offline
+    };
+  } finally {
+    db.close();
+  }
+}
+function safeParseLastError(json, at) {
+  try {
+    const parsed = JSON.parse(json);
+    if (typeof parsed.eventId !== "string" || typeof parsed.path !== "string" || typeof parsed.op !== "string" || typeof parsed.reason !== "string") {
+      return null;
+    }
+    return {
+      eventId: parsed.eventId,
+      path: parsed.path,
+      op: parsed.op,
+      reason: parsed.reason,
+      at: at ?? ""
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/uninit.ts
+import {
+  existsSync as existsSync3,
+  rmSync,
+  rmdirSync,
+  statSync,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { join as join3 } from "path";
+var DAEMON_PIDFILE_REL2 = ".rig/tap/daemon.pid";
+var STATE_DIR_REL = ".rig/tap";
+var DaemonStillRunningError = class extends Error {
+  constructor(pid) {
+    super(`daemon still running (pid ${pid}); stop it first`);
+    this.pid = pid;
+    this.name = "DaemonStillRunningError";
+  }
+  pid;
+};
+function uninit(opts) {
+  const config = readBindingConfig(opts.rootDir);
+  if (!config) {
+    throw new NotInitializedError(opts.rootDir);
+  }
+  const pidfilePath = join3(opts.rootDir, DAEMON_PIDFILE_REL2);
+  const livePid = readLivePid(pidfilePath);
+  if (livePid !== null) {
+    throw new DaemonStillRunningError(livePid);
+  }
+  const stateDbPath = join3(opts.rootDir, ".rig", "tap", "state.local.db");
+  const tracked = [];
+  if (existsSync3(stateDbPath)) {
+    const db = openStateDb(stateDbPath);
+    try {
+      for (const p of db.listPaths()) {
+        const entry = db.getPath(p);
+        if (!entry) continue;
+        tracked.push({ path: p, isDir: entry.lastSeenHash === null });
+      }
+    } finally {
+      db.close();
+    }
+  }
+  let filesDeleted = 0;
+  let dirsRemoved = 0;
+  let alreadyGone = 0;
+  const skippedNonEmptyDirs = [];
+  if (opts.purge) {
+    const files = tracked.filter((t) => !t.isDir);
+    const dirs = tracked.filter((t) => t.isDir).sort((a, b) => b.path.split("/").length - a.path.split("/").length);
+    for (const f of files) {
+      const abs = join3(opts.rootDir, f.path);
+      try {
+        const st = statSync(abs);
+        if (st.isFile()) {
+          unlinkSync2(abs);
+          filesDeleted += 1;
+        } else {
+          skippedNonEmptyDirs.push(f.path);
+        }
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          alreadyGone += 1;
+        } else {
+          throw err;
+        }
+      }
+    }
+    for (const d of dirs) {
+      const abs = join3(opts.rootDir, d.path);
+      try {
+        rmdirSync(abs);
+        dirsRemoved += 1;
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          alreadyGone += 1;
+        } else if (code === "ENOTEMPTY" || code === "EEXIST") {
+          skippedNonEmptyDirs.push(d.path);
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+  const cfgPath = bindingConfigFile(opts.rootDir);
+  if (existsSync3(cfgPath)) {
+    try {
+      unlinkSync2(cfgPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  const stateDir = join3(opts.rootDir, STATE_DIR_REL);
+  if (existsSync3(stateDir)) {
+    rmSync(stateDir, { recursive: true, force: true });
+  }
+  return {
+    bindingId: config.bindingId,
+    trackedPaths: tracked.length,
+    filesDeleted,
+    dirsRemoved,
+    alreadyGone,
+    skippedNonEmptyDirs
+  };
+}
+
+// src/bin.ts
+var DAEMON_PIDFILE_REL3 = ".rig/tap/daemon.pid";
+var PROTOCOL_VERSION = 1;
+function printJson(payload) {
+  process.stdout.write(JSON.stringify(payload) + "\n");
+}
+function printJsonError(code, message) {
+  printJson({ protocolVersion: PROTOCOL_VERSION, error: { code, message } });
+}
+function help() {
+  const C = kleur;
+  console.log(`${C.bold().cyan("tapd")} ${C.dim("\u2014 local daemon for hosted Tap sync")}
+
+${C.bold().cyan("COMMANDS")}
+  ${C.green("tapd init")}    bootstrap a binding in the current directory
+  ${C.green("tapd invite")}  mint / list / revoke invite URLs (owner only)
+  ${C.green("tapd join")}    accept an invite URL into the current directory
+  ${C.green("tapd start")}   run the watch + apply daemon (foreground)
+  ${C.green("tapd status")}  show binding + cursor + pending remote events
+  ${C.green("tapd uninit")}  disconnect this checkout (optionally --purge tracked files)
+  ${C.green("tapd help")}    this message
+
+${C.dim("--version / -v")} print the tapd binary version on stdout and exit.
+${C.dim("--json")} on init / invite / join / status / uninit emits a versioned
+JSON payload to stdout (protocolVersion: 1) for programmatic consumers (rig).
+
+${C.bold().cyan("tapd init OPTIONS")}
+  ${C.dim("--name <n>")}              binding display name (required)
+  ${C.dim("--owner-user-id <u>")}     placeholder user id (Phase 3 sources from Clerk)
+  ${C.dim("--relay <url>")}           default http://127.0.0.1:4030
+  ${C.dim("--device-label <l>")}      default 'owner'
+  ${C.dim("--dir <path>")}            default cwd
+
+${C.bold().cyan("tapd join OPTIONS")}
+  ${C.dim("<invite-url>")}            positional \u2014 full URL from \`rig invite\` /
+                                relay (.../v1/invites/<secret>/accept)
+  ${C.dim("--user-id <u>")}           Phase 3 placeholder until Clerk
+  ${C.dim("--email <e>")}             optional; required if the invite has
+                                an emailConstraint
+  ${C.dim("--device-label <l>")}      default 'device'
+  ${C.dim("--dir <path>")}            default cwd
+
+${C.bold().cyan("tapd invite SUBCOMMANDS")}
+  ${C.green("tapd invite create")}    mint a new invite + print the URL once
+    ${C.dim("--ops <read,write,subscribe>")}    default read,write,subscribe
+    ${C.dim("--role <owner|editor|viewer>")}    omit for pure-capability collab
+    ${C.dim("--path-glob <g>")}                 repeatable; restrict by path
+    ${C.dim("--ttl <duration>")}                e.g. 24h, 7d, 30m (omit for never)
+    ${C.dim("--max-uses <n>")}                  default unlimited; 1 = single-use
+    ${C.dim("--email <e>")}                     require accepter to claim this email
+    ${C.dim("--label <l>")}                     show in list output
+    ${C.dim("--dir <path>")}                    default cwd
+  ${C.green("tapd invite list")}                show outstanding invites + status
+  ${C.green("tapd invite revoke <id>")}          revoke an invite AND its issued tokens
+
+${C.bold().cyan("tapd start OPTIONS")}
+  ${C.dim("--dir <path>")}            default cwd
+  ${C.dim("--poll-seconds <n>")}      default 3
+  ${C.dim("--no-pidfile")}            don't write .rig/tap/daemon.pid (default: write)
+`);
+}
+function parseTtl(raw) {
+  if (!raw) return void 0;
+  const m = /^(\d+)([smhd])?$/.exec(raw.trim());
+  if (!m) {
+    console.error(kleur.red("error:"), `invalid --ttl: ${raw} (expected e.g. 30m, 12h, 7d)`);
+    process.exit(2);
+  }
+  const n = Number(m[1]);
+  const unit = m[2] ?? "s";
+  const factor = unit === "d" ? 86400 : unit === "h" ? 3600 : unit === "m" ? 60 : 1;
+  return n * factor;
+}
+var VALID_OPS = ["read", "write", "subscribe"];
+var VALID_ROLES = ["owner", "editor", "viewer"];
+function parseOps(raw) {
+  if (!raw) return ["read", "write", "subscribe"];
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const p of parts) {
+    if (!VALID_OPS.includes(p)) {
+      console.error(kleur.red("error:"), `invalid --ops value '${p}' (allowed: ${VALID_OPS.join(",")})`);
+      process.exit(2);
+    }
+  }
+  return parts;
+}
+function parseRole(raw) {
+  if (raw === void 0) return void 0;
+  if (!VALID_ROLES.includes(raw)) {
+    console.error(kleur.red("error:"), `invalid --role '${raw}' (allowed: ${VALID_ROLES.join("|")})`);
+    process.exit(2);
+  }
+  return raw;
+}
+function collectPathGlobs(flags2) {
+  const raw = flags2.get("path-glob");
+  if (typeof raw !== "string") return void 0;
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+async function runInvite(positional2, flags2) {
+  const json = flags2.get("json") === true;
+  const sub = positional2[0];
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  try {
+    if (sub === void 0 || sub === "create") {
+      const ops = parseOps(flags2.get("ops"));
+      const role = parseRole(flags2.get("role"));
+      const pathGlobs = collectPathGlobs(flags2);
+      const ttlSeconds = parseTtl(flags2.get("ttl"));
+      const maxUsesRaw = flags2.get("max-uses");
+      const maxUses = typeof maxUsesRaw === "string" ? Number(maxUsesRaw) : void 0;
+      if (maxUses !== void 0 && (!Number.isInteger(maxUses) || maxUses < 1)) {
+        if (json) printJsonError("invalid_flag", "--max-uses must be an integer \u2265 1");
+        else console.error(kleur.red("error:"), "--max-uses must be an integer \u2265 1");
+        process.exit(2);
+      }
+      const emailConstraint = flags2.get("email");
+      const label = flags2.get("label");
+      const result = await mint({
+        rootDir,
+        ops,
+        role: role ?? null,
+        pathGlobs,
+        ttlSeconds,
+        maxUses,
+        emailConstraint,
+        label
+      });
+      if (json) {
+        printJson({
+          protocolVersion: PROTOCOL_VERSION,
+          invite: result.invite,
+          url: result.url
+        });
+        return;
+      }
+      const C = kleur;
+      console.log(C.bold().cyan("tapd invite create"));
+      console.log(`  id:       ${C.bold(result.invite.id)}`);
+      console.log(`  ops:      ${result.invite.ops.join(", ")}`);
+      console.log(`  role:     ${result.invite.role ?? C.dim("pure-capability")}`);
+      if (result.invite.pathGlobs.length > 0) {
+        console.log(`  scope:    ${result.invite.pathGlobs.join(" | ")}`);
+      }
+      if (result.invite.expiresAt) {
+        console.log(`  expires:  ${result.invite.expiresAt}`);
+      } else {
+        console.log(`  expires:  ${C.dim("never")}`);
+      }
+      console.log(
+        `  uses:     ${C.dim(`${result.invite.useCount}/${result.invite.maxUses ?? "\u221E"}`)}`
+      );
+      if (result.invite.emailConstraint) {
+        console.log(`  email:    ${result.invite.emailConstraint}`);
+      }
+      if (result.invite.label) {
+        console.log(`  label:    ${result.invite.label}`);
+      }
+      console.log("");
+      console.log(C.bold("  Invite URL (share once):"));
+      console.log(`    ${C.green(result.url)}`);
+      console.log(C.dim("  Recipients run: tapd join <url> --user-id <u>"));
+      return;
+    }
+    if (sub === "list") {
+      const invites = await list({ rootDir });
+      if (json) {
+        printJson({ protocolVersion: PROTOCOL_VERSION, invites });
+        return;
+      }
+      const C = kleur;
+      if (invites.length === 0) {
+        console.log(C.dim("no invites"));
+        return;
+      }
+      console.log(C.bold().cyan("tapd invite list"));
+      for (const i of invites) {
+        const status2 = i.revokedAt ? C.red("revoked") : i.expiresAt && new Date(i.expiresAt).getTime() < Date.now() ? C.dim("expired") : i.maxUses !== null && i.useCount >= i.maxUses ? C.dim("exhausted") : C.green("active");
+        const roleLabel = i.role ?? "pure-cap";
+        const useFrac = `${i.useCount}/${i.maxUses ?? "\u221E"}`;
+        const labelSuffix = i.label ? `  "${i.label}"` : "";
+        console.log(
+          `  ${C.bold(i.id)}  ${status2}  ${roleLabel.padEnd(8)}  uses ${useFrac}${labelSuffix}`
+        );
+      }
+      return;
+    }
+    if (sub === "revoke") {
+      const inviteId = positional2[1];
+      if (!inviteId) {
+        if (json) printJsonError("missing_argument", "usage: tapd invite revoke <inviteId>");
+        else console.error(kleur.red("error:"), "usage: tapd invite revoke <inviteId>");
+        process.exit(2);
+      }
+      const result = await revoke({ rootDir, inviteId });
+      if (json) {
+        printJson({
+          protocolVersion: PROTOCOL_VERSION,
+          inviteId,
+          alreadyRevoked: result.alreadyRevoked
+        });
+        return;
+      }
+      const C = kleur;
+      if (result.alreadyRevoked) {
+        console.log(`${C.dim("\u2713")} ${inviteId} ${C.dim("(was already revoked)")}`);
+      } else {
+        console.log(`${C.green("\u2713")} revoked ${C.bold(inviteId)} (issued tokens revoked too)`);
+      }
+      return;
+    }
+    if (json) printJsonError("unknown_subcommand", `unknown subcommand: tapd invite ${sub}`);
+    else {
+      console.error(kleur.red("error:"), `unknown subcommand: tapd invite ${sub}`);
+      console.error("  see `tapd help`");
+    }
+    process.exit(2);
+  } catch (err) {
+    if (err instanceof NotInitializedError) {
+      if (json) printJsonError("not_initialized", err.message);
+      else console.error(kleur.red("error:"), err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+async function runJoin(positional2, flags2) {
+  const json = flags2.get("json") === true;
+  const inviteUrl = positional2[0];
+  if (!inviteUrl) {
+    if (json) printJsonError("missing_argument", "missing invite URL");
+    else {
+      console.error(kleur.red("error:"), "missing invite URL");
+      console.error("  usage: tapd join <invite-url> --user-id <u>");
+    }
+    process.exit(2);
+  }
+  const userId = flags2.get("user-id");
+  if (!userId) {
+    if (json) printJsonError("missing_flag", "--user-id is required (placeholder until Clerk)");
+    else console.error(kleur.red("error:"), "--user-id is required (Phase 3 placeholder until Clerk)");
+    process.exit(2);
+  }
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  const email = flags2.get("email");
+  const deviceLabel = flags2.get("device-label");
+  let result;
+  try {
+    result = await join({ rootDir, inviteUrl, userId, email, deviceLabel });
+  } catch (err) {
+    if (err instanceof AlreadyJoinedError) {
+      if (json) printJsonError("already_joined", err.message);
+      else {
+        console.error(kleur.red("error:"), err.message);
+        console.error(kleur.dim("  to sync this rig, run `tapd start`."));
+      }
+      process.exit(1);
+    }
+    if (err instanceof InvalidInviteUrlError) {
+      if (json) printJsonError("invalid_invite_url", err.message);
+      else console.error(kleur.red("error:"), err.message);
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (json) {
+    printJson({
+      protocolVersion: PROTOCOL_VERSION,
+      bindingId: result.bindingId,
+      device: { id: result.device.id, label: result.device.label },
+      tokenSecret: result.tokenSecret,
+      becameMember: result.becameMember
+    });
+    return;
+  }
+  const C = kleur;
+  console.log(C.bold().cyan("tapd join"));
+  console.log(`  binding:  ${C.bold(result.bindingId)}`);
+  console.log(`  device:   ${C.bold(result.device.id)}  ${C.dim(result.device.label)}`);
+  console.log(`  role:     ${result.becameMember ? C.green("member") : C.dim("pure-capability")}`);
+  console.log("");
+  console.log(C.bold("  Capability token (shown once):"));
+  console.log(`    ${C.green(result.tokenSecret)}`);
+  console.log(C.dim(`    Stored in ${rootDir}/.rig/tap-binding.local.json (mode 0600).`));
+  console.log("");
+  console.log(C.dim("  Next: `tapd start` (initial apply pulls the remote manifest)."));
+}
+async function runStatus(flags2) {
+  const json = flags2.get("json") === true;
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  let report;
+  try {
+    report = await status({ rootDir });
+  } catch (err) {
+    if (err instanceof NotInitializedError) {
+      if (json) printJsonError("not_initialized", err.message);
+      else console.error(kleur.red("error:"), err.message);
+      process.exit(1);
+    }
+    if (json) printJsonError("status_failed", err.message);
+    else console.error(kleur.red("error:"), err.message);
+    process.exit(1);
+  }
+  if (json) {
+    printJson(statusToJson(report));
+    return;
+  }
+  const C = kleur;
+  console.log(C.bold().cyan("tapd status"));
+  console.log(`  binding:  ${C.bold(report.config.bindingId)}`);
+  console.log(`  relay:    ${report.config.relayUrl}`);
+  console.log(`  device:   ${C.bold(report.config.deviceId)}`);
+  console.log(`  cursor:   ${report.cursor}`);
+  console.log(`  tracked:  ${report.trackedPaths} paths`);
+  if (report.pendingPeek.length === 0) {
+    console.log(`  pending:  ${C.green("up to date")}`);
+  } else {
+    console.log(`  pending:  ${C.yellow(`${report.pendingPeek.length}+ events behind`)}`);
+    for (const ev of report.pendingPeek) {
+      console.log(C.dim(`    ${ev.op.padEnd(6)} ${ev.path}  (${ev.id})`));
+    }
+  }
+  if (report.conflictCount > 0) {
+    console.log(
+      `  conflicts: ${C.yellow(String(report.conflictCount))} ${C.dim("(sidecars at *.conflict-from.*)")}`
+    );
+  } else {
+    console.log(`  conflicts: ${C.dim("none")}`);
+  }
+  if (report.lastApplyError) {
+    const e = report.lastApplyError;
+    console.log(
+      `  last err: ${C.red(e.reason)} ${C.dim(`(${e.op} ${e.path} @ ${e.eventId}${e.at ? `, ${e.at}` : ""})`)}`
+    );
+  }
+}
+async function runUninit(flags2) {
+  const json = flags2.get("json") === true;
+  const purge = flags2.get("purge") === true;
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  let result;
+  try {
+    result = uninit({ rootDir, purge });
+  } catch (err) {
+    if (err instanceof DaemonStillRunningError) {
+      if (json) printJsonError("daemon_still_running", err.message);
+      else {
+        console.error(kleur.red("error:"), err.message);
+        console.error(kleur.dim("  stop it with `kill <pid>` or send SIGTERM, then re-run."));
+      }
+      process.exit(1);
+    }
+    if (err instanceof NotInitializedError) {
+      if (json) printJsonError("not_initialized", err.message);
+      else console.error(kleur.red("error:"), err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (json) {
+    printJson({
+      protocolVersion: PROTOCOL_VERSION,
+      bindingId: result.bindingId,
+      purged: purge,
+      trackedPaths: result.trackedPaths,
+      filesDeleted: result.filesDeleted,
+      dirsRemoved: result.dirsRemoved,
+      alreadyGone: result.alreadyGone,
+      skippedNonEmptyDirs: result.skippedNonEmptyDirs
+    });
+    return;
+  }
+  const C = kleur;
+  console.log(C.bold().cyan("tapd uninit"));
+  console.log(`  binding:  ${C.bold(result.bindingId)}  ${C.green("disconnected")}`);
+  if (purge) {
+    console.log(`  purge:    ${result.filesDeleted} files + ${result.dirsRemoved} dirs removed`);
+    if (result.alreadyGone > 0) {
+      console.log(`  skipped:  ${C.dim(`${result.alreadyGone} already gone`)}`);
+    }
+    if (result.skippedNonEmptyDirs.length > 0) {
+      console.log(
+        `  kept:     ${C.yellow(`${result.skippedNonEmptyDirs.length} non-empty dirs (untracked content inside)`)}`
+      );
+      for (const d of result.skippedNonEmptyDirs.slice(0, 5)) {
+        console.log(C.dim(`    ${d}`));
+      }
+      if (result.skippedNonEmptyDirs.length > 5) {
+        console.log(C.dim(`    \u2026 and ${result.skippedNonEmptyDirs.length - 5} more`));
+      }
+    }
+  } else {
+    console.log(C.dim(`  ${result.trackedPaths} tracked paths left in place (pass --purge to remove)`));
+  }
+}
+async function runStart(flags2) {
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  const pollSeconds = flags2.has("poll-seconds") ? Number(flags2.get("poll-seconds")) : void 0;
+  const pidfilePath = flags2.get("no-pidfile") === true ? null : pathJoin(rootDir, DAEMON_PIDFILE_REL3);
+  let handle = null;
+  let stopping = false;
+  const cleanup = async () => {
+    if (stopping) return;
+    stopping = true;
+    console.log("\nstopping\u2026");
+    try {
+      if (handle) await handle.stop();
+    } finally {
+      if (pidfilePath) release(pidfilePath);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  if (pidfilePath) {
+    try {
+      acquire(pidfilePath);
+    } catch (err) {
+      if (err instanceof PidfileLockError) {
+        console.error(kleur.red("error:"), err.message);
+        console.error(kleur.dim(`  another \`tapd start\` is already running (pid ${err.pid}).`));
+        console.error(kleur.dim("  stop it with `kill <pid>` or pass --no-pidfile to override."));
+        process.exit(1);
+      }
+      throw err;
+    }
+  }
+  try {
+    handle = await start({ rootDir, pollSeconds });
+  } catch (err) {
+    if (pidfilePath) release(pidfilePath);
+    console.error(kleur.red("error:"), err.message);
+    process.exit(1);
+  }
+  console.log(kleur.bold().cyan("tapd start"));
+  console.log(`  dir:    ${rootDir}`);
+  console.log(`  poll:   ${pollSeconds ?? 3}s`);
+  if (pidfilePath) console.log(`  pid:    ${process.pid}  ${kleur.dim(`(${pidfilePath})`)}`);
+  console.log(kleur.dim("  press ctrl+c to stop"));
+}
+async function runInit(flags2) {
+  const json = flags2.get("json") === true;
+  const name = flags2.get("name");
+  const ownerUserId = flags2.get("owner-user-id");
+  if (!name) {
+    if (json) printJsonError("missing_flag", "--name is required");
+    else console.error(kleur.red("error:"), "--name is required");
+    process.exit(2);
+  }
+  if (!ownerUserId) {
+    if (json) printJsonError("missing_flag", "--owner-user-id is required (placeholder until Clerk)");
+    else console.error(kleur.red("error:"), "--owner-user-id is required (placeholder until Phase 3 / Clerk)");
+    process.exit(2);
+  }
+  const rootDir = resolve(flags2.get("dir") ?? process.cwd());
+  const relayUrl = flags2.get("relay") ?? "http://127.0.0.1:4030";
+  const deviceLabel = flags2.get("device-label");
+  let result;
+  try {
+    result = await init({ rootDir, relayUrl, ownerUserId, bindingName: name, deviceLabel });
+  } catch (err) {
+    if (err instanceof AlreadyInitializedError) {
+      if (json) printJsonError("already_initialized", err.message);
+      else {
+        console.error(kleur.red("error:"), err.message);
+        console.error(kleur.dim("  to resume an incomplete init or sync this rig, run `tapd start`."));
+      }
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (json) {
+    printJson({
+      protocolVersion: PROTOCOL_VERSION,
+      bindingId: result.binding.id,
+      bindingName: result.binding.name,
+      deviceId: result.device.id,
+      deviceLabel: result.device.label,
+      relayUrl,
+      ownerSecret: result.ownerSecret,
+      uploadedHashes: result.uploadedHashes,
+      reusedHashes: result.reusedHashes,
+      submittedEvents: result.submittedEvents,
+      cursor: result.cursor,
+      warnings: result.warnings
+    });
+    return;
+  }
+  const C = kleur;
+  console.log(C.bold().cyan("tapd init"));
+  console.log(`  binding:  ${C.bold(result.binding.id)}  ${C.dim(result.binding.name)}`);
+  console.log(`  device:   ${C.bold(result.device.id)}  ${C.dim(result.device.label)}`);
+  console.log(`  relay:    ${relayUrl}`);
+  console.log(`  uploaded: ${result.uploadedHashes} new + ${result.reusedHashes} reused`);
+  console.log(`  events:   ${result.submittedEvents} submitted, cursor ${result.cursor}`);
+  if (result.warnings.length > 0) {
+    console.log(C.yellow(`  warnings: ${result.warnings.length}`));
+    for (const w of result.warnings.slice(0, 10)) {
+      console.log(C.dim(`    ${w.reason.padEnd(13)} ${w.path}`));
+    }
+    if (result.warnings.length > 10) {
+      console.log(C.dim(`    \u2026 and ${result.warnings.length - 10} more`));
+    }
+  }
+  console.log("");
+  console.log(C.bold("  Owner capability token (shown once):"));
+  console.log(`    ${C.green(result.ownerSecret)}`);
+  console.log(C.dim(`    Stored in ${rootDir}/.rig/tap-binding.local.json (mode 0600).`));
+}
+function parseFlagsWithPositional(argv) {
+  const flags2 = /* @__PURE__ */ new Map();
+  const positional2 = [];
+  let command2;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) flags2.set(a.slice(2, eq), a.slice(eq + 1));
+      else {
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags2.set(a.slice(2), next);
+          i++;
+        } else {
+          flags2.set(a.slice(2), true);
+        }
+      }
+    } else if (!command2) {
+      command2 = a;
+    } else {
+      positional2.push(a);
+    }
+  }
+  return { command: command2, positional: positional2, flags: flags2 };
+}
+var { command, positional, flags } = parseFlagsWithPositional(process.argv.slice(2));
+if (flags.get("version") === true || command === "-v") {
+  process.stdout.write(TAPD_VERSION + "\n");
+  process.exit(0);
+}
+(async () => {
+  switch (command) {
+    case "init":
+      await runInit(flags);
+      return;
+    case "invite":
+      await runInvite(positional, flags);
+      return;
+    case "join":
+      await runJoin(positional, flags);
+      return;
+    case "start":
+      await runStart(flags);
+      return;
+    case "status":
+      await runStatus(flags);
+      return;
+    case "uninit":
+      await runUninit(flags);
+      return;
+    case "help":
+    case void 0:
+      help();
+      return;
+    default:
+      console.error(`unknown command: ${command}`);
+      help();
+      process.exit(2);
+  }
+})().catch((err) => {
+  console.error(kleur.red("fatal:"), err);
+  process.exit(1);
+});
+//# sourceMappingURL=bin.js.map