@dench.com/cli 0.3.3 → 0.3.5

package/chat-spawn.ts

@@ -0,0 +1,370 @@
+/**
+ * `dench chat new` / `dench chat send` — spawn a chat-turn workflow
+ * from the CLI, exactly the same workflow the web UI uses. Threads
+ * created here are visible in `dench chat list` and the UI's chat
+ * thread list immediately, since they go through the same Convex
+ * tables (`chatThreads` + `chatMessages`).
+ *
+ * Aliased as `dench agent new` / `dench agent send` so users who
+ * grep for "agent" find them.
+ *
+ * Both subcommands POST to `/api/chat/cli` (auth: same `dch_agent_*`
+ * session token or Dench API key as the rest of the CLI). The
+ * server creates the thread + queued run, kicks off
+ * `chatTurnWorkflow`, and returns ids + URLs. With `--follow` the
+ * CLI then opens the durable resumable stream
+ * (`/api/chat/[runId]/stream`) and pretty-prints text deltas + tool
+ * calls until the workflow finishes.
+ */
+
+import { hasFlag } from "./lib/cli-args";
+
+class ChatSpawnError extends Error {}
+
+type RuntimeBundle = {
+  host: string;
+  bearerToken: string;
+};
+
+type ChatSpawnContext = {
+  runtime: RuntimeBundle;
+  args: string[];
+  jsonOutput: boolean;
+};
+
+function consumeFlagValue(args: string[], name: string): string | undefined {
+  const idx = args.indexOf(name);
+  if (idx === -1) return undefined;
+  const value = args[idx + 1];
+  args.splice(idx, 2);
+  return value;
+}
+
+function consumeFlag(args: string[], name: string): boolean {
+  const idx = args.indexOf(name);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  return true;
+}
+
+function out(ctx: ChatSpawnContext, value: unknown): void {
+  if (ctx.jsonOutput) {
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  if (value === null || value === undefined) {
+    console.log("(empty)");
+    return;
+  }
+  console.log(JSON.stringify(value, null, 2));
+}
+
+async function postJson(
+  url: string,
+  bearer: string,
+  body: unknown,
+): Promise<{ ok: boolean; status: number; payload: unknown }> {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      authorization: `Bearer ${bearer}`,
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let payload: unknown;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { raw: text };
+  }
+  return { ok: response.ok, status: response.status, payload };
+}
+
+function buildSpawnUrl(host: string): string {
+  return `${host.replace(/\/+$/, "")}/api/chat/cli`;
+}
+
+function buildStreamUrl(host: string, runId: string): string {
+  return `${host.replace(/\/+$/, "")}/api/chat/${encodeURIComponent(runId)}/stream`;
+}
+
+/**
+ * Subscribe to the durable chat stream and pretty-print useful chunks
+ * until the stream closes. Mirrors the chunk types the chat panel
+ * cares about (text deltas, reasoning, tool input/output, finish).
+ */
+async function followStream(args: {
+  host: string;
+  bearerToken: string;
+  runId: string;
+}): Promise<void> {
+  const url = buildStreamUrl(args.host, args.runId);
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      accept: "text/event-stream",
+      authorization: `Bearer ${args.bearerToken}`,
+    },
+  });
+  if (!response.ok || !response.body) {
+    throw new ChatSpawnError(
+      `Failed to open stream: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  // Tool calls in flight, keyed by toolCallId, so we can render
+  // a single line per call ("→ tool_name … done") instead of
+  // dumping every chunk verbatim.
+  const inFlightTools = new Map<string, { toolName: string }>();
+  let textBuffer = "";
+
+  const flushText = () => {
+    if (textBuffer) {
+      process.stdout.write(textBuffer);
+      textBuffer = "";
+    }
+  };
+
+  const handleChunk = (raw: string) => {
+    if (!raw.startsWith("data:")) return;
+    const data = raw.slice("data:".length).trim();
+    if (!data || data === "[DONE]") return;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (!parsed || typeof parsed !== "object") return;
+    const c = parsed as {
+      type?: unknown;
+      delta?: unknown;
+      text?: unknown;
+      toolName?: unknown;
+      toolCallId?: unknown;
+      input?: unknown;
+      output?: unknown;
+      errorText?: unknown;
+    };
+    switch (c.type) {
+      case "text-delta":
+      case "reasoning-delta": {
+        if (typeof c.delta === "string") {
+          textBuffer += c.delta;
+        }
+        break;
+      }
+      case "tool-input-start": {
+        flushText();
+        if (
+          typeof c.toolCallId === "string" &&
+          typeof c.toolName === "string"
+        ) {
+          inFlightTools.set(c.toolCallId, { toolName: c.toolName });
+          process.stdout.write(`\n→ ${c.toolName} …`);
+        }
+        break;
+      }
+      case "tool-output-available": {
+        flushText();
+        if (typeof c.toolCallId === "string") {
+          const meta = inFlightTools.get(c.toolCallId);
+          inFlightTools.delete(c.toolCallId);
+          process.stdout.write(` done (${meta?.toolName ?? "tool"})\n`);
+        }
+        break;
+      }
+      case "tool-output-error": {
+        flushText();
+        if (typeof c.toolCallId === "string") {
+          const meta = inFlightTools.get(c.toolCallId);
+          inFlightTools.delete(c.toolCallId);
+          process.stdout.write(
+            ` error (${meta?.toolName ?? "tool"}): ${
+              typeof c.errorText === "string" ? c.errorText : "unknown"
+            }\n`,
+          );
+        }
+        break;
+      }
+      case "finish": {
+        flushText();
+        process.stdout.write("\n");
+        break;
+      }
+      case "error": {
+        flushText();
+        const msg =
+          typeof c.errorText === "string" ? c.errorText : "stream error";
+        process.stderr.write(`\n[error] ${msg}\n`);
+        break;
+      }
+      default:
+        break;
+    }
+  };
+
+  // Read SSE-style chunks. The route uses Vercel AI SDK's
+  // `createUIMessageStreamResponse` which emits `data: {…}\n\n`
+  // lines, so we split on double newlines.
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let nextBreak = buffer.indexOf("\n\n");
+    while (nextBreak !== -1) {
+      const event = buffer.slice(0, nextBreak);
+      buffer = buffer.slice(nextBreak + 2);
+      // Each event may contain multiple `data:` lines.
+      for (const line of event.split("\n")) {
+        if (line.trim().length > 0) handleChunk(line);
+      }
+      nextBreak = buffer.indexOf("\n\n");
+    }
+  }
+  flushText();
+}
+
+function joinPositionalsExceptFlags(args: string[]): string {
+  return args.filter((arg) => !arg.startsWith("--")).join(" ").trim();
+}
+
+async function runChatNew(ctx: ChatSpawnContext): Promise<void> {
+  const model = consumeFlagValue(ctx.args, "--model");
+  const fileContextPath = consumeFlagValue(ctx.args, "--file-context");
+  const visibility = consumeFlagValue(ctx.args, "--visibility");
+  const title = consumeFlagValue(ctx.args, "--title");
+  const yolo = consumeFlag(ctx.args, "--yolo");
+  const follow = consumeFlag(ctx.args, "--follow");
+
+  const prompt = joinPositionalsExceptFlags(ctx.args);
+  if (!prompt) {
+    throw new ChatSpawnError(
+      'Usage: dench chat new "<prompt>" [--model M] [--file-context PATH] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]',
+    );
+  }
+
+  const result = await postJson(
+    buildSpawnUrl(ctx.runtime.host),
+    ctx.runtime.bearerToken,
+    {
+      prompt,
+      model,
+      fileContextPath,
+      visibility,
+      title,
+      yolo,
+    },
+  );
+  if (!result.ok) {
+    const errorMessage =
+      (result.payload as { error?: string } | null)?.error ??
+      `Spawn failed (${result.status})`;
+    throw new ChatSpawnError(errorMessage);
+  }
+
+  const payload = result.payload as {
+    threadId?: string;
+    runId?: string;
+    threadUrl?: string;
+    streamUrl?: string;
+  } | null;
+  out(ctx, payload);
+
+  if (follow && payload?.runId) {
+    if (!ctx.jsonOutput) console.error("\n--- following stream ---");
+    await followStream({
+      host: ctx.runtime.host,
+      bearerToken: ctx.runtime.bearerToken,
+      runId: payload.runId,
+    });
+  }
+}
+
+async function runChatSend(ctx: ChatSpawnContext): Promise<void> {
+  const yolo = consumeFlag(ctx.args, "--yolo");
+  const follow = consumeFlag(ctx.args, "--follow");
+  const model = consumeFlagValue(ctx.args, "--model");
+
+  // First positional = threadId, the rest joined = prompt.
+  const positionals = ctx.args.filter((arg) => !arg.startsWith("--"));
+  const threadId = positionals.shift();
+  if (!threadId) {
+    throw new ChatSpawnError(
+      'Usage: dench chat send <threadId> "<message>" [--model M] [--yolo] [--follow] [--json]',
+    );
+  }
+  const prompt = positionals.join(" ").trim();
+  if (!prompt) {
+    throw new ChatSpawnError(
+      'Missing message body. Usage: dench chat send <threadId> "<message>"',
+    );
+  }
+
+  const result = await postJson(
+    buildSpawnUrl(ctx.runtime.host),
+    ctx.runtime.bearerToken,
+    {
+      threadId,
+      prompt,
+      model,
+      yolo,
+    },
+  );
+  if (!result.ok) {
+    const errorMessage =
+      (result.payload as { error?: string } | null)?.error ??
+      `Send failed (${result.status})`;
+    throw new ChatSpawnError(errorMessage);
+  }
+
+  const payload = result.payload as {
+    threadId?: string;
+    runId?: string;
+    threadUrl?: string;
+    streamUrl?: string;
+  } | null;
+  out(ctx, payload);
+
+  if (follow && payload?.runId) {
+    if (!ctx.jsonOutput) console.error("\n--- following stream ---");
+    await followStream({
+      host: ctx.runtime.host,
+      bearerToken: ctx.runtime.bearerToken,
+      runId: payload.runId,
+    });
+  }
+}
+
+/**
+ * Public entry point invoked by the chat dispatcher in cli/dench.ts
+ * (and the agent dispatcher when the user runs `dench agent new` /
+ * `dench agent send` aliases). The CLI dispatcher resolves the
+ * runtime + bearer token once and hands them in.
+ */
+export async function runChatSpawnCommand(opts: {
+  runtime: RuntimeBundle;
+  args: string[];
+  subcommand: "new" | "send";
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonOutput = hasFlag(args, "--json");
+  const ctx: ChatSpawnContext = {
+    runtime: opts.runtime,
+    args,
+    jsonOutput,
+  };
+  if (opts.subcommand === "new") {
+    await runChatNew(ctx);
+    return;
+  }
+  await runChatSend(ctx);
+}
+
+export { ChatSpawnError };

package/fs-daemon-mount.ts

@@ -0,0 +1,133 @@
+/**
+ * Mount-point detection helpers for `dench-fs-daemon`.
+ *
+ * `/workspace` in every Dench sandbox is a Daytona persistent volume
+ * mounted via AWS Mountpoint for S3 (a FUSE driver). Two upstream
+ * limitations matter for the file daemon:
+ *
+ *   • inotify events never fire on the mount
+ *     (https://github.com/awslabs/mountpoint-s3/issues/1290), so
+ *     chokidar's default backend is useless. The daemon switches
+ *     to polling mode when these helpers report a FUSE backing.
+ *
+ *   • rename(2) returns ENOSYS on general-purpose buckets, so
+ *     callers that need to detect "is this path on the volume?"
+ *     can use `detectWorkspaceFsType` to choose the safe
+ *     copy+unlink path instead of trusting `mv`.
+ *
+ * This file lives alongside fs-daemon.ts but contains no Convex /
+ * chokidar imports so unit tests can pull it directly.
+ */
+
+import { readFile } from "node:fs/promises";
+
+export type MountInfo = {
+  mountPoint: string;
+  fsType: string;
+  source: string;
+};
+
+/**
+ * Read /proc/self/mountinfo and return the parsed mount table.
+ * Returns an empty array on non-Linux hosts (e.g. local macOS dev,
+ * where /proc doesn't exist) so callers can fall through cleanly.
+ *
+ * The proc(5) line format is:
+ *
+ *   36 35 98:0 /mnt1 /mnt/parent rw,noatime master:1 - ext3 /dev/root rw
+ *   ─┬ ─┬ ──┬─ ──┬── ──┬─────── ──┬───── ──┬────── ─ ──┬─ ────┬──── ──┬
+ *    1  2   3    4    5            6        7           8     9        10
+ *
+ * We only need fields 5 (mount point) and the fs type after the
+ * " - " separator (field 9, with optional source as field 10).
+ */
+export async function readMountInfo(
+  procPath = "/proc/self/mountinfo",
+): Promise<MountInfo[]> {
+  let raw: string;
+  try {
+    raw = await readFile(procPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const out: MountInfo[] = [];
+  for (const rawLine of raw.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const dashIdx = line.indexOf(" - ");
+    if (dashIdx === -1) continue;
+    const before = line.slice(0, dashIdx).split(/\s+/);
+    const after = line.slice(dashIdx + 3).split(/\s+/);
+    const mountPoint = before[4];
+    const fsType = after[0];
+    const source = after[1] ?? "";
+    if (!mountPoint || !fsType) continue;
+    out.push({ mountPoint, fsType, source });
+  }
+  return out;
+}
+
+/**
+ * Find the longest mount point that is a prefix of `absPath`. Used to
+ * answer "what filesystem is this path on?" from the parsed mount
+ * table. Important to use longest-prefix so a `/workspace` mount
+ * over `/` doesn't get shadowed by the root mount.
+ *
+ * Naïve `startsWith` would also match `/workspace` against
+ * `/worker`; we guard against that by requiring the next char to be
+ * `/` (or the strings to be equal).
+ */
+export function findMountForPath(
+  mounts: MountInfo[],
+  absPath: string,
+): MountInfo | null {
+  let best: MountInfo | null = null;
+  for (const mount of mounts) {
+    if (mount.mountPoint === absPath) return mount;
+    const trimmed = mount.mountPoint.replace(/\/+$/, "");
+    if (
+      absPath === trimmed ||
+      absPath.startsWith(`${trimmed === "" ? "" : trimmed}/`)
+    ) {
+      if (!best || mount.mountPoint.length > best.mountPoint.length) {
+        best = mount;
+      }
+    }
+  }
+  return best;
+}
+
+/**
+ * Returns true for any FUSE-flavored fs type. mount-s3 reports
+ * `fuse` (no subtype on Linux); other FUSE drivers commonly use
+ * `fuse.<name>` (e.g. fuse.sshfs). `fuseblk` is the block-device
+ * flavor used by ntfs-3g and friends.
+ */
+export function isFuseFsType(fsType: string): boolean {
+  if (!fsType) return false;
+  return (
+    fsType === "fuse" || fsType.startsWith("fuse.") || fsType === "fuseblk"
+  );
+}
+
+/**
+ * Convenience: detect the filesystem backing a given workspace path
+ * in one call. The daemon uses this on startup to decide whether to
+ * enable chokidar's polling mode.
+ */
+export async function detectWorkspaceFsType(workspace: string): Promise<{
+  fsType: string;
+  isFuse: boolean;
+  source: string;
+}> {
+  const mounts = await readMountInfo();
+  const match = findMountForPath(mounts, workspace);
+  if (!match) {
+    return { fsType: "unknown", isFuse: false, source: "" };
+  }
+  return {
+    fsType: match.fsType,
+    isFuse: isFuseFsType(match.fsType),
+    source: match.source,
+  };
+}

package/fs-daemon.ts

@@ -1451,38 +1451,24 @@ async function runInitialSync(argv: string[]): Promise<void> {
   );
 }
 
-/**
- * Only auto-run when this file is the entry point. Tests import named
- * exports (`readMountInfo`, `findMountForPath`, `isFuseFsType`,
- * etc.) and must not trigger the daemon's main loop. The check below
- * tolerates Bun (`process.argv[1]`), the npm-installed wrapper
- * (`require.main === module`), and the dench CLI's `tsx`-based
- * fallback (`import.meta.main`).
- */
-const isDirectEntrypoint = (() => {
-  try {
-    if (typeof require !== "undefined" && require.main === module) return true;
-  } catch {
-    // require / module aren't defined in pure ESM mode; fall through.
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: Bun-specific import.meta property
-  if ((import.meta as any).main === true) return true;
-  const entry = process.argv[1] ?? "";
-  return entry.endsWith("fs-daemon.ts") || entry.endsWith("/fs-daemon");
-})();
-
-if (isDirectEntrypoint) {
-  main().catch((error) => {
-    console.error(
-      `[dench-fs-daemon] fatal: ${
-        error instanceof Error ? (error.stack ?? error.message) : String(error)
-      }`,
-    );
-    // Always exit with a non-zero code so the supervisor (in
-    // src/lib/daytona/sandbox-bootstrap.ts) can decide whether to
-    // restart. Previously we parked the process on a noop interval,
-    // which made `pgrep dench-fs-daemon` report "alive" for a daemon
-    // that had silently given up syncing.
-    process.exit(1);
-  });
-}
+// Always run main(). Earlier versions guarded this on an `isDirectEntrypoint`
+// heuristic (`process.argv[1].endsWith("/fs-daemon")` etc.), but bun's global
+// install symlinks the launcher as `/root/.bun/bin/dench-fs-daemon` — that
+// path ends with `-fs-daemon`, not `/fs-daemon`, so the guard returned false
+// and the script exited 0 silently. Nothing imports this file as a module any
+// more (the test suite imports `fs-daemon-mount.ts` for the FUSE helpers), so
+// the guard is unnecessary and matches the unconditional `main()` call in
+// `cli/dench.ts`.
+main().catch((error) => {
+  console.error(
+    `[dench-fs-daemon] fatal: ${
+      error instanceof Error ? (error.stack ?? error.message) : String(error)
+    }`,
+  );
+  // Always exit with a non-zero code so the supervisor (in
+  // src/lib/daytona/sandbox-bootstrap.ts) can decide whether to restart.
+  // Previously we parked the process on a noop interval, which made
+  // `pgrep dench-fs-daemon` report "alive" for a daemon that had silently
+  // given up syncing.
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {
@@ -13,8 +13,10 @@
     "dench.ts",
     "fs-daemon",
     "fs-daemon.ts",
+    "fs-daemon-mount.ts",
     "agent.ts",
     "chat.ts",
+    "chat-spawn.ts",
     "crm.ts",
     "agentKind.ts",
     "host.ts",