@dench.com/cli 2.8.3 → 2.8.5-staging.175

package/lib/levenshtein.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared Levenshtein edit-distance helper for CLI "did you mean …?"
+ * suggestions. Lives in cli/lib so `dench crm`, `dench apps`, and any
+ * other hand-rolled dispatcher can suggest the closest known verb
+ * instead of dead-ending on `Unknown subcommand: entires`.
+ */
+
+export function levenshteinDistance(a: string, b: string): number {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  let curr = new Array<number>(b.length + 1);
+  for (let i = 1; i <= a.length; i += 1) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}
+
+/**
+ * Return the candidate closest to `input` (case-insensitive), or null
+ * when nothing is plausibly a typo. Exact case-insensitive matches win
+ * outright; otherwise the best candidate must be within
+ * max(2, floor(len/2)) edits — same threshold the CRM field
+ * suggester has used in production.
+ */
+export function closestMatch(
+  input: string,
+  candidates: readonly string[],
+): string | null {
+  const lower = input.toLowerCase();
+  const caseMatch = candidates.find(
+    (candidate) => candidate.toLowerCase() === lower,
+  );
+  if (caseMatch) return caseMatch;
+  let best: string | null = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(lower, candidate.toLowerCase());
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  const threshold = Math.max(2, Math.floor(input.length / 2));
+  return best !== null && bestDistance <= threshold ? best : null;
+}

package/package.json

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

package/tools.ts

@@ -7,10 +7,14 @@
  * paid-workspace gateway key resolved from the active agent session by
  * the top-level dispatcher.
  *
- * The one exception is the connection LISTING, which is not a pure gateway
- * passthrough: Gmail, Outlook, Calendar and LinkedIn are brokered by Dench
- * through Unipile, not Composio, so `status` also reads them from Convex and
- * merges the two into one list. See `fetchUnipileConnections`.
+ * Two exceptions are not pure gateway passthroughs:
+ *   - the connection LISTING: Gmail, Outlook, Calendar and LinkedIn (Unipile)
+ *     and Slack (Dench's in-house Slack app) are brokered by Dench, not
+ *     Composio, so `status` also reads them from Convex and merges the two
+ *     into one list. See `fetchUnipileConnections`.
+ *   - `connect slack`: prints the in-house Slack install URL
+ *     (`/api/slack/install?slug=…`) instead of a Composio OAuth redirect —
+ *     the in-house connection always takes preference over Composio Slack.
  *
  * Subcommands:
  *
@@ -65,6 +69,13 @@ export type ToolCliContext = {
    */
   convex?: ConvexHttpClient;
   sessionToken?: string;
+  /**
+   * The session's app host + workspace slug, when the dispatcher knows them.
+   * Used to build first-party links (the in-house Slack install URL) against
+   * the RIGHT tier — a staging session must not print a production URL.
+   */
+  appOrigin?: string;
+  workspaceSlug?: string;
 };
 
 type GatewayAuthContext = Pick<
@@ -549,6 +560,74 @@ async function runRunSubcommand(ctx: ToolCliContext): Promise<void> {
   console.log(redactForDisplay(payload));
 }
 
+const getAgentBillingStatusRef = makeFunctionReference<"query">(
+  "functions/agentWorkspace:getAgentBillingStatus",
+);
+
+/**
+ * The active workspace's slug, for building the in-house Slack install URL.
+ * Best-effort — a failure yields null and the caller prints a placeholder the
+ * human can fill in, rather than the whole command failing.
+ */
+async function resolveWorkspaceSlug(
+  ctx: UnipileAuthContext,
+): Promise<string | null> {
+  if (!ctx.convex) return null;
+  try {
+    const result = await ctx.convex.query(getAgentBillingStatusRef, {
+      ...(ctx.sessionToken ? { sessionToken: ctx.sessionToken } : {}),
+    } as never);
+    return stringField(asRecord(asRecord(result)?.workspace), "slug") ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Slack connects through Dench's OWN Slack app — the in-house install that
+ * powers both the messaging channel (DM / @mention the bot) and the agent
+ * SLACK_* tools. It is never connected through Composio, so `dench tool
+ * connect slack` prints the first-party OAuth install URL instead of asking
+ * the gateway for a Composio redirect. Admin-only: the URL enforces org-admin
+ * membership itself.
+ */
+async function runSlackConnectSubcommand(
+  ctx: ToolCliContext,
+  toolkit: string,
+): Promise<void> {
+  const slug = ctx.workspaceSlug?.trim() || (await resolveWorkspaceSlug(ctx));
+  const origin = (ctx.appOrigin?.trim() || resolveAppPublicOrigin()).replace(
+    /\/+$/,
+    "",
+  );
+  const redirectUrl = `${origin}/api/slack/install?slug=${
+    slug ? encodeURIComponent(slug) : "<workspace-slug>"
+  }`;
+  const message = `Connect Slack here (org admin only): ${redirectUrl}`;
+  const summary = {
+    ok: true,
+    toolkit,
+    inHouse: true,
+    redirectUrl,
+    message,
+    note:
+      "Slack is Dench's in-house integration (not Composio). One install powers " +
+      "both the Slack messaging channel and the agent SLACK_* tools " +
+      "(SLACK_SEND_MESSAGE, SLACK_FETCH_HISTORY, …).",
+  };
+  if (ctx.jsonOutput) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log(message);
+  console.log(
+    "Slack is Dench's in-house integration (not Composio). Once an admin installs it,",
+  );
+  console.log(
+    "run tools with `dench tool run SLACK_SEND_MESSAGE --args '{…}'` — see `dench tool search --toolkit slack`.",
+  );
+}
+
 async function runConnectSubcommand(ctx: ToolCliContext): Promise<void> {
   const toolkit = ctx.args[0];
   if (!toolkit || toolkit.startsWith("--")) {
@@ -557,6 +636,12 @@ async function runConnectSubcommand(ctx: ToolCliContext): Promise<void> {
     );
   }
   ctx.args.shift();
+
+  const normalizedToolkit = toolkit.trim().toLowerCase();
+  if (normalizedToolkit === "slack" || normalizedToolkit === "slackbot") {
+    await runSlackConnectSubcommand(ctx, normalizedToolkit);
+    return;
+  }
   const callbackUrl =
     getFlag(ctx.args, "--callback-url") ??
     process.env.DENCH_OAUTH_CALLBACK_URL?.trim() ??
@@ -1172,10 +1257,15 @@ Notes:
   All commands authenticate with DENCH_API_KEY or the active \`dench signin\`
   agent session. Agent sessions require a paid workspace.
   Results carry a "source". "composio" rows are brokered by Composio; "unipile"
-  rows (gmail, outlook, calendar, linkedin) are connected by Dench itself. Both
-  run through \`dench tool run\` with the same slug + --args contract; only
-  \`dench tool connect\` is Composio-only — the human connects the other four
-  from the workspace Marketplace.
+  rows (gmail, outlook, calendar, linkedin) and "dench" rows (slack) are
+  connected by Dench itself. ALL of them run through \`dench tool run\` with the
+  same slug + --args contract. \`dench tool connect slack\` prints the in-house
+  Slack install URL (org admin, one click); gmail/outlook/calendar/linkedin are
+  connected by a human from the workspace Marketplace; every other toolkit
+  connects through Composio's OAuth redirect.
+  Slack is ALWAYS in-house: SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit
+  blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through the
+  org's own Slack app install and can post to / read any channel.
   A write tool returns approval_required with an approvalId. Once a human
   approves it, re-run with --approval <approvalId>; an approval is bound to that
   exact tool and argument set.