@dench.com/cli 2.1.0 → 2.1.2

package/fs-daemon.ts

@@ -50,7 +50,14 @@
  */
 import { createHash } from "node:crypto";
 import { mkdirSync } from "node:fs";
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
 import { dirname, relative } from "node:path";
 import { ConvexClient, ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
@@ -142,6 +149,33 @@ function sha256(bytes: Uint8Array): string {
   return createHash("sha256").update(bytes).digest("hex");
 }
 
+function normalizePosixWorkspacePath(input: string): string {
+  let cleaned = input.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (cleaned.startsWith("/workspace/")) {
+    cleaned = cleaned.slice("/workspace".length);
+  } else if (cleaned === "/workspace") {
+    cleaned = "/";
+  }
+  if (!cleaned.startsWith("/")) cleaned = `/${cleaned}`;
+  return cleaned.length > 1 && cleaned.endsWith("/")
+    ? cleaned.slice(0, -1)
+    : cleaned;
+}
+
+type PullRequest = {
+  id: string;
+  paths: string[];
+  requestedAt: number;
+};
+
+type PullResponse = {
+  errors: Array<{ error: string; path: string }>;
+  id: string;
+  ok: boolean;
+  pulled: Array<{ contentHash: string; path: string }>;
+  respondedAt: number;
+};
+
 const SYNC_DEBOUNCE_MS = 300;
 const MAX_INLINE_TEXT_BYTES = 100_000;
 const CIRCUIT_BREAKER_LIMIT = 5;
@@ -155,6 +189,7 @@ const RECONCILE_INTERVAL_DEFAULT_MS = 30_000;
 // Status / breaker state visible to `dench fs status` over a tiny
 // JSON file the daemon refreshes after each tick.
 const DAEMON_STATUS_PATH = "/tmp/dench-fs-daemon.status.json";
+const PULL_REQUEST_DIR = "/tmp/dench-fs-daemon.pull";
 
 type BreakerState = {
   path: string;
@@ -421,6 +456,13 @@ class DenchFileClient {
     return Array.isArray(rows) ? rows : [];
   }
 
+  async getFileTreeRow(path: string): Promise<FileTreeSyncRow | null> {
+    const normalized = normalizePosixWorkspacePath(path);
+    const parent = dirname(normalized) === "." ? "/" : dirname(normalized);
+    const rows = await this.listTree(parent);
+    return rows.find((row) => row.path === normalized) ?? null;
+  }
+
   async getSignedDownloadUrl(path: string): Promise<string | null> {
     const url = (await this.http.action(api.files.getFileSignedDownloadUrl, {
       path,
@@ -526,6 +568,68 @@ async function pullDownRemoteFile(
   );
 }
 
+async function processPullRequests(args: {
+  client: DenchFileClient;
+  tracker: HashTracker;
+  workspace: string;
+}): Promise<void> {
+  await mkdir(PULL_REQUEST_DIR, { recursive: true });
+  const entries = await readdir(PULL_REQUEST_DIR).catch(() => []);
+  const requestFiles = entries.filter(
+    (entry) => entry.startsWith("request-") && entry.endsWith(".json"),
+  );
+  for (const entry of requestFiles) {
+    const requestPath = `${PULL_REQUEST_DIR}/${entry}`;
+    let request: PullRequest | null = null;
+    try {
+      request = JSON.parse(await readFile(requestPath, "utf-8")) as PullRequest;
+    } catch (error) {
+      console.error(
+        `[dench-fs-daemon] invalid pull request ${entry}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      await unlink(requestPath).catch(() => undefined);
+      continue;
+    }
+    const response: PullResponse = {
+      errors: [],
+      id: request.id,
+      ok: true,
+      pulled: [],
+      respondedAt: Date.now(),
+    };
+    for (const rawPath of request.paths) {
+      const path = normalizePosixWorkspacePath(rawPath);
+      try {
+        const row = await args.client.getFileTreeRow(path);
+        if (!row || row.isDir || !row.contentHash) {
+          throw new Error("File is not present in Convex fileTree.");
+        }
+        await pullDownRemoteFile(args.client, {
+          expectedHash: row.contentHash,
+          posixPath: path,
+          tracker: args.tracker,
+          workspace: args.workspace,
+        });
+        response.pulled.push({ contentHash: row.contentHash, path });
+      } catch (error) {
+        response.ok = false;
+        response.errors.push({
+          error: error instanceof Error ? error.message : String(error),
+          path,
+        });
+      }
+    }
+    await writeFile(
+      `${PULL_REQUEST_DIR}/response-${request.id}.json`,
+      JSON.stringify(response),
+      "utf-8",
+    );
+    await unlink(requestPath).catch(() => undefined);
+  }
+}
+
 /**
  * sysexits.h-style exit codes the supervisor (in
  * src/lib/daytona/sandbox-bootstrap.ts) recognizes as **permanent** —
@@ -785,6 +889,21 @@ async function runDaemon(daemonArgs: Args): Promise<void> {
       .catch(() => undefined);
   });
 
+  process.on("SIGUSR2", () => {
+    console.log(`[dench-fs-daemon] SIGUSR2 received — processing pull queue`);
+    void processPullRequests({
+      client,
+      tracker,
+      workspace: daemonArgs.workspace,
+    }).catch((error) =>
+      console.error(
+        `[dench-fs-daemon] pull queue failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      ),
+    );
+  });
+
   process.on("SIGTERM", () => {
     reconciler.stop();
     unsubscribe();
@@ -1303,6 +1422,82 @@ async function runFlush(argv: string[]): Promise<void> {
     outcome.reason === "no_daemon" ? 1 : outcome.reason === "timeout" ? 2 : 3;
 }
 
+async function runPull(argv: string[]): Promise<void> {
+  const json = argv.includes("--json");
+  const wait = argv.includes("--wait");
+  const timeoutIndex = argv.indexOf("--timeout-ms");
+  const timeoutMs =
+    timeoutIndex === -1
+      ? 10_000
+      : Number.parseInt(argv[timeoutIndex + 1] ?? "10000", 10);
+  const paths: string[] = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json" || arg === "--wait") continue;
+    if (arg === "--timeout-ms") {
+      i += 1;
+      continue;
+    }
+    paths.push(normalizePosixWorkspacePath(arg));
+  }
+  if (paths.length === 0) {
+    throw new Error("dench-fs-daemon pull requires at least one path");
+  }
+  const status = (await readStatusFile()).state;
+  if (!status || !isPidAlive(status.pid)) {
+    const response = { ok: false, reason: "no_daemon" };
+    if (json) process.stdout.write(`${JSON.stringify(response)}\n`);
+    else process.stderr.write("DENCH_FS_PULL=no_daemon\n");
+    process.exitCode = 1;
+    return;
+  }
+  await mkdir(PULL_REQUEST_DIR, { recursive: true });
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const request: PullRequest = { id, paths, requestedAt: Date.now() };
+  await writeFile(
+    `${PULL_REQUEST_DIR}/request-${id}.json`,
+    JSON.stringify(request),
+    "utf-8",
+  );
+  process.kill(status.pid, "SIGUSR2");
+  if (!wait) {
+    const response = { ok: true, id, queued: paths };
+    if (json) process.stdout.write(`${JSON.stringify(response)}\n`);
+    else process.stdout.write(`DENCH_FS_PULL=queued id=${id}\n`);
+    return;
+  }
+
+  const responsePath = `${PULL_REQUEST_DIR}/response-${id}.json`;
+  const deadline =
+    Date.now() + (Number.isFinite(timeoutMs) ? timeoutMs : 10_000);
+  while (Date.now() < deadline) {
+    try {
+      const response = JSON.parse(
+        await readFile(responsePath, "utf-8"),
+      ) as PullResponse;
+      await unlink(responsePath).catch(() => undefined);
+      if (json) process.stdout.write(`${JSON.stringify(response)}\n`);
+      else if (response.ok) {
+        process.stdout.write(
+          `DENCH_FS_PULL=ok pulled=${response.pulled.length}\n`,
+        );
+      } else {
+        process.stderr.write(
+          `DENCH_FS_PULL=failed errors=${response.errors.length}\n`,
+        );
+      }
+      if (!response.ok) process.exitCode = 3;
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  const timeoutResponse = { ok: false, id, paths, reason: "timeout" };
+  if (json) process.stdout.write(`${JSON.stringify(timeoutResponse)}\n`);
+  else process.stderr.write(`DENCH_FS_PULL=timeout id=${id}\n`);
+  process.exitCode = 2;
+}
+
 async function main(): Promise<void> {
   const argv = process.argv.slice(2);
   const subcommand = argv[0];
@@ -1327,6 +1522,10 @@ async function main(): Promise<void> {
     await runFlush(argv.slice(1));
     return;
   }
+  if (subcommand === "pull") {
+    await runPull(argv.slice(1));
+    return;
+  }
   if (subcommand === "status") {
     await runStatus(argv.slice(1));
     return;
@@ -1425,7 +1624,7 @@ async function collectStatus(args: {
 
   const pidAlive = statusFile.state ? isPidAlive(statusFile.state.pid) : false;
 
-  let onDiskList: Array<{ path: string; size: number; mtimeMs: number }> = [];
+  const onDiskList: Array<{ path: string; size: number; mtimeMs: number }> = [];
   let convexRows: Array<{
     path: string;
     contentHash?: string;