@dench.com/cli 0.2.0 → 0.3.1

package/README.md

@@ -7,13 +7,13 @@ Agent-facing CLI for the Dench agent workspace.
 Run without installing:
 
 ```bash
-npx -y dench-cli login --name "AI Agent - Billing Repo"
+npx -y @dench.com/cli login --name "AI Agent - Billing Repo"
 ```
 
 Or install globally:
 
 ```bash
-npm install -g dench-cli
+npm install -g @dench.com/cli
 dench login --name "AI Agent - Billing Repo"
 ```
 

package/dench.ts

@@ -1199,7 +1199,7 @@ async function login() {
       sessionTokenHash,
       agentName,
       agentKind,
-      userAgent: "dench-cli",
+      userAgent: "@dench.com/cli",
     },
   );
   const approvalUrl = `${host}/agent-login/${encodeURIComponent(code)}`;

package/fs-daemon.ts

@@ -27,19 +27,21 @@
  *
  * Usage (daemon mode):
  *   dench-fs-daemon \
- *     --org-id <orgId> \
  *     --workspace /workspace \
  *     --hot-cache /tmp/dench-cache
+ *
+ * `--org-id` is optional: when omitted, the daemon resolves the organization
+ * from DENCH_API_KEY via Convex before it starts watching files.
  */
 import { createHash } from "node:crypto";
 import { mkdirSync } from "node:fs";
-import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, relative } from "node:path";
 import { ConvexClient, ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 
 type Args = {
-  orgId: string;
+  orgId?: string;
   workspace: string;
   hotCache: string;
 };
@@ -67,11 +69,10 @@ function parseArgs(argv: string[]): Args {
         break;
     }
   }
-  if (!out.orgId || !out.workspace || !out.hotCache) {
-    throw new Error(
-      "dench-fs-daemon: --org-id, --workspace, and --hot-cache are required",
-    );
-  }
+  out.orgId ??= process.env.DENCH_ORG_ID?.trim() || undefined;
+  out.workspace ??= process.env.DENCH_VOLUME_PATH?.trim() || "/workspace";
+  out.hotCache ??=
+    process.env.DENCH_HOT_CACHE_PATH?.trim() || "/tmp/dench-cache";
   return out as Args;
 }
 
@@ -144,7 +145,9 @@ class HashTracker {
       setTimeout(() => {
         this.paused.delete(absPath);
         this.recentSyncs.delete(absPath);
-        console.warn(`[dench-fs-daemon] circuit breaker released for ${absPath}`);
+        console.warn(
+          `[dench-fs-daemon] circuit breaker released for ${absPath}`,
+        );
       }, 60_000);
       return true;
     }
@@ -177,10 +180,11 @@ const api = {
     commitFileUpload: makeFunctionReference<"mutation">(
       "functions/files:commitFileUpload",
     ),
-    deleteFile: makeFunctionReference<"mutation">(
-      "functions/files:deleteFile",
-    ),
+    deleteFile: makeFunctionReference<"mutation">("functions/files:deleteFile"),
     listTree: makeFunctionReference<"query">("functions/files:listTree"),
+    resolveApiKeyOrganization: makeFunctionReference<"query">(
+      "functions/files:resolveApiKeyOrganization",
+    ),
     appendLiveBuffer: makeFunctionReference<"mutation">(
       "functions/files:appendLiveBuffer",
     ),
@@ -197,17 +201,24 @@ class DenchFileClient {
   private http: ConvexHttpClient;
   private realtime: ConvexClient | null = null;
 
-  constructor(convexUrl: string, apiKey: string) {
+  constructor(
+    convexUrl: string,
+    private readonly apiKey: string,
+  ) {
     this.http = new ConvexHttpClient(convexUrl);
-    // Convex's HTTP client supports a Bearer token for auth via setAuth.
-    // The unified Dench API key is accepted by the validator we wired in
-    // convex/lib/denchApiKey.ts.
-    this.http.setAuth(apiKey);
+  }
+
+  async resolveOrganizationId(): Promise<string> {
+    const result = (await this.http.query(api.files.resolveApiKeyOrganization, {
+      apiKey: this.apiKey,
+    })) as { organizationId: string };
+    return result.organizationId;
   }
 
   async generateUploadUrl(path: string): Promise<string> {
     return (await this.http.mutation(api.files.generateUploadUrl, {
       path,
+      apiKey: this.apiKey,
     })) as string;
   }
 
@@ -238,7 +249,10 @@ class DenchFileClient {
     lastModifiedBy: string;
   }): Promise<{ versionConflict: boolean; currentHash?: string }> {
     try {
-      await this.http.mutation(api.files.commitFileUpload, args);
+      await this.http.mutation(api.files.commitFileUpload, {
+        ...args,
+        apiKey: this.apiKey,
+      });
       return { versionConflict: false };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -248,7 +262,7 @@ class DenchFileClient {
       ) {
         // Convex serializes ConvexError data into the message; pull
         // currentHash if present.
-        const m = /currentHash[\"']?:[\"']?([a-f0-9]{64})/.exec(message);
+        const m = /currentHash["']?:["']?([a-f0-9]{64})/.exec(message);
         return { versionConflict: true, currentHash: m?.[1] };
       }
       throw error;
@@ -256,14 +270,17 @@ class DenchFileClient {
   }
 
   async deleteFile(path: string): Promise<void> {
-    await this.http.mutation(api.files.deleteFile, { path });
+    await this.http.mutation(api.files.deleteFile, {
+      path,
+      apiKey: this.apiKey,
+    });
   }
 
   async getSignedDownloadUrl(path: string): Promise<string | null> {
-    const url = (await this.http.action(
-      api.files.getFileSignedDownloadUrl,
-      { path },
-    )) as string | null;
+    const url = (await this.http.action(api.files.getFileSignedDownloadUrl, {
+      path,
+      apiKey: this.apiKey,
+    })) as string | null;
     return url ?? null;
   }
 
@@ -272,11 +289,17 @@ class DenchFileClient {
     runId: string;
     chunk: string;
   }): Promise<void> {
-    await this.http.mutation(api.files.appendLiveBuffer, args as never);
+    await this.http.mutation(api.files.appendLiveBuffer, {
+      ...args,
+      apiKey: this.apiKey,
+    } as never);
   }
 
   async finalizeLiveBuffer(path: string): Promise<void> {
-    await this.http.mutation(api.files.finalizeLiveBuffer, { path });
+    await this.http.mutation(api.files.finalizeLiveBuffer, {
+      path,
+      apiKey: this.apiKey,
+    });
   }
 
   /**
@@ -295,7 +318,7 @@ class DenchFileClient {
     }
     const unsubscribe = this.realtime.onUpdate(
       api.files.listTree,
-      { prefix: "/" },
+      { prefix: "/", apiKey: this.apiKey },
       (rows: unknown) => {
         const list = Array.isArray(rows)
           ? (rows as Array<{
@@ -347,14 +370,16 @@ async function runDaemon(daemonArgs: Args): Promise<void> {
     return;
   }
 
+  const client = new DenchFileClient(convexUrl, apiKey);
+  const resolvedOrgId =
+    daemonArgs.orgId ?? (await client.resolveOrganizationId());
   console.log(
-    `[dench-fs-daemon] starting org=${daemonArgs.orgId} workspace=${daemonArgs.workspace}`,
+    `[dench-fs-daemon] starting org=${resolvedOrgId} workspace=${daemonArgs.workspace}`,
   );
   mkdirSync(daemonArgs.workspace, { recursive: true });
   mkdirSync(daemonArgs.hotCache, { recursive: true });
 
   const tracker = new HashTracker();
-  const client = new DenchFileClient(convexUrl, apiKey);
 
   let chokidar: typeof import("chokidar");
   try {
@@ -518,8 +543,7 @@ async function runStreamOpen(args: string[]): Promise<void> {
   if (!path) {
     throw new Error("dench-fs-daemon stream-open requires <path>");
   }
-  const runId =
-    process.env.DENCH_RUN_ID?.trim() ?? `manual-${Date.now()}`;
+  const runId = process.env.DENCH_RUN_ID?.trim() ?? `manual-${Date.now()}`;
   const token = newToken();
   const store = await readTokenStore();
   store[token] = { path, runId };
@@ -531,9 +555,7 @@ async function runStreamAppend(args: string[]): Promise<void> {
   const token = args[0];
   const chunk = args.slice(1).join(" ");
   if (!token || chunk === undefined) {
-    throw new Error(
-      "dench-fs-daemon stream-append requires <token> <chunk>",
-    );
+    throw new Error("dench-fs-daemon stream-append requires <token> <chunk>");
   }
   const store = await readTokenStore();
   const entry = store[token];
@@ -606,21 +628,31 @@ async function main(): Promise<void> {
  */
 async function runInitialSync(argv: string[]): Promise<void> {
   const initial = argv.includes("--initial");
-  const orgId = argv[argv.indexOf("--org-id") + 1];
-  const workspace = argv[argv.indexOf("--workspace") + 1] ?? "/workspace";
-  if (!initial || !orgId) {
+  const orgIdIndex = argv.indexOf("--org-id");
+  const workspaceIndex = argv.indexOf("--workspace");
+  const orgId =
+    orgIdIndex === -1
+      ? (process.env.DENCH_ORG_ID?.trim() ?? undefined)
+      : argv[orgIdIndex + 1];
+  const workspace =
+    workspaceIndex === -1
+      ? "/workspace"
+      : (argv[workspaceIndex + 1] ?? "/workspace");
+  if (!initial) {
     throw new Error(
-      "dench fs sync --initial --org-id <orgId> [--workspace /workspace]",
+      "dench fs sync --initial [--org-id <orgId>] [--workspace /workspace]",
     );
   }
   const convexUrl = process.env.CONVEX_URL?.trim();
   const apiKey = process.env.DENCH_API_KEY?.trim();
   if (!convexUrl || !apiKey) {
-    throw new Error(
-      "dench fs sync requires CONVEX_URL + DENCH_API_KEY in env",
-    );
+    throw new Error("dench fs sync requires CONVEX_URL + DENCH_API_KEY in env");
   }
   const client = new DenchFileClient(convexUrl, apiKey);
+  const resolvedOrgId = orgId ?? (await client.resolveOrganizationId());
+  process.stdout.write(
+    `[dench-fs-daemon] initial sync org=${resolvedOrgId} workspace=${workspace}\n`,
+  );
   const fs = await import("node:fs/promises");
   const path = await import("node:path");
 
@@ -670,7 +702,7 @@ async function runInitialSync(argv: string[]): Promise<void> {
 main().catch((error) => {
   console.error(
     `[dench-fs-daemon] fatal: ${
-      error instanceof Error ? error.stack ?? error.message : String(error)
+      error instanceof Error ? (error.stack ?? error.message) : String(error)
     }`,
   );
   // Long-running daemon: don't exit on transient errors. One-shot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Dench agent workspace CLI.",
   "type": "module",
   "bin": {