@skaile/workspaces 0.53.0 → 1.0.0

package/dist/chunk-RAIRWFAN.js

@@ -1,843 +0,0 @@
-import { createLogger } from './chunk-JB35MVBN.js';
-import { spawn } from 'child_process';
-import { randomBytes } from 'crypto';
-import { mkdir, chmod, writeFile, unlink, rename, cp, rm, stat, readdir, readFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import path, { relative, join } from 'path';
-import { createConnection } from 'net';
-import { existsSync, readFileSync } from 'fs';
-import chokidar from 'chokidar';
-
-async function ensureDirMode(dir, log) {
-  await mkdir(dir, { recursive: true });
-  try {
-    await chmod(dir, 504);
-  } catch (err) {
-    log?.debug("chmod 0770 skipped (EPERM \u2014 entrypoint heal expected)", {
-      path: dir,
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-var PortPool = class _PortPool {
-  min;
-  max;
-  inUse = /* @__PURE__ */ new Set();
-  constructor(range) {
-    this.min = range[0];
-    this.max = range[1];
-  }
-  /** Allocate the next free port from the range. Checks OS for collisions. */
-  async allocate() {
-    for (let port = this.min; port <= this.max; port++) {
-      if (this.inUse.has(port)) continue;
-      if (!await _PortPool.isPortFree(port)) {
-        this.inUse.add(port);
-        continue;
-      }
-      this.inUse.add(port);
-      return port;
-    }
-    throw new Error(`No free port in range ${this.min}-${this.max}`);
-  }
-  /** Mark a port as in-use (for explicit port args or registered instances). */
-  reserve(port) {
-    this.inUse.add(port);
-  }
-  /** Return a port to the pool. */
-  release(port) {
-    this.inUse.delete(port);
-  }
-  /** Check if a port is currently tracked as in-use. */
-  isInUse(port) {
-    return this.inUse.has(port);
-  }
-  /** Quick TCP connect test — returns true if nothing is listening. */
-  static isPortFree(port, host = "127.0.0.1") {
-    return new Promise((resolve) => {
-      const socket = createConnection({ port, host });
-      socket.once("connect", () => {
-        socket.destroy();
-        resolve(false);
-      });
-      socket.once("error", () => {
-        socket.destroy();
-        resolve(true);
-      });
-      socket.setTimeout(500, () => {
-        socket.destroy();
-        resolve(true);
-      });
-    });
-  }
-};
-function globToMatcher(pattern) {
-  const segmentMatch = pattern.match(/^\*\*\/([^*/?]+)\/\*\*$/);
-  if (segmentMatch) {
-    const name = segmentMatch[1];
-    return (p) => p.includes(`/${name}/`) || p.endsWith(`/${name}`) || p === name;
-  }
-  const dotSegment = pattern.match(/^\*\*\/(\.[\w#]+)(?:\/\*\*)?$/);
-  if (dotSegment) {
-    const name = dotSegment[1];
-    return (p) => p.includes(`/${name}/`) || p.endsWith(`/${name}`) || p === name;
-  }
-  const extMatch = pattern.match(/^\*\*\/\*(\.\w+(?:\.\*)?)/);
-  if (extMatch) {
-    const suffix = extMatch[1];
-    if (suffix.endsWith(".*")) {
-      const base = suffix.slice(0, -2);
-      return (p) => p.includes(base);
-    }
-    return (p) => p.endsWith(suffix);
-  }
-  const suffixMatch = pattern.match(/^\*\*\/\*(.+)$/);
-  if (suffixMatch) {
-    const sfx = suffixMatch[1];
-    return (p) => p.endsWith(sfx);
-  }
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-  const re = new RegExp(`^${escaped}$`);
-  return (p) => re.test(p);
-}
-var DEFAULT_IGNORED = [
-  (p) => p.includes("/.git/") || p.endsWith("/.git"),
-  (p) => p.includes("/node_modules/") || p.endsWith("/node_modules"),
-  (p) => p.includes("/.connectors/") || p.endsWith("/.connectors"),
-  // Atomic-write tempfiles (Bun.write creates `<name>.tmp.<pid>.<ts>` then renames).
-  // These vanish between readdir and fs.watch, causing EINVAL that crashes the process.
-  (p) => /\.tmp\.\d/.test(p),
-  // Editor swap/backup files that also race with save operations.
-  (p) => p.endsWith(".swp"),
-  (p) => p.endsWith(".swx"),
-  (p) => p.includes("/.#"),
-  (p) => p.endsWith("~")
-];
-var DEFAULT_DEBOUNCE_MS = 150;
-function parseGitignore(rootDir) {
-  const gitignorePath = join(rootDir, ".gitignore");
-  if (!existsSync(gitignorePath)) return [];
-  try {
-    const content = readFileSync(gitignorePath, "utf-8");
-    const matchers = [];
-    for (const raw of content.split("\n")) {
-      const line = raw.trim();
-      if (!line || line.startsWith("#") || line.startsWith("!")) continue;
-      let pattern = line;
-      if (pattern.startsWith("/")) {
-        pattern = pattern.slice(1);
-      } else if (!pattern.includes("/")) {
-        pattern = `**/${pattern}`;
-      }
-      if (pattern.endsWith("/")) {
-        matchers.push(globToMatcher(`${pattern}**`));
-      } else {
-        matchers.push(globToMatcher(pattern));
-        if (!pattern.includes("*") && !pattern.includes(".")) {
-          matchers.push(globToMatcher(`${pattern}/**`));
-        }
-      }
-    }
-    return matchers;
-  } catch {
-    return [];
-  }
-}
-var CHOKIDAR_EVENT_MAP = {
-  add: "create",
-  change: "edit",
-  unlink: "delete",
-  addDir: "create",
-  unlinkDir: "delete"
-};
-async function createFsWatcher(rootDir, callback, options) {
-  const log = createLogger({ kind: "connector", subkind: "watcher", instance: rootDir });
-  const gitignorePatterns = parseGitignore(rootDir);
-  const optionsIgnored = (options?.ignored ?? []).map(
-    (entry) => typeof entry === "string" ? globToMatcher(entry) : entry
-  );
-  const ignored = [...DEFAULT_IGNORED, ...gitignorePatterns, ...optionsIgnored];
-  const debounceMs = options?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  const watcher = chokidar.watch(rootDir, {
-    ignoreInitial: true,
-    ignored,
-    awaitWriteFinish: { stabilityThreshold: debounceMs, pollInterval: 50 },
-    usePolling: false
-  });
-  watcher.on("error", (err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    log.warn("watcher error (non-fatal)", { message });
-  });
-  for (const [chokidarEvent, action] of Object.entries(CHOKIDAR_EVENT_MAP)) {
-    watcher.on(
-      chokidarEvent,
-      (fullPath) => {
-        const rel = relative(rootDir, fullPath);
-        if (!rel || rel.startsWith("..")) return;
-        const normalizedPath = rel.split("\\").join("/");
-        callback({ path: normalizedPath, action, source: "filesystem" });
-      }
-    );
-  }
-  return {
-    close: () => watcher.close()
-  };
-}
-
-// connectors/src/rclone-process-manager.ts
-var RCLONE_RC_PORTS = new PortPool([55e3, 56e3]);
-var DEFAULT_VFS_WRITE_BACK = "30s";
-var DEFAULT_UPLOAD_STUCK_THRESHOLD = 3;
-var STABILIZE_THRESHOLD_MS = 1500;
-var STABILIZE_TIMEOUT_MS = 3e4;
-var STABILIZE_POLL_MS = DEFAULT_DEBOUNCE_MS;
-var HANDLES = /* @__PURE__ */ new Map();
-var RcloneProcessManager = class {
-  /**
-   * @param now Injectable clock (ms) used only to timestamp the quarantine dir
-   * on a poisoned-cache reset, so the move-aside name is deterministic in tests.
-   */
-  constructor(now = Date.now) {
-    this.now = now;
-  }
-  now;
-  /**
-   * Spawn an rclone FUSE mount with one-shot poisoned-cache recovery. Delegates
-   * to {@link spawnOnce}; if that fails specifically because the persistent VFS
-   * cache was poisoned (a prior container SIGKILLed mid-write left `vfs`/`vfsMeta`
-   * referencing missing backing files), quarantine the cache and retry the mount
-   * exactly once on a clean rebuild from the authoritative remote.
-   *
-   * The retry is single-shot and bounded: if the fresh-cache mount also fails the
-   * cause is connectivity/token (not the cache), so the error propagates without
-   * a second reset — never a reset/respawn loop. A non-poison failure, or a
-   * poison failure with nothing to quarantine, propagates immediately.
-   */
-  async spawn(config) {
-    try {
-      return await this.spawnOnce(config);
-    } catch (err) {
-      if (!(err instanceof CachePoisonedMountError)) throw err;
-      let quarantined;
-      try {
-        quarantined = await quarantineCacheDir(config.cacheDir, this.now());
-      } catch (qErr) {
-        config.log.warn("rclone vfs-cache quarantine failed \u2014 surfacing original mount error", {
-          cacheDir: config.cacheDir,
-          error: qErr instanceof Error ? qErr.message : String(qErr)
-        });
-        throw err;
-      }
-      if (!quarantined) {
-        throw err;
-      }
-      config.log.warn(
-        "rclone mount failed on a poisoned vfs cache \u2014 quarantined it and retrying the mount once",
-        { cacheDir: config.cacheDir, quarantined }
-      );
-      return await this.spawnOnce(config);
-    }
-  }
-  /**
-   * Spawn an rclone FUSE mount. Resolves once the mountpoint is confirmed
-   * present in `/proc/self/mounts`. Throws on timeout, on early exit, or
-   * if invariants are violated. A readiness-timeout accompanied by the
-   * poisoned-cache log signature throws {@link CachePoisonedMountError} so the
-   * public {@link spawn} can apply its quarantine-and-retry recovery.
-   */
-  async spawnOnce(config) {
-    if (!path.isAbsolute(config.mountPoint)) {
-      throw new Error(`mountPoint must be absolute: ${config.mountPoint}`);
-    }
-    if (!path.isAbsolute(config.cacheDir)) {
-      throw new Error(`cacheDir must be absolute: ${config.cacheDir}`);
-    }
-    await ensureDirMode(config.mountPoint, config.log);
-    await ensureDirMode(config.cacheDir, config.log);
-    const configPath = path.join(
-      tmpdir(),
-      `rclone-${config.mountId}-${randomBytes(6).toString("hex")}.conf`
-    );
-    await writeFile(configPath, config.rcloneConfig, { mode: 384 });
-    const port = await RCLONE_RC_PORTS.allocate();
-    const rcAddr = `127.0.0.1:${port}`;
-    const rcloneLog = config.log.child({ subkind: `${config.driverName}+rclone` });
-    config.log.info("rclone spawn starting", {
-      mountPoint: config.mountPoint,
-      remote: config.remote,
-      vfsCacheMode: config.vfsCacheMode
-    });
-    const args = _buildRcloneArgs(config, { configPath, rcAddr });
-    const proc = spawn("rclone", args, { stdio: ["ignore", "pipe", "pipe"] });
-    const routeCtx = {
-      stuckThreshold: config.uploadStuckThreshold ?? DEFAULT_UPLOAD_STUCK_THRESHOLD,
-      alertedObjects: /* @__PURE__ */ new Set(),
-      itemNotFoundCounts: /* @__PURE__ */ new Map(),
-      onUploadStuck: (object, tries) => {
-        rcloneLog.error(
-          "rclone upload repeatedly failing \u2014 file may be stranded in this session's cache",
-          void 0,
-          { object, tries, event: "sync_status", phase: "error" }
-        );
-        config.onUploadStuck?.(object, tries);
-      },
-      onAuthError: config.onAuthError
-    };
-    const recentStderr = [];
-    const stderrTail = (line) => {
-      recentStderr.push(line);
-      if (recentStderr.length > 20) recentStderr.shift();
-    };
-    let cachePoisonObserved = false;
-    const noteCachePoison = (line) => {
-      if (!cachePoisonObserved && _isCachePoisonLine(line)) cachePoisonObserved = true;
-    };
-    const stdoutHandler = (line) => {
-      noteCachePoison(line);
-      _routeRcloneLogLine(line, rcloneLog, routeCtx);
-    };
-    const stderrHandler = (line) => {
-      stderrTail(line);
-      noteCachePoison(line);
-      _routeRcloneLogLine(line, rcloneLog, routeCtx);
-    };
-    if (proc.stdout) attachLineSplitter(proc.stdout, stdoutHandler);
-    if (proc.stderr) attachLineSplitter(proc.stderr, stderrHandler);
-    let earlyExitCode = null;
-    let earlyExitSignal = null;
-    const earlyExit = new Promise((resolve) => {
-      proc.once("exit", (code, signal) => {
-        earlyExitCode = code;
-        earlyExitSignal = signal;
-        resolve();
-      });
-    });
-    const mountReady = waitFor(
-      async () => {
-        if (earlyExitCode !== null || earlyExitSignal !== null) return false;
-        return await isMountpoint(config.mountPoint);
-      },
-      { timeoutMs: 15e3, intervalMs: 100 }
-    );
-    const ready = await Promise.race([mountReady, earlyExit.then(() => false)]);
-    if (!ready) {
-      try {
-        if (proc.exitCode === null && proc.signalCode === null) {
-          proc.kill("SIGKILL");
-        }
-      } catch {
-      }
-      await unlink(configPath).catch(() => {
-      });
-      RCLONE_RC_PORTS.release(port);
-      const tail = recentStderr.length > 0 ? `
-stderr tail:
-${recentStderr.slice(-5).join("\n")}` : "";
-      const message = `rclone failed to mount ${config.remote} at ${config.mountPoint}${tail}`;
-      if (cachePoisonObserved) {
-        throw new CachePoisonedMountError(message);
-      }
-      throw new Error(message);
-    }
-    const pid = proc.pid;
-    if (pid === void 0) {
-      proc.kill("SIGKILL");
-      await unlink(configPath).catch(() => {
-      });
-      RCLONE_RC_PORTS.release(port);
-      throw new Error("rclone process has no pid after successful mount");
-    }
-    const entry = {
-      proc,
-      configPath,
-      port,
-      mountPoint: config.mountPoint,
-      cacheDir: config.cacheDir,
-      spawnConfig: config,
-      log: config.log,
-      rcloneLog,
-      recentStderr
-    };
-    HANDLES.set(pid, entry);
-    proc.on("exit", (code) => {
-      if (HANDLES.has(pid)) {
-        config.log.warn("rclone exited unexpectedly", { code, pid });
-      }
-    });
-    config.log.info("rclone mountpoint confirmed", { pid });
-    return { pid, mountPoint: config.mountPoint, cacheDir: config.cacheDir, rcAddr };
-  }
-  /**
-   * Stop an rclone subprocess. Attempts a flush first, then SIGTERM, then
-   * SIGKILL + fusermount3 if `graceMs` elapses without the mountpoint
-   * disappearing.
-   *
-   * `graceMs` bounds both the flush stabilization gate and the SIGTERM→SIGKILL
-   * window — it is *not* a single total wall-clock cap: the flush also waits on
-   * rclone's `/vfs/stats` drain (its own 60s ceiling) between the two.
-   */
-  async stop(handle, opts) {
-    const graceMs = opts?.graceMs ?? 3e4;
-    const entry = HANDLES.get(handle.pid);
-    if (!entry) {
-      return;
-    }
-    try {
-      await this.flush(handle, { stabilizeTimeoutMs: graceMs });
-    } catch (err) {
-      entry.log.warn("rclone flush before stop failed", {
-        pid: handle.pid,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-    entry.log.info("rclone stop initiated", { pid: handle.pid });
-    HANDLES.delete(handle.pid);
-    try {
-      entry.proc.kill("SIGTERM");
-    } catch {
-    }
-    const unmounted = await waitFor(async () => !await isMountpoint(entry.mountPoint), {
-      timeoutMs: graceMs,
-      intervalMs: 200
-    });
-    if (!unmounted) {
-      try {
-        entry.proc.kill("SIGKILL");
-      } catch {
-      }
-      await new Promise((resolve) => {
-        const fuse = spawn("fusermount3", ["-u", entry.mountPoint], { stdio: "ignore" });
-        fuse.once("exit", () => resolve());
-        fuse.once("error", () => resolve());
-      });
-      entry.log.warn("rclone hard-killed", { pid: handle.pid });
-    }
-    RCLONE_RC_PORTS.release(entry.port);
-    await unlink(entry.configPath).catch(() => {
-    });
-  }
-  /**
-   * Apply a freshly-rendered rclone INI to a running mount by recycling the
-   * process: flush + stop the current rclone, then re-spawn at the same
-   * mountpoint/cacheDir with the new config. Returns the new handle.
-   *
-   * rclone holds the OAuth token in memory (baked into the config at spawn);
-   * there is no rc command to swap it on a live `onedrive` backend, so a
-   * recycle is the reliable way to apply a refreshed token. The vfs cache dir
-   * is reused, so the remount revalidates rather than re-downloads. During the
-   * brief unmount window the read-only mount-placeholder barrier underneath is
-   * exposed (writes fail with EROFS, not EIO) — see ConnectorManager's
-   * read-only-until-ready guarantee.
-   */
-  async reconfigure(handle, rcloneConfig) {
-    const entry = HANDLES.get(handle.pid);
-    if (!entry) {
-      throw new Error(`rclone handle not found (pid=${handle.pid})`);
-    }
-    const nextConfig = { ...entry.spawnConfig, rcloneConfig };
-    entry.log.info("rclone reconfigure \u2014 recycling process to apply refreshed credential", {
-      pid: handle.pid
-    });
-    await this.stop(handle, { graceMs: 3e4 });
-    return this.spawn(nextConfig);
-  }
-  /**
-   * Force rclone to upload pending writes, then wait until the in-use
-   * counter reaches zero.
-   *
-   * Before issuing the refresh it waits for the vfs cache dir to go quiescent
-   * (no write for `stabilityThresholdMs`, bounded by `stabilizeTimeoutMs`) so a
-   * close/hibernate-triggered flush doesn't snapshot a half-written file and
-   * trigger rclone's mid-write "sizes differ" abort. Pass `stabilize: false`
-   * to skip the gate.
-   */
-  async flush(handle, opts) {
-    const entry = HANDLES.get(handle.pid);
-    if (!entry) {
-      throw new Error(`rclone handle not found (pid=${handle.pid})`);
-    }
-    if (opts?.stabilize !== false) {
-      const thresholdMs = opts?.stabilityThresholdMs ?? STABILIZE_THRESHOLD_MS;
-      const timeoutMs = opts?.stabilizeTimeoutMs ?? STABILIZE_TIMEOUT_MS;
-      const scanDir = await vfsContentDir(entry.cacheDir);
-      const quiescent = await awaitQuiescent(scanDir, {
-        thresholdMs,
-        timeoutMs,
-        pollMs: STABILIZE_POLL_MS
-      });
-      if (!quiescent) {
-        entry.log.warn("rclone cache did not stabilize before flush \u2014 proceeding anyway", {
-          pid: handle.pid,
-          thresholdMs,
-          timeoutMs
-        });
-      }
-    }
-    const refreshRes = await fetch(`http://${handle.rcAddr}/vfs/refresh?recursive=true`, {
-      method: "POST"
-    });
-    if (!refreshRes.ok) {
-      const body = await refreshRes.text().catch(() => "");
-      throw new Error(`rclone /vfs/refresh failed: ${refreshRes.status} ${body}`);
-    }
-    const ok = await waitFor(
-      async () => {
-        const r = await fetch(`http://${handle.rcAddr}/vfs/stats`, { method: "GET" });
-        if (!r.ok) return false;
-        const body = await r.json();
-        return body.inUse === 0;
-      },
-      { timeoutMs: 6e4, intervalMs: 500 }
-    );
-    if (!ok) {
-      throw new Error(`rclone flush did not drain within 60s (pid=${handle.pid})`);
-    }
-  }
-  /**
-   * Authoritative remote byte size for a mount-relative path, via rclone's
-   * `operations/stat` rc endpoint. Backs the mount read-path stale-tail gate:
-   * `operations/stat` hits the backend object directly, so it returns the true
-   * remote size even when the VFS cache is serving a non-truncated item (and
-   * `statSync` on the FUSE mount reports the inflated length). Returns `null`
-   * when the handle is unknown, the object is missing / a directory, or the
-   * call fails — the caller then trusts the on-disk bytes.
-   */
-  async statSize(handle, relPath) {
-    const entry = HANDLES.get(handle.pid);
-    if (!entry) return null;
-    return fetchAuthoritativeSize(handle.rcAddr, entry.spawnConfig.remote, relPath);
-  }
-  /** Liveness + cache-dir size. */
-  async status(handle) {
-    const entry = HANDLES.get(handle.pid);
-    if (!entry) {
-      return { alive: false, cacheBytes: 0 };
-    }
-    const alive = entry.proc.exitCode === null && entry.proc.signalCode === null;
-    const cacheBytes = await dirSize(entry.cacheDir);
-    return { alive, cacheBytes };
-  }
-};
-var UPLOAD_FAIL_RE = /failed to upload.*?try #(\d+)/i;
-var UPLOAD_OK_RE = /upload succeeded/i;
-var AUTH_FAIL_RE = /invalid_client|couldn'?t fetch token|invalid_grant|InvalidAuthenticationToken/i;
-var ITEM_NOT_FOUND_RE = /itemNotFound/i;
-var CACHE_POISON_RE = /failed to reload item|failed to add virtual dir entry/i;
-var CachePoisonedMountError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CachePoisonedMountError";
-  }
-};
-function _isCachePoisonLine(line) {
-  return CACHE_POISON_RE.test(line);
-}
-async function quarantineCacheDir(cacheDir, nowMs) {
-  const stamp = new Date(nowMs).toISOString().replace(/[:.]/g, "-");
-  const quarantineDir = path.join(cacheDir, `.corrupt-${stamp}`);
-  await mkdir(quarantineDir, { recursive: true });
-  let moved = 0;
-  for (const sub of ["vfs", "vfsMeta"]) {
-    const src = path.join(cacheDir, sub);
-    const dst = path.join(quarantineDir, sub);
-    try {
-      await rename(src, dst);
-    } catch (err) {
-      const code = err?.code;
-      if (code === "ENOENT") continue;
-      if (code === "EXDEV") {
-        try {
-          await cp(src, dst, { recursive: true });
-        } catch (cpErr) {
-          await rm(dst, { recursive: true, force: true }).catch(() => void 0);
-          throw cpErr;
-        }
-        await rm(src, { recursive: true, force: true });
-      } else {
-        throw err;
-      }
-    }
-    moved += 1;
-  }
-  if (moved === 0) {
-    await rm(quarantineDir, { recursive: true, force: true }).catch(() => void 0);
-    return null;
-  }
-  return quarantineDir;
-}
-function _routeRcloneLogLine(line, log, ctx) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return;
-  let parsed = null;
-  try {
-    const candidate = JSON.parse(trimmed);
-    if (candidate && typeof candidate === "object") parsed = candidate;
-  } catch {
-    parsed = null;
-  }
-  if (!parsed) {
-    if (ctx) {
-      _trackUploadFailure(trimmed, void 0, ctx);
-      if (AUTH_FAIL_RE.test(trimmed)) ctx.onAuthError?.();
-      if (ITEM_NOT_FOUND_RE.test(trimmed)) _trackItemNotFound(void 0, trimmed, ctx);
-    }
-    log.info(trimmed);
-    return;
-  }
-  const level = (parsed.level ?? "INFO").toUpperCase();
-  const msg = parsed.msg ?? "";
-  const data = {};
-  if (parsed.object !== void 0) data.object = parsed.object;
-  if (parsed.source !== void 0) data.source = parsed.source;
-  if (ctx) {
-    _trackUploadFailure(msg, parsed.object, ctx);
-    const errText = typeof parsed.error === "string" ? parsed.error : "";
-    if (AUTH_FAIL_RE.test(msg) || errText && AUTH_FAIL_RE.test(errText)) ctx.onAuthError?.();
-    if (ITEM_NOT_FOUND_RE.test(msg) || errText && ITEM_NOT_FOUND_RE.test(errText)) {
-      _trackItemNotFound(parsed.object, msg, ctx);
-    }
-  }
-  switch (level) {
-    case "DEBUG":
-      log.debug(msg, data);
-      break;
-    case "INFO":
-    case "NOTICE":
-      log.info(msg, data);
-      break;
-    case "WARNING":
-      log.warn(msg, data);
-      break;
-    case "ERROR":
-    case "CRITICAL":
-    case "EMERGENCY":
-    case "ALERT":
-      log.error(msg, parsed.error, data);
-      break;
-    default:
-      log.info(msg, data);
-      break;
-  }
-}
-function _trackUploadFailure(msg, object, ctx) {
-  const failMatch = UPLOAD_FAIL_RE.exec(msg);
-  if (failMatch) {
-    const tries = Number(failMatch[1]);
-    const key = object ?? extractObjectFromMsg(msg) ?? "(unknown)";
-    const threshold = ctx.stuckThreshold ?? DEFAULT_UPLOAD_STUCK_THRESHOLD;
-    if (!ctx.alertedObjects) ctx.alertedObjects = /* @__PURE__ */ new Set();
-    const alerted = ctx.alertedObjects;
-    if (tries >= threshold && !alerted.has(key)) {
-      alerted.add(key);
-      ctx.onUploadStuck?.(key, tries);
-    }
-    return;
-  }
-  if (UPLOAD_OK_RE.test(msg)) {
-    const key = object ?? extractObjectFromMsg(msg);
-    if (key) {
-      ctx.alertedObjects?.delete(key);
-      ctx.itemNotFoundCounts?.delete(key);
-    }
-  }
-}
-function _trackItemNotFound(object, msg, ctx) {
-  const key = object ?? extractObjectFromMsg(msg) ?? "(unknown)";
-  if (!ctx.itemNotFoundCounts) ctx.itemNotFoundCounts = /* @__PURE__ */ new Map();
-  if (!ctx.alertedObjects) ctx.alertedObjects = /* @__PURE__ */ new Set();
-  const count = (ctx.itemNotFoundCounts.get(key) ?? 0) + 1;
-  ctx.itemNotFoundCounts.set(key, count);
-  const threshold = ctx.stuckThreshold ?? DEFAULT_UPLOAD_STUCK_THRESHOLD;
-  if (count >= threshold && !ctx.alertedObjects.has(key)) {
-    ctx.alertedObjects.add(key);
-    ctx.onUploadStuck?.(key, count);
-  }
-}
-function extractObjectFromMsg(msg) {
-  const m = /(?:^|\s)([^\s:]+\/[^\s:]+):/.exec(msg);
-  return m?.[1];
-}
-function _buildRcloneArgs(config, io) {
-  const args = [
-    "mount",
-    config.remote,
-    config.mountPoint,
-    "--config",
-    io.configPath,
-    "--cache-dir",
-    config.cacheDir,
-    "--vfs-cache-mode",
-    config.vfsCacheMode,
-    "--vfs-cache-max-size",
-    config.cacheMaxSize ?? "5G",
-    "--vfs-cache-max-age",
-    config.cacheMaxAge ?? "168h",
-    "--vfs-write-back",
-    config.vfsWriteBack ?? DEFAULT_VFS_WRITE_BACK,
-    "--vfs-cache-poll-interval",
-    "60s",
-    "--rc",
-    "--rc-addr",
-    io.rcAddr,
-    // loopback-only rc server — without no-auth, flush's POST /vfs/refresh 403s,
-    // graceful stop fails, and the write-back cache is left dirty. Safe: nothing
-    // external can reach 127.0.0.1:<port>.
-    "--rc-no-auth",
-    "--log-level",
-    "INFO",
-    "--use-json-log",
-    "--allow-other",
-    // The ro-tmpfs deferred-mount barrier is already mounted here; without this
-    // rclone aborts with "directory already mounted". See mount-placeholder.ts.
-    "--allow-non-empty"
-  ];
-  if (config.ignoreSizeCheck) {
-    args.push("--ignore-size", "--ignore-checksum");
-  }
-  if (config.driverName.split("+")[0] === "sharepoint") {
-    args.push("--onedrive-upload-cutoff", "4Mi");
-  }
-  return args;
-}
-function _operationsStatTarget(remote, relPath) {
-  const colon = remote.indexOf(":");
-  const fs = colon >= 0 ? remote.slice(0, colon + 1) : remote;
-  const base = colon >= 0 ? remote.slice(colon + 1) : "";
-  const joined = [base, relPath].map((s) => s.replace(/^\/+|\/+$/g, "")).filter((s) => s.length > 0).join("/");
-  return { fs, remote: joined };
-}
-async function fetchAuthoritativeSize(rcAddr, remote, relPath, fetchImpl = fetch) {
-  const target = _operationsStatTarget(remote, relPath);
-  try {
-    const res = await fetchImpl(`http://${rcAddr}/operations/stat`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(target)
-    });
-    if (!res.ok) return null;
-    const body = await res.json();
-    const item = body.item;
-    if (!item || item.IsDir === true) return null;
-    return typeof item.Size === "number" && item.Size >= 0 ? item.Size : null;
-  } catch {
-    return null;
-  }
-}
-async function awaitQuiescent(dir, opts) {
-  const deadline = Date.now() + opts.timeoutMs;
-  for (; ; ) {
-    const newest = await newestMtimeMs(dir);
-    if (newest === null || Date.now() - newest >= opts.thresholdMs) return true;
-    if (Date.now() >= deadline) return false;
-    await sleep(opts.pollMs);
-  }
-}
-async function vfsContentDir(cacheDir) {
-  const vfs = path.join(cacheDir, "vfs");
-  try {
-    return (await stat(vfs)).isDirectory() ? vfs : cacheDir;
-  } catch {
-    return cacheDir;
-  }
-}
-async function newestMtimeMs(dir) {
-  let newest = null;
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const full = path.join(dir, String(e.name));
-      if (e.isDirectory()) {
-        const sub = await newestMtimeMs(full);
-        if (sub !== null && (newest === null || sub > newest)) newest = sub;
-      } else if (e.isFile()) {
-        try {
-          const s = await stat(full);
-          if (newest === null || s.mtimeMs > newest) newest = s.mtimeMs;
-        } catch {
-        }
-      }
-    }
-  } catch {
-    return null;
-  }
-  return newest;
-}
-function _fuseMountPresent(procMountsText, mountPoint) {
-  const resolved = path.resolve(mountPoint);
-  for (const raw of procMountsText.split("\n")) {
-    if (raw.length === 0) continue;
-    const fields = raw.split(/\s+/);
-    const mp = fields[1];
-    const fstype = fields[2];
-    if (!mp || !fstype) continue;
-    const decoded = mp.replace(/\\040/g, " ");
-    if (decoded === resolved && (fstype === "fuse" || fstype.startsWith("fuse."))) return true;
-  }
-  return false;
-}
-async function isMountpoint(mountPoint) {
-  try {
-    const text = await readFile("/proc/self/mounts", "utf8");
-    return _fuseMountPresent(text, mountPoint);
-  } catch {
-    return false;
-  }
-}
-async function waitFor(check, opts) {
-  const deadline = Date.now() + opts.timeoutMs;
-  while (Date.now() < deadline) {
-    if (await check()) return true;
-    await sleep(opts.intervalMs);
-  }
-  return await check();
-}
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function attachLineSplitter(stream, onLine) {
-  let buffer = "";
-  stream.setEncoding("utf8");
-  stream.on("data", (chunk) => {
-    buffer += chunk;
-    let idx = buffer.indexOf("\n");
-    while (idx >= 0) {
-      const line = buffer.slice(0, idx);
-      buffer = buffer.slice(idx + 1);
-      if (line.length > 0) onLine(line);
-      idx = buffer.indexOf("\n");
-    }
-  });
-  stream.on("end", () => {
-    if (buffer.length > 0) {
-      onLine(buffer);
-      buffer = "";
-    }
-  });
-}
-async function dirSize(dir) {
-  let total = 0;
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const full = path.join(dir, String(e.name));
-      if (e.isDirectory()) {
-        total += await dirSize(full);
-      } else if (e.isFile()) {
-        try {
-          const s = await stat(full);
-          total += s.size;
-        } catch {
-        }
-      }
-    }
-  } catch {
-    return 0;
-  }
-  return total;
-}
-
-export { CachePoisonedMountError, DEFAULT_UPLOAD_STUCK_THRESHOLD, DEFAULT_VFS_WRITE_BACK, PortPool, RcloneProcessManager, _buildRcloneArgs, _fuseMountPresent, _isCachePoisonLine, _operationsStatTarget, _routeRcloneLogLine, awaitQuiescent, createFsWatcher, ensureDirMode, fetchAuthoritativeSize, quarantineCacheDir };
-//# sourceMappingURL=chunk-RAIRWFAN.js.map
-//# sourceMappingURL=chunk-RAIRWFAN.js.map