@dench.com/cli 0.2.0

package/host.ts

@@ -0,0 +1,44 @@
+export const PRODUCTION_HOST = "https://dench.dev";
+export const STAGING_HOST = "https://workspace-staging.dench.com";
+export const DEFAULT_HOST = PRODUCTION_HOST;
+
+function optionFromArgs(args: string[], name: string) {
+  const index = args.indexOf(name);
+  if (index === -1) return undefined;
+  return args[index + 1];
+}
+
+function hasFlag(args: string[], name: string) {
+  return args.includes(name);
+}
+
+export function normalizeHost(input: string) {
+  const withProtocol = /^https?:\/\//.test(input) ? input : `https://${input}`;
+  const url = new URL(withProtocol);
+  return url.origin;
+}
+
+export function isLocalHost(input: string) {
+  const hostname = new URL(normalizeHost(input)).hostname;
+  return (
+    hostname === "localhost" ||
+    hostname === "127.0.0.1" ||
+    hostname === "0.0.0.0" ||
+    hostname === "::1" ||
+    hostname.endsWith(".localhost")
+  );
+}
+
+export function resolveHostFromArgs(
+  args: string[],
+  configHost?: string,
+  envHost = process.env.DENCH_HOST,
+) {
+  if (hasFlag(args, "--prod")) return PRODUCTION_HOST;
+  if (hasFlag(args, "--staging")) return STAGING_HOST;
+
+  const explicit = optionFromArgs(args, "--host") ?? envHost;
+  if (explicit) return normalizeHost(explicit);
+  if (configHost) return normalizeHost(configHost);
+  return DEFAULT_HOST;
+}

package/lib/cli-args.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared CLI argument-parsing helpers used by `dench crm` + `dench agent`.
+ *
+ * Both CLI surfaces hand-parse argv slices (we deliberately avoid pulling
+ * in commander/yargs to keep the cli bundle small). These helpers are the
+ * tiny abstraction across both:
+ *   - shift(args, expected): pop the next positional arg or throw.
+ *   - getFlag(args, name): pull the value following `--name` and remove
+ *     both tokens from args. Returns undefined if the flag is missing.
+ *   - hasFlag(args, name): true iff `--name` appears (and removes it).
+ *   - parseJson(value): JSON.parse with a CliError-style throw on
+ *     failure.
+ *
+ * NOTE: each module wraps its own *CliError class so we don't import
+ * across cli/ entry points; this module's errors throw plain Error and
+ * the caller adapts.
+ */
+
+export class CliArgError extends Error {}
+
+export function shift(args: string[], expected: string): string {
+  const value = args.shift();
+  if (!value) throw new CliArgError(`Missing ${expected}`);
+  return value;
+}
+
+export function getFlag(
+  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;
+}
+
+export function hasFlag(args: string[], name: string): boolean {
+  const idx = args.indexOf(name);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  return true;
+}
+
+export function parseJson(value: string | undefined): unknown {
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CliArgError(`Invalid JSON: ${value}`);
+  }
+}

package/openUrl.ts

@@ -0,0 +1,120 @@
+import { spawn as nodeSpawn, type SpawnOptions } from "node:child_process";
+import { platform as nodePlatform } from "node:os";
+
+type SpawnedProcess = {
+  once(
+    event: "spawn" | "error",
+    listener: (error?: Error) => void,
+  ): SpawnedProcess;
+  unref(): void;
+};
+
+export type SpawnLike = (
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+) => SpawnedProcess;
+
+export type OpenUrlResult =
+  | { status: "opened"; command: string; args: string[] }
+  | { status: "skipped"; reason: string }
+  | { status: "failed"; command: string; args: string[]; error: string };
+
+type OpenUrlOptions = {
+  noOpen?: boolean;
+  json?: boolean;
+  env?: Record<string, string | undefined>;
+  platform?: NodeJS.Platform;
+  spawn?: SpawnLike;
+};
+
+function truthyEnv(value: string | undefined) {
+  if (!value) return false;
+  return !["0", "false", "no"].includes(value.trim().toLowerCase());
+}
+
+function disabledReason(options: OpenUrlOptions) {
+  if (options.noOpen) return "--no-open";
+  if (options.json) return "--json";
+  if (truthyEnv(options.env?.DENCH_NO_OPEN)) return "DENCH_NO_OPEN";
+  if (truthyEnv(options.env?.CI)) return "CI";
+  if (
+    ["none", "false"].includes(options.env?.BROWSER?.trim().toLowerCase() ?? "")
+  ) {
+    return "BROWSER";
+  }
+  return undefined;
+}
+
+function openerCommand(url: string, currentPlatform: NodeJS.Platform) {
+  if (currentPlatform === "darwin") {
+    return { command: "open", args: [url] };
+  }
+  if (currentPlatform === "win32") {
+    return { command: "cmd", args: ["/c", "start", "", url] };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+
+export async function openUrl(
+  url: string,
+  options: OpenUrlOptions = {},
+): Promise<OpenUrlResult> {
+  const reason = disabledReason(options);
+  if (reason) return { status: "skipped", reason };
+
+  const { command, args } = openerCommand(
+    url,
+    options.platform ?? nodePlatform(),
+  );
+  const spawn = options.spawn ?? (nodeSpawn as SpawnLike);
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (result: OpenUrlResult) => {
+      if (!settled) {
+        settled = true;
+        resolve(result);
+      }
+    };
+
+    try {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+      });
+      child.once("error", (error) =>
+        settle({
+          status: "failed",
+          command,
+          args,
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      );
+      child.once("spawn", () => {
+        child.unref();
+        settle({ status: "opened", command, args });
+      });
+    } catch (error) {
+      settle({
+        status: "failed",
+        command,
+        args,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  });
+}
+
+export function formatApprovalOpenMessage(url: string, result: OpenUrlResult) {
+  if (result.status === "opened") {
+    return `Attempted to open Dench approval link in your browser. If it did not open, use this link: ${url}`;
+  }
+  if (result.status === "failed") {
+    return `Could not open browser automatically. Open this Dench approval link: ${url}`;
+  }
+  if (result.reason === "--no-open") {
+    return `Open this Dench approval link: ${url}`;
+  }
+  return `Automatic browser open is disabled (${result.reason}). Open this Dench approval link: ${url}`;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@dench.com/cli",
+  "version": "0.2.0",
+  "description": "Dench agent workspace CLI.",
+  "type": "module",
+  "bin": {
+    "dench": "dench",
+    "dench-fs-daemon": "fs-daemon"
+  },
+  "files": [
+    "dench",
+    "dench.mjs",
+    "dench.ts",
+    "fs-daemon",
+    "fs-daemon.ts",
+    "crm.ts",
+    "agentKind.ts",
+    "host.ts",
+    "openUrl.ts",
+    "session.ts",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "convex": "1.34.0",
+    "tsx": "^4.21.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}