@dench.com/cli 0.3.8 → 0.4.0

package/chat.ts

@@ -1,11 +1,12 @@
 /**
- * `dench chat <subcommand>` — CLI surface for browsing past chat threads
- * in the user's workspace.
+ * `dench chat <subcommand>` — CLI surface for browsing and managing
+ * past chat threads in the user's workspace.
  *
  * Mirrors the `dench crm` pattern: a thin command dispatcher on top of
- * Convex public queries (`functions/chat:listPastChats`,
- * `searchPastChats`, `readPastChat`) which themselves enforce the
- * "own + shared in this org" visibility rule.
+ * Convex public queries/mutations (`functions/chat:listPastChats`,
+ * `searchPastChats`, `readPastChat`, `renameThreads`, `deleteThreads`)
+ * which themselves enforce the "own + shared in this org" visibility
+ * rule (`requireThreadAccess`).
  *
  * Auth: every call forwards a single bearer token via `sessionToken`
  * (either a `dch_agent_*` agent session minted by `dench login` or a
@@ -16,9 +17,13 @@
  * inside a sandbox without extra flags.
  *
  * Subcommands:
- *   chat list   [--query <substr>] [--limit N] [--include-archived]
- *   chat search <query>            [--limit N] [--include-current]
- *   chat read   <thread-id>        [--limit N]
+ *   chat list    [--query <substr>] [--limit N] [--include-archived]
+ *   chat search  <query>            [--limit N] [--include-current]
+ *   chat read    <thread-id>        [--limit N]
+ *   chat rename  <thread-id> <new-title>           # single rename
+ *   chat rename  --from-stdin                       # batch via JSON {items:[...]}
+ *   chat delete  <thread-id> [<thread-id>...]      # 1–25 ids, --yes to skip prompt
+ *   chat delete  --ids id1,id2,id3                  # comma-separated form
  */
 import type { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
@@ -67,6 +72,12 @@ const api = {
   readPastChat: makeFunctionReference<"query">(
     "functions/chat:readPastChat",
   ),
+  renameThreads: makeFunctionReference<"mutation">(
+    "functions/chat:renameThreads",
+  ),
+  deleteThreads: makeFunctionReference<"mutation">(
+    "functions/chat:deleteThreads",
+  ),
 };
 
 function commonArgs(ctx: ChatCliContext) {
@@ -84,6 +95,14 @@ async function callQuery(
   return ctx.convex.query(fn, { ...args, ...commonArgs(ctx) } as never);
 }
 
+async function callMutation(
+  ctx: ChatCliContext,
+  fn: Parameters<ConvexHttpClient["mutation"]>[0],
+  args: Record<string, unknown> = {},
+): Promise<unknown> {
+  return ctx.convex.mutation(fn, { ...args, ...commonArgs(ctx) } as never);
+}
+
 function out(ctx: ChatCliContext, value: unknown): void {
   if (ctx.jsonOutput) {
     console.log(JSON.stringify(value, null, 2));
@@ -108,6 +127,19 @@ Full-text search across past chat messages (own + shared):
 Read messages from a specific past chat thread:
   dench chat read <thread-id> [--limit N] [--json]
 
+Rename one or more past chat threads (own + shared):
+  dench chat rename <thread-id> <new-title> [--json]
+  dench chat rename --from-stdin [--json]
+    Reads JSON {"items":[{"threadId":"...","title":"..."}, ...]} from stdin.
+    Up to 50 items per call. Titles are trimmed and clamped to 200 chars.
+
+PERMANENTLY delete one or more past chat threads (and all their messages):
+  dench chat delete <thread-id> [<thread-id>...] [--yes] [--json]
+  dench chat delete --ids id1,id2,id3 [--yes] [--json]
+    Up to 25 ids per call. IRREVERSIBLE — the messages are removed too.
+    Without --yes, the CLI prompts for confirmation when stdin is a TTY.
+    In non-interactive contexts (sandboxes, scripts), --yes is required.
+
 Spawn a new chat-turn workflow (same agent loop as the web UI):
   dench chat new "<prompt>" [--model <m>] [--file-context <path>] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]
   dench chat send <thread-id> "<message>" [--model <m>] [--yolo] [--follow] [--json]
@@ -163,6 +195,11 @@ export async function runChatCommand(opts: {
       return await runChatReadCommand(ctx);
     case "tree":
       return await runChatTreeCommand(ctx);
+    case "rename":
+      return await runChatRenameCommand(ctx);
+    case "delete":
+    case "rm":
+      return await runChatDeleteCommand(ctx);
     default:
       throw new ChatCliError(`Unknown chat subcommand: ${subcommand}`);
   }
@@ -222,6 +259,176 @@ async function runChatReadCommand(ctx: ChatCliContext): Promise<void> {
   );
 }
 
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) {
+    throw new ChatCliError(
+      "--from-stdin requires JSON piped on stdin (got TTY).",
+    );
+  }
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function runChatRenameCommand(ctx: ChatCliContext): Promise<void> {
+  const fromStdin = hasFlag(ctx.args, "--from-stdin");
+  let items: Array<{ threadId: string; title: string }>;
+  if (fromStdin) {
+    const raw = (await readStdin()).trim();
+    if (!raw) {
+      throw new ChatCliError(
+        'Empty --from-stdin payload; expected {"items":[...]}.',
+      );
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new ChatCliError(
+        `Invalid JSON on stdin: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+    if (
+      !parsed ||
+      typeof parsed !== "object" ||
+      !Array.isArray((parsed as { items?: unknown }).items)
+    ) {
+      throw new ChatCliError(
+        'Stdin JSON must be {"items":[{"threadId":"...","title":"..."}]}.',
+      );
+    }
+    const rawItems = (parsed as { items: unknown[] }).items;
+    items = rawItems.map((entry, index) => {
+      if (
+        !entry ||
+        typeof entry !== "object" ||
+        typeof (entry as { threadId?: unknown }).threadId !== "string" ||
+        typeof (entry as { title?: unknown }).title !== "string"
+      ) {
+        throw new ChatCliError(
+          `items[${index}] must be { threadId: string, title: string }.`,
+        );
+      }
+      const item = entry as { threadId: string; title: string };
+      if (!item.threadId.trim()) {
+        throw new ChatCliError(`items[${index}].threadId is empty.`);
+      }
+      if (!item.title.trim()) {
+        throw new ChatCliError(`items[${index}].title is empty.`);
+      }
+      return { threadId: item.threadId.trim(), title: item.title };
+    });
+  } else {
+    const threadId = shift(ctx.args, "thread id").trim();
+    const titleParts: string[] = [];
+    while (ctx.args.length > 0) {
+      const next = ctx.args.shift();
+      if (next === undefined) break;
+      if (next.startsWith("--")) {
+        ctx.args.unshift(next);
+        break;
+      }
+      titleParts.push(next);
+    }
+    const title = titleParts.join(" ").trim();
+    if (!title) {
+      throw new ChatCliError(
+        "Usage: dench chat rename <thread-id> <new-title>",
+      );
+    }
+    items = [{ threadId, title }];
+  }
+  if (items.length === 0) {
+    throw new ChatCliError("Nothing to rename.");
+  }
+  if (items.length > 50) {
+    throw new ChatCliError(
+      `Too many items (${items.length}); the server caps each call at 50.`,
+    );
+  }
+  out(ctx, await callMutation(ctx, api.renameThreads, { items }));
+}
+
+async function promptYesNo(question: string): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
+  process.stdout.write(`${question} [y/N] `);
+  return new Promise<boolean>((resolve) => {
+    const onData = (chunk: Buffer) => {
+      const answer = chunk.toString("utf8").trim().toLowerCase();
+      cleanup();
+      resolve(answer === "y" || answer === "yes");
+    };
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      try {
+        process.stdin.pause();
+      } catch {
+        // ignore: stdin may already be closed.
+      }
+    };
+    process.stdin.resume();
+    process.stdin.once("data", onData);
+  });
+}
+
+async function runChatDeleteCommand(ctx: ChatCliContext): Promise<void> {
+  const idsFlag = getFlag(ctx.args, "--ids");
+  const skipConfirm = hasFlag(ctx.args, "--yes") || hasFlag(ctx.args, "-y");
+  const collected: string[] = [];
+  if (idsFlag) {
+    for (const part of idsFlag.split(",")) {
+      const trimmed = part.trim();
+      if (trimmed) collected.push(trimmed);
+    }
+  }
+  while (ctx.args.length > 0) {
+    const next = ctx.args.shift();
+    if (next === undefined) break;
+    if (next.startsWith("--")) {
+      ctx.args.unshift(next);
+      break;
+    }
+    if (next.trim()) collected.push(next.trim());
+  }
+  const seen = new Set<string>();
+  const threadIds = collected.filter((id) => {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+  if (threadIds.length === 0) {
+    throw new ChatCliError(
+      "Usage: dench chat delete <thread-id> [<thread-id>...]  (or --ids id1,id2,...)",
+    );
+  }
+  if (threadIds.length > 25) {
+    throw new ChatCliError(
+      `Too many thread ids (${threadIds.length}); the server caps each call at 25. Run multiple invocations.`,
+    );
+  }
+  if (!skipConfirm) {
+    if (!process.stdin.isTTY) {
+      throw new ChatCliError(
+        "Refusing to delete without --yes in non-interactive mode (no TTY).",
+      );
+    }
+    const ok = await promptYesNo(
+      `PERMANENTLY delete ${threadIds.length} chat${
+        threadIds.length === 1 ? "" : "s"
+      } and all their messages?`,
+    );
+    if (!ok) {
+      console.error("Aborted.");
+      return;
+    }
+  }
+  out(ctx, await callMutation(ctx, api.deleteThreads, { threadIds }));
+}
+
 /**
  * `dench chat tree [<root-thread-id>] [--limit N] [--json]` — print the
  * parent-child chat thread hierarchy rooted at the given thread (or

package/cron.ts

@@ -5,10 +5,12 @@
  * Each cron is a row in the Convex `triggers` table that, when due,
  * spawns a fresh chat thread (the `target: "chat_turn"` path — new
  * default) running in YOLO mode and seeded with the cron's prompt as
- * the first user message. The Vercel cron dispatcher (`/api/cron/dispatch`,
- * scheduled via `vercel.json` at every minute) walks the
- * `by_enabled_nextFireAt` index, claims due rows, and fires the
- * workflow.
+ * the first user message. Scheduling is owned by the
+ * `@convex-dev/crons` component: each create/update/enable mutation
+ * registers a component cron under name=triggerId; the component fires
+ * `internal.functions.triggersNode.fireDenchTrigger` at the precise
+ * scheduled time, which then POSTs to `/api/runs/spawn-{chat,child}`
+ * to start the workflow.
  *
  * Auth: prefers the unified Dench API key from `DENCH_API_KEY`
  * (sandbox envVar baked at create time). Falls back to `dench login`
@@ -504,6 +506,8 @@ async function runHistory(ctx: CronCliContext): Promise<void> {
 
 function cronHelp(): void {
   console.log(`Usage: dench cron <subcommand>
+       dench routine <subcommand>     (alias)
+       dench routines <subcommand>    (alias)
 
 Browse:
   dench cron list [--enabled-only] [--json]

package/dench.ts

@@ -492,6 +492,10 @@ Past chat threads (own + shared in this workspace):
   dench chat list [--query <substr>] [--limit N] [--include-archived] [--json]
   dench chat search "<query>" [--limit N] [--include-current] [--json]
   dench chat read <thread-id> [--limit N] [--json]
+  dench chat rename <thread-id> <new-title> [--json]
+  dench chat rename --from-stdin [--json]            (batch via JSON {items:[...]})
+  dench chat delete <thread-id> [<thread-id>...] [--yes] [--json]
+  dench chat delete --ids id1,id2 [--yes] [--json]   (PERMANENTLY deletes threads)
 
 Spawn a new chat-turn workflow (same as the web UI):
   dench chat new "<prompt>" [--model <m>] [--file-context <path>] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]
@@ -534,6 +538,20 @@ Subagents (Daytona-native rewrite):
 
   dench --version
 
+Self-updating agent harness (OpenClaw parity):
+  dench identity show | edit                    IDENTITY.md (org-wide)
+  dench organisation show | edit                ORGANISATION.md
+  dench user show | edit                        USER.md (per-member)
+  dench tools show | edit                       TOOLS.md notes section
+  dench mem show | append "<text>" | set        MEMORY.md aggregate
+  dench heartbeat status | enable | disable
+                  | interval <30m|1h|…> | instructions
+  dench bootstrap status | complete | reopen | template
+  dench model default <id|clear>
+  dench model thread <threadId> <id|clear>
+  dench daily today | show <YYYY-MM-DD>
+  Help: dench identity help
+
 External tools:
   dench apps is an alias for dench tool status -- it lists connected apps.
   dench tool with no subcommand prints tool help.
@@ -1794,30 +1812,6 @@ async function getRuntime() {
       });
     }
 
-    // Sandbox session-mode path: workflow minting provisions a real
-    // dch_agent_* token at sandbox-create time. Prefer it over apiKey so
-    // agentWorkspace.* commands (Composio tools) work inside sandboxes.
-    const sandboxAgentToken = process.env.DENCH_AGENT_SESSION_TOKEN?.trim();
-    const sandboxConvexUrl = resolveApiKeyConvexUrl();
-    if (sandboxAgentToken && sandboxConvexUrl) {
-      const orgId = process.env.DENCH_ORG_ID?.trim();
-      const orgSlug = process.env.DENCH_ORG_SLUG?.trim();
-      const apiHost =
-        process.env.DENCH_API_URL?.trim() ||
-        process.env.DENCH_INTERNAL_BASE?.trim() ||
-        host;
-      return {
-        mode: "session" as const,
-        host: apiHost,
-        client: new ConvexHttpClient(sandboxConvexUrl),
-        sessionToken: sandboxAgentToken,
-        organization:
-          orgId && orgSlug
-            ? { id: orgId, name: orgSlug, slug: orgSlug }
-            : undefined,
-      };
-    }
-
     // Sandbox / automation path: the unified Dench API key + Convex URL
     // baked into sandbox envVars (see
     // src/lib/secrets/sandbox-tokens.ts) is enough to drive every
@@ -3713,8 +3707,11 @@ async function main() {
     return;
   }
 
-  if (command === "cron") {
-    const subArgs = args.slice(args.indexOf("cron") + 1);
+  // `dench routine` / `dench routines` are UI-friendly aliases for
+  // `dench cron`. Same dispatch, same auth, same handler — only the
+  // top-level command name differs to match the workspace UI rename.
+  if (command === "cron" || command === "routine" || command === "routines") {
+    const subArgs = args.slice(args.indexOf(command) + 1);
     const sub = subArgs[0];
     // Help is a no-auth path so users can read the surface without a
     // session — mirrors `dench crm help`.
@@ -3733,7 +3730,10 @@ async function main() {
     // bearer prefix and resolves the org for both. The Bearer token
     // must carry `crons:read` (queries) or `crons:write` (mutations)
     // scope, or the wildcard `*`.
-    const authedRuntime = requireAuthenticatedRuntime(runtime, "dench cron");
+    const authedRuntime = requireAuthenticatedRuntime(
+      runtime,
+      `dench ${command}`,
+    );
     await runCronCommand({
       convex: authedRuntime.client,
       args: subArgs,
@@ -3742,6 +3742,85 @@ async function main() {
     return;
   }
 
+  // ── OpenClaw-parity self-update CLI surface ──────────────────────────
+  //
+  // Dispatch all `dench identity / organisation / user / tools / mem /
+  // heartbeat / bootstrap / model / daily` traffic through the shared
+  // agent-config CLI module. Each command requires the same auth shape
+  // as `dench cron` (Bearer DENCH_API_KEY or `dench login` session
+  // token) so server-side `requireCronAccess` accepts both.
+  const AGENT_CONFIG_COMMANDS = new Set([
+    "identity",
+    "organisation",
+    "user",
+    "tools",
+    "mem",
+    "heartbeat",
+    "bootstrap",
+    "model",
+    "daily",
+  ]);
+  if (AGENT_CONFIG_COMMANDS.has(command)) {
+    const subArgs = args.slice(args.indexOf(command) + 1);
+    if (
+      subArgs[0] === "help" ||
+      subArgs.includes("--help") ||
+      subArgs.includes("-h")
+    ) {
+      const { printAgentConfigCliHelp } = await import("./agent-config");
+      printAgentConfigCliHelp();
+      return;
+    }
+    const runtime = await getRuntime();
+    const authedRuntime = requireAuthenticatedRuntime(
+      runtime,
+      `dench ${command}`,
+    );
+    const ctxBase = {
+      convex: authedRuntime.client,
+      args: subArgs,
+      jsonOutput: json,
+      sessionToken: authedRuntime.sessionToken,
+    };
+    const mod = await import("./agent-config");
+    if (command === "identity") {
+      await mod.runIdentityCommand(ctxBase);
+      return;
+    }
+    if (command === "organisation") {
+      await mod.runOrganisationCommand(ctxBase);
+      return;
+    }
+    if (command === "user") {
+      await mod.runUserCommand(ctxBase);
+      return;
+    }
+    if (command === "tools") {
+      await mod.runToolsCommand(ctxBase);
+      return;
+    }
+    if (command === "mem") {
+      await mod.runMemoryAggregateCommand(ctxBase);
+      return;
+    }
+    if (command === "heartbeat") {
+      await mod.runHeartbeatCommand(ctxBase);
+      return;
+    }
+    if (command === "bootstrap") {
+      await mod.runBootstrapCommand(ctxBase);
+      return;
+    }
+    if (command === "model") {
+      await mod.runModelCommand(ctxBase);
+      return;
+    }
+    if (command === "daily") {
+      await mod.runDailyCommand(ctxBase);
+      return;
+    }
+  }
+
   if (command === "login") {
     await login();
     return;

package/package.json

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