@wspc/cli 0.0.22 → 0.0.23

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command63 } from "commander";
+import { Command as Command65 } from "commander";
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
 
 // src/generated/cli/invite/accept.ts
 import { Command } from "commander";
@@ -35,7 +37,7 @@ function createSseClient({
   ...options
 }) {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3e3;
     let attempt = 0;
@@ -928,6 +930,25 @@ var eventIcsDownload = (options) => (options.client ?? client).get({
   url: "/calendar/events/{filename}",
   ...options
 });
+var driveFileDelete = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drive/libraries/{id}/files/delete",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var driveLibraryGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drive/libraries/{id}",
+  ...options
+});
+var driveManifestGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drive/libraries/{id}/manifest",
+  ...options
+});
 var emailAliasList = (options) => (options?.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/email/aliases",
@@ -1177,7 +1198,7 @@ var V1_CRED_KEYS = [
   "actor",
   "agent_label"
 ];
-var CONSISTENCY_BOOKMARK_SERVICES = ["auth", "todo", "calendar", "email", "push"];
+var CONSISTENCY_BOOKMARK_SERVICES = ["auth", "todo", "calendar", "drive", "email", "push"];
 function normalizeConsistencyBookmarks(raw) {
   if (typeof raw !== "object" || raw === null) return void 0;
   const out = {};
@@ -1318,6 +1339,7 @@ var SERVICE_HEADERS = {
   auth: "x-cb-auth",
   todo: "x-cb-todo",
   calendar: "x-cb-cal",
+  drive: "x-cb-drive",
   email: "x-cb-email",
   push: "x-cb-push"
 };
@@ -1384,7 +1406,7 @@ function createConsistencyFetch(opts) {
       const value = response.headers.get(header);
       return value ? [[serviceName, value]] : [];
     });
-    const shouldCheckInvalidBookmark = injectedBookmarks.length > 0;
+    const shouldCheckInvalidBookmark = injectedBookmarks.length > 0 && !response.ok;
     const invalidBookmark = shouldCheckInvalidBookmark ? await responseHasInvalidBookmark(response) : false;
     if (nextBookmarks.length === 0 && !invalidBookmark) return response;
     await opts.store.update((config) => {
@@ -1410,9 +1432,9 @@ function createConsistencyFetch(opts) {
 }
 
 // src/version.ts
-var VERSION = "0.0.22";
-var SPEC_SHA = "a2dfa511";
-var SPEC_FETCHED_AT = "2026-06-20T14:16:47.131Z";
+var VERSION = "0.0.23";
+var SPEC_SHA = "51d0418e";
+var SPEC_FETCHED_AT = "2026-06-21T04:09:00.455Z";
 var API_BASE = "https://api.wspc.ai";
 
 // src/index.ts
@@ -1559,6 +1581,17 @@ function buildInterceptor(store, resolved, fetchImpl) {
   });
 }
 async function loadSdkClient(opts = {}) {
+  const { _rawClient } = await loadClientParts(opts);
+  return { _rawClient };
+}
+async function loadAuthedFetch(opts = {}) {
+  const { fetch: fetch2, baseUrl } = await loadClientParts(opts);
+  return { fetch: fetch2, baseUrl };
+}
+async function loadSdkClientWithAuthedFetch(opts = {}) {
+  return loadClientParts(opts);
+}
+async function loadClientParts(opts = {}) {
   const store = opts.store ?? new ConfigStore();
   const config = await store.read();
   const resolved = resolveAccount(config, { accountOverride: process.env.WSPC_ACCOUNT });
@@ -1569,27 +1602,14 @@ async function loadSdkClient(opts = {}) {
     fetchImpl: opts.fetchImpl
   });
   const interceptor = buildInterceptor(store, resolved, consistencyFetch);
+  const authedFetch = (input, init) => interceptor.execute(new Request(input, init));
   const rawClient = createClient(
     createConfig({
       baseUrl: resolved.apiBase,
-      fetch: ((input, init) => interceptor.execute(new Request(input, init)))
+      fetch: authedFetch
     })
   );
-  return { _rawClient: rawClient };
-}
-async function loadAuthedFetch(opts = {}) {
-  const store = opts.store ?? new ConfigStore();
-  const config = await store.read();
-  const resolved = resolveAccount(config, { accountOverride: process.env.WSPC_ACCOUNT });
-  const consistencyFetch = createConsistencyFetch({
-    store,
-    envName: resolved.envName,
-    apiBase: resolved.apiBase,
-    fetchImpl: opts.fetchImpl
-  });
-  const interceptor = buildInterceptor(store, resolved, consistencyFetch);
-  const authedFetch = (input, init) => interceptor.execute(new Request(input, init));
-  return { fetch: authedFetch, baseUrl: resolved.apiBase };
+  return { _rawClient: rawClient, fetch: authedFetch, baseUrl: resolved.apiBase };
 }
 
 // src/handwritten/output/primitives.ts
@@ -1754,12 +1774,12 @@ function wrapToWidth(text, width) {
         out.push(head);
         word = word.slice(head.length);
       }
-      const sep = cur ? " " : "";
-      if (cur && visibleWidth(cur + sep + word) > limit) {
+      const sep2 = cur ? " " : "";
+      if (cur && visibleWidth(cur + sep2 + word) > limit) {
         out.push(cur);
         cur = word;
       } else {
-        cur = cur + sep + word;
+        cur = cur + sep2 + word;
       }
     }
     if (cur) out.push(cur);
@@ -1779,11 +1799,11 @@ function table(headers, rows) {
     }
     return w;
   });
-  const sep = "  ";
+  const sep2 = "  ";
   const lines = [];
-  lines.push(headers.map((h, i) => dim(padEndVisible(h, widths[i] ?? 0))).join(sep));
+  lines.push(headers.map((h, i) => dim(padEndVisible(h, widths[i] ?? 0))).join(sep2));
   for (const r of rows) {
-    lines.push(r.map((c, i) => padEndVisible(c ?? "", widths[i] ?? 0)).join(sep));
+    lines.push(r.map((c, i) => padEndVisible(c ?? "", widths[i] ?? 0)).join(sep2));
   }
   return lines.join("\n") + "\n";
 }
@@ -4274,9 +4294,973 @@ var attachmentCommand = new Command62("attachment").description("Download an inb
 `);
 });
 
+// src/handwritten/commands/drive/bind.ts
+import { Command as Command63 } from "commander";
+import { stat as stat2 } from "fs/promises";
+import { resolve } from "path";
+
+// src/handwritten/commands/drive/api.ts
+function asError(result) {
+  const message = JSON.stringify(result.error ?? "request failed");
+  return new Error(`HTTP ${result.response?.status ?? "?"}: ${message}`);
+}
+async function expectJsonResult(result) {
+  if (result.error || !result.response?.ok) throw asError(result);
+  if (result.data == null) throw new Error("empty response");
+  return result.data;
+}
+function driveContentUrl(baseUrl, id) {
+  const baseWithTrailingSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  return new URL(`drive/libraries/${encodeURIComponent(id)}/files/content`, baseWithTrailingSlash);
+}
+async function createDriveApi(opts = {}) {
+  const client2 = await loadSdkClientWithAuthedFetch(opts);
+  const rawClient = client2._rawClient;
+  return {
+    async getLibrary(id) {
+      const result = await driveLibraryGet({
+        client: rawClient,
+        path: { id }
+      });
+      return expectJsonResult(result);
+    },
+    async getManifest(id, cursor) {
+      const result = await driveManifestGet({
+        client: rawClient,
+        path: { id },
+        ...cursor ? { query: { cursor } } : {}
+      });
+      return expectJsonResult(result);
+    },
+    async deleteFile(id, path, expectedEntryVersion) {
+      const result = await driveFileDelete({
+        client: rawClient,
+        path: { id },
+        body: {
+          path,
+          expected_entry_version: expectedEntryVersion
+        }
+      });
+      return expectJsonResult(result);
+    },
+    async uploadFile(id, path, body, sha256, expectedEntryVersion) {
+      const url = driveContentUrl(client2.baseUrl, id);
+      url.searchParams.set("path", path);
+      if (expectedEntryVersion !== void 0) {
+        url.searchParams.set("expected_entry_version", String(expectedEntryVersion));
+      }
+      const res = await client2.fetch(url, {
+        method: "PUT",
+        headers: {
+          "content-type": "application/octet-stream",
+          "x-drive-content-sha256": sha256
+        },
+        body
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
+      }
+      const payload = await res.json();
+      if (payload === void 0 || payload === null) {
+        throw new Error("empty response");
+      }
+      return payload;
+    },
+    async downloadFile(id, path) {
+      const url = driveContentUrl(client2.baseUrl, id);
+      url.searchParams.set("path", path);
+      const res = await client2.fetch(url, { method: "GET" });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
+      }
+      return res;
+    }
+  };
+}
+
+// src/handwritten/commands/drive/state.ts
+import { mkdir, open, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { join as join2 } from "path";
+var DRIVE_DIR = ".wspc-drive";
+var STATE_FILE = "state.json";
+function statePath(root) {
+  return join2(root, DRIVE_DIR, STATE_FILE);
+}
+async function readDriveState(root) {
+  const buf = await readFile2(statePath(root), "utf8");
+  const parsed = JSON.parse(buf);
+  if (!isValidDriveState(parsed)) {
+    throw new Error("unsupported .wspc-drive/state.json schema");
+  }
+  return parsed;
+}
+async function writeDriveState(root, state) {
+  await mkdir(join2(root, DRIVE_DIR), { recursive: true });
+  const tmp = join2(root, DRIVE_DIR, `state.json.tmp-${process.pid}-${randomUUID()}`);
+  const snapshot = JSON.stringify(
+    {
+      ...state,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    null,
+    2
+  ) + "\n";
+  const fullPath = statePath(root);
+  try {
+    await writeFile(tmp, snapshot, { mode: 384 });
+    const fh = await open(tmp, "r");
+    try {
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await rename(tmp, fullPath);
+  } finally {
+    await rm(tmp, { force: true });
+  }
+}
+async function initDriveState(root, libraryId) {
+  await mkdir(join2(root, DRIVE_DIR), { recursive: true });
+  try {
+    const existing = await readDriveState(root);
+    if (existing.library_id !== libraryId) {
+      throw new Error(`folder already bound to ${existing.library_id}`);
+    }
+    return existing;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    schema_version: 1,
+    library_id: libraryId,
+    created_at: now,
+    updated_at: now,
+    entries: {},
+    conflicts: {}
+  };
+  await writeDriveState(root, state);
+  return state;
+}
+async function withDriveLock(root, fn) {
+  await mkdir(join2(root, DRIVE_DIR), { recursive: true });
+  const lockFile = join2(root, DRIVE_DIR, "sync.lock");
+  const fh = await open(lockFile, "wx").catch((error) => {
+    if (error.code === "EEXIST") {
+      throw new Error("sync lock already exists");
+    }
+    throw error;
+  });
+  try {
+    return await fn();
+  } finally {
+    await fh.close().catch(() => {
+    });
+    await rm(lockFile, { force: true }).catch(() => {
+    });
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDriveStateEntry(value) {
+  return isRecord(value) && typeof value.entry_id === "string" && typeof value.entry_version === "number" && typeof value.size_bytes === "number" && typeof value.last_synced_at === "string" && value.status === "synced" && (value.current_version_id === void 0 || typeof value.current_version_id === "string") && (value.content_sha256 === void 0 || typeof value.content_sha256 === "string") && (value.last_local_sha256 === void 0 || typeof value.last_local_sha256 === "string");
+}
+function isDriveConflict(value) {
+  return isRecord(value) && typeof value.detected_at === "string" && typeof value.reason === "string" && (value.remote_entry_version === void 0 || typeof value.remote_entry_version === "number") && (value.remote_version_id === void 0 || typeof value.remote_version_id === "string");
+}
+function isValidDriveState(value) {
+  if (!isRecord(value)) return false;
+  if (value.schema_version !== 1 || typeof value.library_id !== "string" || typeof value.created_at !== "string" || typeof value.updated_at !== "string" || !isRecord(value.entries) || !isRecord(value.conflicts)) {
+    return false;
+  }
+  for (const entry of Object.values(value.entries)) {
+    if (!isDriveStateEntry(entry)) return false;
+  }
+  for (const conflict2 of Object.values(value.conflicts)) {
+    if (!isDriveConflict(conflict2)) return false;
+  }
+  return true;
+}
+
+// src/handwritten/commands/drive/bind.ts
+async function assertExistingDirectory(path) {
+  let stats;
+  try {
+    stats = await stat2(path);
+  } catch {
+    throw new Error(`local folder does not exist: ${path}`);
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`local path is not a folder: ${path}`);
+  }
+}
+function driveBindCommand() {
+  return new Command63("bind").description("Bind a local folder to an existing Drive library").requiredOption("--library <id>", "existing Drive library id").argument("[path]", "local folder path", ".").action(async (path, opts) => {
+    const root = resolve(path);
+    await assertExistingDirectory(root);
+    const api = await createDriveApi();
+    const library = await api.getLibrary(opts.library);
+    const state = await initDriveState(root, opts.library);
+    render(
+      { kind: "drive_bind", display: { shape: "object" } },
+      {
+        root,
+        library_id: state.library_id,
+        library_name: library.name
+      }
+    );
+  });
+}
+
+// src/handwritten/commands/drive/sync.ts
+import { Command as Command64 } from "commander";
+import { createWriteStream as createWriteStream2 } from "fs";
+import { link, mkdir as mkdir2, readFile as readFile3, rename as rename2, rm as rm2, unlink } from "fs/promises";
+import { basename as basename2, dirname, join as join4, resolve as resolve3 } from "path";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { Readable as Readable2, Transform } from "stream";
+import { pipeline as pipeline2 } from "stream/promises";
+
+// src/handwritten/commands/drive/decision.ts
+function decideDriveAction(entry, local, remote) {
+  if (!entry) return decideWithoutBase(local, remote);
+  if (!local && !remote) return { type: "remove_state" };
+  const localStatus = getLocalStatus(entry, local);
+  const remoteStatus = getRemoteStatus(entry, remote);
+  if (!remote) return decideRemoteMissing(localStatus);
+  if (!local) return decideLocalMissing(entry, remoteStatus);
+  return decideBothPresent(entry, localStatus, remoteStatus);
+}
+function decideWithoutBase(local, remote) {
+  if (local && !remote) return { type: "upload_create", expectedEntryVersion: 0 };
+  if (!local && remote) {
+    return remote.entry_version === void 0 ? { type: "conflict", reason: "remote_missing_entry_version" } : { type: "download" };
+  }
+  if (local && remote) {
+    if (remote.entry_version === void 0) return { type: "conflict", reason: "remote_missing_entry_version" };
+    return remote.content_sha256 !== void 0 && local.sha256 === remote.content_sha256 ? { type: "state_only" } : { type: "conflict", reason: "local_and_remote_without_base" };
+  }
+  return { type: "unchanged" };
+}
+function decideRemoteMissing(localStatus) {
+  if (localStatus === "unchanged") return { type: "delete_local" };
+  if (localStatus === "unknown") return { type: "conflict", reason: "unknown_local_base_remote_deleted" };
+  return { type: "conflict", reason: "local_changed_remote_deleted" };
+}
+function decideLocalMissing(entry, remoteStatus) {
+  if (remoteStatus === "unchanged") return { type: "delete_remote", expectedEntryVersion: entry.entry_version };
+  return { type: "conflict", reason: "remote_changed_before_delete" };
+}
+function decideBothPresent(entry, localStatus, remoteStatus) {
+  if (localStatus === "unchanged" && remoteStatus === "content_same_new_version") {
+    return { type: "state_only" };
+  }
+  if (remoteStatus === "missing_version") {
+    return { type: "conflict", reason: "remote_missing_entry_version" };
+  }
+  if (localStatus === "unknown" && remoteStatus !== "unchanged") {
+    return { type: "conflict", reason: "unknown_local_base_remote_changed" };
+  }
+  if (localStatus === "unknown") return { type: "conflict", reason: "unknown_local_base" };
+  if (localStatus === "unchanged" && remoteStatus === "changed") return { type: "download" };
+  if (localStatus === "changed" && remoteStatus === "unchanged") {
+    return { type: "upload_update", expectedEntryVersion: entry.entry_version };
+  }
+  if (localStatus !== "unchanged" && remoteStatus !== "unchanged") {
+    return { type: "conflict", reason: "local_and_remote_changed" };
+  }
+  return { type: "unchanged" };
+}
+function getLocalStatus(entry, local) {
+  if (!local) return "changed";
+  if (entry.last_local_sha256 !== void 0) {
+    return local.sha256 === entry.last_local_sha256 ? "unchanged" : "changed";
+  }
+  if (entry.content_sha256 !== void 0) {
+    return local.sha256 === entry.content_sha256 ? "unchanged" : "changed";
+  }
+  return "unknown";
+}
+function getRemoteStatus(entry, remote) {
+  if (!remote) return "changed";
+  if (remote.entry_version !== void 0 && remote.entry_version === entry.entry_version) return "unchanged";
+  if (remote.entry_version === void 0) return "missing_version";
+  if (remote.content_sha256 !== void 0 && entry.content_sha256 !== void 0 && remote.content_sha256 === entry.content_sha256) {
+    return "content_same_new_version";
+  }
+  return "changed";
+}
+
+// src/handwritten/commands/drive/path-policy.ts
+import { isAbsolute, relative, resolve as resolve2, sep } from "path";
+var UTF8_SEGMENT_LIMIT = 255;
+var UTF8_PATH_LIMIT = 1024;
+var CONTROL_CHARS = /[\0-\x1f\x7f]/;
+var WINDOWS_DRIVE_PREFIX = /^[a-zA-Z]:/;
+var UNC_PREFIX = /^\\\\/;
+var ABSOLUTE_POSIX_DOUBLE_SLASH = /^\/\//;
+function validateDrivePath(drivePath) {
+  if (drivePath.length === 0) {
+    throw new Error("invalid drive path: empty");
+  }
+  if (isAbsolute(drivePath) || ABSOLUTE_POSIX_DOUBLE_SLASH.test(drivePath)) {
+    throw new Error(`invalid drive path: ${drivePath}`);
+  }
+  if (drivePath.includes("\\")) {
+    throw new Error("invalid drive path: backslash");
+  }
+  if (WINDOWS_DRIVE_PREFIX.test(drivePath) || UNC_PREFIX.test(drivePath)) {
+    throw new Error(`invalid drive path: ${drivePath}`);
+  }
+  if (CONTROL_CHARS.test(drivePath)) {
+    throw new Error(`invalid drive path: control character`);
+  }
+  if (Buffer.byteLength(drivePath, "utf8") > UTF8_PATH_LIMIT) {
+    throw new Error(`invalid drive path: exceeds ${UTF8_PATH_LIMIT} bytes`);
+  }
+  const segments = drivePath.split("/");
+  if (segments.some((segment) => segment.length === 0)) {
+    throw new Error("invalid drive path: empty segment");
+  }
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error("invalid drive path: relative segment");
+  }
+  if (segments.some((segment) => Buffer.byteLength(segment, "utf8") > UTF8_SEGMENT_LIMIT)) {
+    throw new Error(`invalid drive path: segment exceeds ${UTF8_SEGMENT_LIMIT} bytes`);
+  }
+  return drivePath;
+}
+function resolveInsideRoot(root, drivePath) {
+  const normalizedPath = validateDrivePath(drivePath);
+  const absoluteRoot = resolve2(root);
+  const absolutePath = resolve2(absoluteRoot, normalizedPath);
+  const relativePath = relative(absoluteRoot, absolutePath);
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`)) {
+    throw new Error(`drive path escapes root: ${drivePath}`);
+  }
+  return absolutePath;
+}
+
+// src/handwritten/commands/drive/scanner.ts
+import { createHash } from "crypto";
+import { constants as fsConstants } from "fs";
+import { open as open2, readdir, lstat } from "fs/promises";
+import { join as join3 } from "path";
+async function scanDriveFiles(root, options = {}) {
+  const candidates = [];
+  const files = {};
+  const absRoot = root;
+  await walk(absRoot, "");
+  await addNonCollidingFiles(candidates);
+  return files;
+  async function walk(currentPath, currentDrivePath) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (isExcludedRootEntry(currentDrivePath, entry)) {
+        continue;
+      }
+      if (isInternalSyncArtifactName(entry.name)) {
+        continue;
+      }
+      const nextDrivePath = currentDrivePath ? `${currentDrivePath}/${entry.name}` : entry.name;
+      try {
+        validateDrivePath(nextDrivePath);
+      } catch (error) {
+        if (!options.onPathError) throw error;
+        await options.onPathError(nextDrivePath, error);
+        continue;
+      }
+      const nextPath = join3(currentPath, entry.name);
+      const stats = await lstat(nextPath);
+      if (stats.isSymbolicLink()) {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        await walk(nextPath, nextDrivePath);
+        continue;
+      }
+      if (!stats.isFile()) {
+        continue;
+      }
+      const digest = await hashDriveFile(nextPath);
+      if (!digest) {
+        continue;
+      }
+      candidates.push({ path: nextDrivePath, entry: { sha256: digest.sha256, size_bytes: digest.sizeBytes } });
+    }
+  }
+  async function addNonCollidingFiles(candidates2) {
+    const byCaseFoldedPath = /* @__PURE__ */ new Map();
+    for (const candidate of candidates2) {
+      const folded = candidate.path.toLowerCase();
+      const group = byCaseFoldedPath.get(folded) ?? [];
+      group.push(candidate);
+      byCaseFoldedPath.set(folded, group);
+    }
+    for (const group of byCaseFoldedPath.values()) {
+      if (group.length > 1) {
+        const sorted = group.sort((left, right) => left.path.localeCompare(right.path));
+        for (const candidate2 of sorted) {
+          const error = new Error(`LOCAL_PATH_CASE_CONFLICT: ${candidate2.path}`);
+          if (!options.onPathError) throw error;
+          await options.onPathError(candidate2.path, error);
+        }
+        continue;
+      }
+      const [candidate] = group;
+      if (candidate) files[candidate.path] = candidate.entry;
+    }
+  }
+  function isExcludedRootEntry(currentDrivePath, entry) {
+    return currentDrivePath === "" && entry.name === DRIVE_DIR;
+  }
+}
+function isInternalSyncArtifactName(name) {
+  if (!name.startsWith(".") || !name.endsWith(".tmp")) return false;
+  return name.includes(".wspc-download-") || name.includes(".wspc-backup-");
+}
+async function hashDriveFile(path) {
+  const useNoFollow = fsConstants.O_NOFOLLOW !== void 0;
+  const fdFlags = useNoFollow ? fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW : fsConstants.O_RDONLY;
+  const fileHandle = await open2(path, fdFlags);
+  const hash = createHash("sha256");
+  let sizeBytes = 0;
+  try {
+    const stats = await fileHandle.stat();
+    if (!stats.isFile()) {
+      return void 0;
+    }
+    if (!useNoFollow) {
+      const liveStats = await lstat(path);
+      if (!liveStats.isFile()) {
+        return void 0;
+      }
+      if (stats.ino !== void 0 && liveStats.ino !== void 0 && stats.dev !== void 0 && liveStats.dev !== void 0) {
+        if (stats.ino !== liveStats.ino || stats.dev !== liveStats.dev) {
+          return void 0;
+        }
+      }
+    }
+    await new Promise((resolve4, reject) => {
+      const stream = fileHandle.createReadStream();
+      stream.on("error", reject);
+      stream.on("data", (chunk) => {
+        hash.update(chunk);
+        sizeBytes += chunk.length;
+      });
+      stream.on("end", () => resolve4());
+    });
+    return {
+      sizeBytes,
+      sha256: hash.digest("hex")
+    };
+  } finally {
+    await fileHandle.close().catch(() => {
+    });
+  }
+}
+
+// src/handwritten/commands/drive/sync.ts
+function emptySummary() {
+  return {
+    uploaded: 0,
+    downloaded: 0,
+    deleted: 0,
+    unchanged: 0,
+    conflicts: 0,
+    errors: 0,
+    paths: []
+  };
+}
+async function runDriveSyncOnce(root, api) {
+  return withDriveLock(root, async () => {
+    let state = await readDriveState(root);
+    const syncApi = api ?? await createDriveApi();
+    const summary = emptySummary();
+    const blockedPaths = /* @__PURE__ */ new Set();
+    const localFiles = await scanDriveFiles(root, {
+      onPathError: async (path, error) => {
+        await recordPathError(summary, blockedPaths, path, error);
+      }
+    });
+    const remoteFiles = await fetchRemoteManifest(root, state, syncApi, summary, blockedPaths);
+    const paths = Array.from(
+      /* @__PURE__ */ new Set([...Object.keys(localFiles), ...Object.keys(remoteFiles), ...Object.keys(state.entries)])
+    ).filter((path) => !blockedPaths.has(path)).sort((left, right) => left.localeCompare(right));
+    for (const path of paths) {
+      const remote = remoteFiles[path];
+      const action = decideDriveAction(state.entries[path], localFiles[path], remote);
+      const result = await processPath({ root, state, api: syncApi, path, action, remote, local: localFiles[path], summary });
+      state = result.state;
+      if (result.stop) break;
+    }
+    recordUnresolvedConflicts(summary, state);
+    return summary;
+  });
+}
+function driveSyncCommand(api) {
+  const sync = new Command64("sync").description("Drive sync commands");
+  sync.command("once").description("Run one Drive sync pass").argument("[path]", "local folder path", ".").action(async (path) => {
+    const summary = await runDriveSyncOnce(resolve3(path), api);
+    render({ kind: "drive_sync_once", display: { shape: "object" } }, summary);
+    if (summary.conflicts > 0 || summary.errors > 0) {
+      process.exitCode = 1;
+    }
+  });
+  return sync;
+}
+async function fetchRemoteManifest(root, state, api, summary, blockedPaths) {
+  const candidates = [];
+  const remoteFiles = {};
+  let cursor;
+  do {
+    const page = await api.getManifest(state.library_id, cursor);
+    for (const entry of page.entries) {
+      try {
+        validateRemoteEntry(root, entry);
+        candidates.push(entry);
+      } catch (error) {
+        await recordPathError(summary, blockedPaths, entry.path, error);
+      }
+    }
+    cursor = page.next_cursor ?? void 0;
+  } while (cursor !== void 0);
+  const byCaseFoldedPath = /* @__PURE__ */ new Map();
+  for (const entry of candidates) {
+    const folded = entry.path.toLowerCase();
+    const group = byCaseFoldedPath.get(folded) ?? [];
+    group.push(entry);
+    byCaseFoldedPath.set(folded, group);
+  }
+  for (const group of byCaseFoldedPath.values()) {
+    const exactPathCounts = /* @__PURE__ */ new Map();
+    for (const entry2 of group) {
+      exactPathCounts.set(entry2.path, (exactPathCounts.get(entry2.path) ?? 0) + 1);
+    }
+    if (group.length > 1) {
+      const hasExactDuplicate = Array.from(exactPathCounts.values()).some((count) => count > 1);
+      const reason = hasExactDuplicate ? "REMOTE_PATH_DUPLICATE" : "REMOTE_PATH_CASE_CONFLICT";
+      for (const entry2 of group.sort((left, right) => left.path.localeCompare(right.path))) {
+        await recordPathError(summary, blockedPaths, entry2.path, new Error(`${reason}: ${entry2.path}`), {
+          appendPathResult: true
+        });
+      }
+      continue;
+    }
+    const [entry] = group;
+    if (entry) remoteFiles[entry.path] = entry;
+  }
+  return remoteFiles;
+}
+function validateRemoteEntry(root, entry) {
+  validateDrivePath(entry.path);
+  resolveInsideRoot(root, entry.path);
+}
+async function processPath(args) {
+  const { root, state, api, path, action, remote, local, summary } = args;
+  summary.paths.push({ path, action: action.type });
+  let durableStateRequired = false;
+  try {
+    if (action.type === "upload_create" || action.type === "upload_update") {
+      const localPath = resolveInsideRoot(root, path);
+      const { body, digest: uploadDigest } = await readStableUploadBody(localPath, local);
+      const uploaded = await api.uploadFile(state.library_id, path, body, uploadDigest, action.expectedEntryVersion);
+      durableStateRequired = true;
+      const nextState = cloneDriveState(state);
+      nextState.entries[path] = stateEntryFromRemote(uploaded.entry, uploadDigest);
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.uploaded += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "download") {
+      if (!remote) throw new Error("remote entry missing for download");
+      await assertLocalSafeForDownload(root, path, state.entries[path]);
+      const digest = await downloadRemote(root, state.library_id, path, api, remote.content_sha256, state.entries[path], () => {
+        durableStateRequired = true;
+      });
+      const nextState = cloneDriveState(state);
+      nextState.entries[path] = stateEntryFromRemote(remote, digest);
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.downloaded += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "delete_remote") {
+      await assertLocalAbsentBeforeRemoteDelete(root, path);
+      await api.deleteFile(state.library_id, path, action.expectedEntryVersion);
+      durableStateRequired = true;
+      await assertLocalAbsentBeforeRemoteDelete(root, path);
+      const nextState = cloneDriveState(state);
+      delete nextState.entries[path];
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.deleted += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "delete_local") {
+      await removeLocalIfStillBase(root, path, state.entries[path], () => {
+        durableStateRequired = true;
+      });
+      const nextState = cloneDriveState(state);
+      delete nextState.entries[path];
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.deleted += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "state_only") {
+      if (!remote) throw new Error("remote entry missing for state update");
+      const nextState = cloneDriveState(state);
+      nextState.entries[path] = stateEntryFromRemote(remote, local?.sha256 ?? remote.content_sha256);
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.unchanged += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "remove_state") {
+      const nextState = cloneDriveState(state);
+      delete nextState.entries[path];
+      delete nextState.conflicts[path];
+      await commitDriveState(root, nextState);
+      summary.unchanged += 1;
+      return { state: nextState, stop: false };
+    }
+    if (action.type === "conflict") {
+      const nextState = await recordConflict(root, state, path, action.reason, remote);
+      summary.conflicts += 1;
+      return { state: nextState, stop: false };
+    }
+    summary.unchanged += 1;
+  } catch (error) {
+    if (isVersionConflict(error)) {
+      try {
+        const nextState = await recordConflict(root, state, path, "VERSION_CONFLICT", remote);
+        summary.conflicts += 1;
+        summary.paths[summary.paths.length - 1] = { path, action: "conflict" };
+        return { state: nextState, stop: false };
+      } catch (writeError) {
+        await recordPathError(summary, void 0, path, writeError);
+        return { state, stop: durableStateRequired };
+      }
+    }
+    await recordPathError(summary, void 0, path, error);
+    return { state, stop: durableStateRequired };
+  }
+  return { state, stop: false };
+}
+function recordUnresolvedConflicts(summary, state) {
+  const newlyRecorded = new Set(summary.paths.filter((result) => result.action === "conflict").map((result) => result.path));
+  const reportedPaths = new Set(summary.paths.map((result) => result.path));
+  for (const path of Object.keys(state.conflicts).sort((left, right) => left.localeCompare(right))) {
+    if (!newlyRecorded.has(path)) {
+      summary.conflicts += 1;
+    }
+    const existingResult = summary.paths.find((result) => result.path === path);
+    if (existingResult?.action === "unchanged") {
+      existingResult.action = "conflict";
+      continue;
+    }
+    if (!reportedPaths.has(path)) {
+      summary.paths.push({ path, action: "conflict" });
+    }
+  }
+}
+async function downloadRemote(root, libraryId, path, api, expectedSha256, entry, onLocalMutation) {
+  const target = resolveInsideRoot(root, path);
+  await mkdir2(dirname(target), { recursive: true });
+  const tmp = join4(dirname(target), `.${basename2(target)}.wspc-download-${randomUUID2()}.tmp`);
+  try {
+    const response = await api.downloadFile(libraryId, path);
+    if (!response.body) {
+      throw new Error("download response body missing");
+    }
+    const hash = createHash2("sha256");
+    const hashingStream = new Transform({
+      transform(chunk, _encoding, callback) {
+        hash.update(chunk);
+        callback(void 0, chunk);
+      }
+    });
+    await pipeline2(
+      Readable2.fromWeb(response.body),
+      hashingStream,
+      createWriteStream2(tmp, { flags: "wx" })
+    );
+    const digest = hash.digest("hex");
+    if (expectedSha256 !== void 0 && digest !== expectedSha256) {
+      throw new Error(`download hash mismatch: expected ${expectedSha256}, got ${digest}`);
+    }
+    await installDownloadedFile(root, path, tmp, entry, onLocalMutation);
+    return digest;
+  } finally {
+    await rm2(tmp, { force: true }).catch(() => {
+    });
+  }
+}
+async function installDownloadedFile(root, path, tmp, entry, onLocalMutation) {
+  const target = resolveInsideRoot(root, path);
+  const backup = localMutationBackupPath(target);
+  const expectedSha256 = expectedLocalBaseSha256(entry);
+  let backupIsExpectedBase = false;
+  try {
+    try {
+      await rename2(target, backup);
+      onLocalMutation();
+    } catch (error) {
+      if (!isNotFoundError(error)) throw error;
+      await installNoOverwrite(tmp, target, onLocalMutation);
+      return;
+    }
+    const backupDigest = await hashDriveFile(backup);
+    if (!backupDigest) {
+      await restoreBackupWhenPossible(backup, target);
+      throw new Error("local file changed before download");
+    }
+    if (!expectedSha256 || backupDigest.sha256 !== expectedSha256) {
+      await restoreBackupWhenPossible(backup, target);
+      throw new Error("local file changed before download");
+    }
+    backupIsExpectedBase = true;
+    try {
+      await installNoOverwrite(tmp, target, onLocalMutation);
+    } catch (error) {
+      const restored = await restoreBackupWhenPossible(backup, target);
+      if (!restored && backupIsExpectedBase) {
+        await unlink(backup).catch(() => {
+        });
+      }
+      throw error;
+    }
+    await unlink(backup);
+  } catch (error) {
+    if (!backupIsExpectedBase) {
+      await restoreBackupWhenPossible(backup, target);
+    }
+    throw error;
+  }
+}
+async function removeLocalIfStillBase(root, path, entry, onLocalMutation) {
+  const target = resolveInsideRoot(root, path);
+  const backup = localMutationBackupPath(target);
+  const expectedSha256 = expectedLocalBaseSha256(entry);
+  if (!expectedSha256) {
+    throw new Error("local file has no sync base");
+  }
+  let backupIsExpectedBase = false;
+  try {
+    try {
+      await rename2(target, backup);
+      onLocalMutation();
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        throw new Error("local file changed before delete");
+      }
+      throw error;
+    }
+    const backupDigest = await hashDriveFile(backup);
+    if (!backupDigest || backupDigest.sha256 !== expectedSha256) {
+      await restoreBackupWhenPossible(backup, target);
+      throw new Error("local file changed before delete");
+    }
+    backupIsExpectedBase = true;
+    if (await localFileExists(target)) {
+      await unlink(backup).catch(() => {
+      });
+      throw new Error("local file reappeared during delete");
+    }
+    await unlink(backup);
+    if (await localFileExists(target)) {
+      throw new Error("local file reappeared during delete");
+    }
+  } catch (error) {
+    if (!backupIsExpectedBase) {
+      await restoreBackupWhenPossible(backup, target);
+    }
+    throw error;
+  }
+}
+async function installNoOverwrite(source, target, onLinked) {
+  await link(source, target);
+  onLinked?.();
+  await unlink(source);
+}
+async function restoreBackupWhenPossible(backup, target) {
+  try {
+    await installNoOverwrite(backup, target);
+    return true;
+  } catch (error) {
+    if (isAlreadyExistsError(error)) return false;
+    if (isNotFoundError(error)) return true;
+    return false;
+  }
+}
+async function localFileExists(path) {
+  const digest = await hashDriveFile(path).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  return digest !== void 0;
+}
+function localMutationBackupPath(target) {
+  return join4(dirname(target), `.${basename2(target)}.wspc-backup-${randomUUID2()}.tmp`);
+}
+function expectedLocalBaseSha256(entry) {
+  return entry?.last_local_sha256 ?? entry?.content_sha256;
+}
+async function readStableUploadBody(localPath, scanned) {
+  if (!scanned) {
+    throw new Error("local file missing from scan");
+  }
+  const snapshot = await hashDriveFile(localPath).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  if (!snapshot || snapshot.sha256 !== scanned.sha256 || snapshot.sizeBytes !== scanned.size_bytes) {
+    throw new Error("local file changed after scan");
+  }
+  const body = await readFile3(localPath).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  if (!body) {
+    throw new Error("local file changed after scan");
+  }
+  const uploadBytes = new Uint8Array(body.byteLength);
+  uploadBytes.set(body);
+  const digest = createHash2("sha256").update(uploadBytes).digest("hex");
+  if (digest !== scanned.sha256 || uploadBytes.byteLength !== scanned.size_bytes) {
+    throw new Error("local file changed after scan");
+  }
+  return { body: uploadBytes.buffer, digest };
+}
+async function assertLocalSafeForDownload(root, path, entry) {
+  const target = resolveInsideRoot(root, path);
+  const digest = await hashDriveFile(target).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  if (!digest) return;
+  if (!entry?.last_local_sha256) {
+    throw new Error("local file appeared before download");
+  }
+  if (digest.sha256 !== entry.last_local_sha256) {
+    throw new Error("local file changed before download");
+  }
+}
+async function assertLocalAbsentBeforeRemoteDelete(root, path) {
+  const digest = await hashDriveFile(resolveInsideRoot(root, path)).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  if (digest) {
+    throw new Error("local file appeared before remote delete");
+  }
+}
+function stateEntryFromRemote(remote, localSha256) {
+  return {
+    entry_id: remote.id,
+    entry_version: remote.entry_version,
+    current_version_id: remote.current_version_id,
+    content_sha256: remote.content_sha256,
+    size_bytes: remote.size_bytes,
+    last_local_sha256: localSha256,
+    last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "synced"
+  };
+}
+async function commitDriveState(root, nextState) {
+  await writeDriveState(root, nextState);
+}
+function cloneDriveState(state) {
+  return {
+    ...state,
+    entries: { ...state.entries },
+    conflicts: { ...state.conflicts }
+  };
+}
+async function recordConflict(root, state, path, reason, remote) {
+  const nextState = cloneDriveState(state);
+  nextState.conflicts[path] = conflict(reason, remote);
+  await commitDriveState(root, nextState);
+  return nextState;
+}
+async function recordPathError(summary, blockedPaths, path, error, options = {}) {
+  blockedPaths?.add(path);
+  const lastPath = summary.paths.at(-1);
+  if (!options.appendPathResult && lastPath?.path === path) {
+    lastPath.action = "error";
+  } else {
+    summary.paths.push({ path, action: "error" });
+  }
+  void errorMessage(error);
+  summary.errors += 1;
+}
+function conflict(reason, remote) {
+  return {
+    detected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    reason,
+    remote_entry_version: remote?.entry_version,
+    remote_version_id: remote?.current_version_id
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isVersionConflict(error) {
+  const structured = error;
+  if (structured?.code === "VERSION_CONFLICT") return true;
+  return [errorMessage(error), structured?.body, structured?.response?.body].some(containsVersionConflict);
+}
+function containsVersionConflict(value) {
+  if (value === void 0) return false;
+  if (typeof value === "string") return value.includes("VERSION_CONFLICT");
+  try {
+    return JSON.stringify(value).includes("VERSION_CONFLICT");
+  } catch {
+    return false;
+  }
+}
+function isNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isAlreadyExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+
 // src/cli.ts
+function mountDriveCommands(program) {
+  let drive = program.commands.find((c) => c.name() === "drive");
+  if (!drive) {
+    drive = new Command65("drive").description("Drive commands");
+    program.addCommand(drive);
+  }
+  if (!drive.commands.some((c) => c.name() === "bind")) {
+    drive.addCommand(driveBindCommand());
+  }
+  const sync = drive.commands.find((c) => c.name() === "sync");
+  if (!sync) {
+    drive.addCommand(driveSyncCommand());
+  } else if (!sync.commands.some((c) => c.name() === "once")) {
+    const once = driveSyncCommand().commands.find((c) => c.name() === "once");
+    if (once) sync.addCommand(once);
+  }
+}
+function isCliEntrypoint(argv = process.argv, metaUrl = import.meta.url) {
+  if (!argv[1]) return false;
+  try {
+    return realpathSync(argv[1]) === realpathSync(fileURLToPath(metaUrl));
+  } catch {
+    return false;
+  }
+}
 function buildProgram() {
-  const program = new Command63().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 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 globals = actionCommand.optsWithGlobals();
     if (globals.json) process.env.WSPC_OUTPUT = "json";
     if (globals.account) process.env.WSPC_ACCOUNT = String(globals.account);
@@ -4287,6 +5271,7 @@ function buildProgram() {
   program.addCommand(configCommand);
   program.addCommand(accountCommand);
   registerGeneratedCommands(program);
+  mountDriveCommands(program);
   const todo = program.commands.find((c) => c.name() === "todo");
   if (todo) todo.addCommand(todoDoneCommand);
   const email = program.commands.find((c) => c.name() === "email");
@@ -4319,8 +5304,12 @@ async function dispatch(argv, { allowRetry = true } = {}) {
     process.exitCode = 1;
   }
 }
-dispatch(process.argv);
+if (isCliEntrypoint()) {
+  dispatch(process.argv);
+}
 export {
-  dispatch
+  dispatch,
+  isCliEntrypoint,
+  mountDriveCommands
 };
 //# sourceMappingURL=cli.js.map