@wspc/cli 0.0.23 → 0.1.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command65 } from "commander";
+import { Command as Command66 } from "commander";
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 
@@ -37,7 +37,7 @@ function createSseClient({
   ...options
 }) {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3e3;
     let attempt = 0;
@@ -1432,9 +1432,9 @@ function createConsistencyFetch(opts) {
 }
 
 // src/version.ts
-var VERSION = "0.0.23";
+var VERSION = "0.1.1";
 var SPEC_SHA = "51d0418e";
-var SPEC_FETCHED_AT = "2026-06-21T04:09:00.455Z";
+var SPEC_FETCHED_AT = "2026-06-21T12:30:00.342Z";
 var API_BASE = "https://api.wspc.ai";
 
 // src/index.ts
@@ -4746,14 +4746,14 @@ async function hashDriveFile(path) {
         }
       }
     }
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve5, reject) => {
       const stream = fileHandle.createReadStream();
       stream.on("error", reject);
       stream.on("data", (chunk) => {
         hash.update(chunk);
         sizeBytes += chunk.length;
       });
-      stream.on("end", () => resolve4());
+      stream.on("end", () => resolve5());
     });
     return {
       sizeBytes,
@@ -5233,11 +5233,170 @@ function isAlreadyExistsError(error) {
   return error instanceof Error && "code" in error && error.code === "EEXIST";
 }
 
+// src/handwritten/commands/drive/watch.ts
+import { Command as Command65 } from "commander";
+import chokidar from "chokidar";
+import { relative as relative2, resolve as resolve4 } from "path";
+async function runDriveWatch(root, options = {}) {
+  const runSync = options.runSync ?? runDriveSyncOnce;
+  const debounceMs = options.debounceMs ?? 500;
+  const emit = options.onEvent ?? ((event) => render({ kind: "drive_watch", display: { shape: "object" } }, event));
+  let debounceTimer;
+  let retryTimer;
+  let resolveRetryTimer;
+  let running = false;
+  let rerunRequested = false;
+  let backoffMs = 1e3;
+  let stopped = false;
+  let stopWatch;
+  let stopError;
+  let cleanupSignalListeners = () => {
+  };
+  async function requestSync() {
+    if (stopped) return;
+    if (running) {
+      rerunRequested = true;
+      return;
+    }
+    running = true;
+    try {
+      do {
+        rerunRequested = false;
+        try {
+          const summary = await runSync(root);
+          emit({ kind: "drive_sync_once", ...summary });
+          backoffMs = 1e3;
+        } catch (error) {
+          if (isAuthError(error) || isFatalWatchError(error) || !isRetryableWatchError(error)) throw error;
+          emit({ kind: "drive_watch_retry", delay_ms: backoffMs, error: errorMessage2(error) });
+          await waitForManagedTimer(backoffMs);
+          if (stopped) return;
+          backoffMs = Math.min(backoffMs * 2, 6e4);
+          rerunRequested = true;
+        }
+      } while (rerunRequested && !stopped);
+    } finally {
+      running = false;
+    }
+  }
+  function clearDebounceTimer() {
+    if (debounceTimer === void 0) return;
+    clearTimeout(debounceTimer);
+    debounceTimer = void 0;
+  }
+  function clearRetryTimer() {
+    if (retryTimer === void 0) return;
+    clearTimeout(retryTimer);
+    retryTimer = void 0;
+    resolveRetryTimer?.();
+    resolveRetryTimer = void 0;
+  }
+  function waitForManagedTimer(ms) {
+    clearRetryTimer();
+    return new Promise((resolve5) => {
+      resolveRetryTimer = resolve5;
+      retryTimer = setTimeout(() => {
+        retryTimer = void 0;
+        resolveRetryTimer = void 0;
+        resolve5();
+      }, ms);
+    });
+  }
+  function stopWithError(error) {
+    stopError = error;
+    clearDebounceTimer();
+    clearRetryTimer();
+    stopWatch?.();
+  }
+  const state = await (options.readState ?? readDriveState)(root);
+  const source = options.source ?? createChokidarSource(root);
+  try {
+    source.onChange((path) => {
+      if (isDriveInternalPath(root, path)) return;
+      if (running) {
+        rerunRequested = true;
+        return;
+      }
+      clearDebounceTimer();
+      debounceTimer = setTimeout(() => {
+        debounceTimer = void 0;
+        requestSync().catch(stopWithError);
+      }, debounceMs);
+    });
+    emit({ kind: "drive_watch_started", root, library_id: state.library_id });
+    await requestSync();
+    if (options.once) return;
+    if (stopError !== void 0) throw stopError;
+    await waitForStopSignal((stop, removeListeners) => {
+      stopWatch = stop;
+      cleanupSignalListeners = removeListeners;
+    });
+    if (stopError !== void 0) throw stopError;
+  } finally {
+    stopped = true;
+    clearDebounceTimer();
+    clearRetryTimer();
+    cleanupSignalListeners();
+    await source.close();
+  }
+}
+function driveWatchCommand(options = {}) {
+  return new Command65("watch").description("Watch a bound Drive folder and sync local changes").argument("[path]", "local folder path", ".").action(async (path) => {
+    await runDriveWatch(resolve4(path), options);
+  });
+}
+function createChokidarSource(root) {
+  const watcher = chokidar.watch(root, {
+    ignoreInitial: true,
+    ignored: (path) => isDriveInternalPath(root, path)
+  });
+  return {
+    onChange(handler) {
+      watcher.on("all", (_event, path) => handler(path));
+    },
+    async close() {
+      await watcher.close();
+    }
+  };
+}
+function isDriveInternalPath(root, path) {
+  const rel = relative2(root, path);
+  return rel === DRIVE_DIR || rel.startsWith(`${DRIVE_DIR}/`) || rel.startsWith(`${DRIVE_DIR}\\`);
+}
+function isAuthError(error) {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  const message = errorMessage2(error);
+  return code === "WSPC_AUTH_EXPIRED" || /\b(401|403|auth|authorization)\b/i.test(message);
+}
+function isFatalWatchError(error) {
+  return /unsupported .*state\.json schema|sync lock already exists/i.test(errorMessage2(error));
+}
+function isRetryableWatchError(error) {
+  const status = typeof error === "object" && error !== null ? error.status : void 0;
+  const message = errorMessage2(error);
+  return status === 429 || typeof status === "number" && status >= 500 || /\b(429|5\d\d|network|temporary|fetch)\b/i.test(message);
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function waitForStopSignal(onRegistered) {
+  return new Promise((resolveStop) => {
+    const stop = () => resolveStop();
+    const cleanup = () => {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    };
+    onRegistered(stop, cleanup);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+
 // src/cli.ts
 function mountDriveCommands(program) {
   let drive = program.commands.find((c) => c.name() === "drive");
   if (!drive) {
-    drive = new Command65("drive").description("Drive commands");
+    drive = new Command66("drive").description("Drive commands");
     program.addCommand(drive);
   }
   if (!drive.commands.some((c) => c.name() === "bind")) {
@@ -5250,6 +5409,9 @@ function mountDriveCommands(program) {
     const once = driveSyncCommand().commands.find((c) => c.name() === "once");
     if (once) sync.addCommand(once);
   }
+  if (!drive.commands.some((c) => c.name() === "watch")) {
+    drive.addCommand(driveWatchCommand());
+  }
 }
 function isCliEntrypoint(argv = process.argv, metaUrl = import.meta.url) {
   if (!argv[1]) return false;
@@ -5260,7 +5422,7 @@ function isCliEntrypoint(argv = process.argv, metaUrl = import.meta.url) {
   }
 }
 function buildProgram() {
-  const program = new Command65().name("wspc").description("Official CLI for wspc.ai").version(`wspc ${VERSION} (spec ${SPEC_SHA}, fetched ${SPEC_FETCHED_AT})`).option("--json", "Output raw JSON (machine-readable)").option("--account <email>", "Run as a specific account (overrides the active account)").hook("preAction", (_thisCommand, actionCommand) => {
+  const program = new Command66().name("wspc").description("Official CLI for wspc.ai").version(`wspc ${VERSION} (spec ${SPEC_SHA}, fetched ${SPEC_FETCHED_AT})`).option("--json", "Output raw JSON (machine-readable)").option("--account <email>", "Run as a specific account (overrides the active account)").hook("preAction", (_thisCommand, actionCommand) => {
     const globals = actionCommand.optsWithGlobals();
     if (globals.json) process.env.WSPC_OUTPUT = "json";
     if (globals.account) process.env.WSPC_ACCOUNT = String(globals.account);