@devflow-one/cli 0.1.2 → 0.1.5

package/README.md

@@ -182,13 +182,16 @@ devflow mr ready 12 --profile prof-1
 
 ### Destructive actions
 
-`branch delete` and `mr close` are destructive. They are **refused unless you
-confirm** with `--force` (or `--yes`); the gateway enforces the same gate
-server-side, so the confirmation can't be bypassed:
+`branch delete`, `mr close` and `mr merge` are destructive. They are **refused
+unless you confirm** with `--force` (or `--yes`); the gateway enforces the same
+gate server-side, so the confirmation can't be bypassed:
 
 ```sh
 devflow branch delete old --project ABC            # refused
 devflow branch delete old --project ABC --force    # executes
+
+# merge a PR/MR, squashing and cleaning up the source branch
+devflow mr merge 42 --method squash --delete-source-branch --force
 ```
 
 Inference never softens this gate — a destructive command run with fully

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devflow-one/cli",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Terminal CLI wrapping the local DevFlow gateway so shell scripts can trigger repo actions.",
   "keywords": [
     "devflow",

package/src/args.js

@@ -4,7 +4,15 @@
 // positionals.
 
 /** Boolean flags never consume the following token. */
-const BOOLEAN_FLAGS = new Set(["json", "all", "help", "force", "yes", "no-push"]);
+const BOOLEAN_FLAGS = new Set([
+  "json",
+  "all",
+  "help",
+  "force",
+  "yes",
+  "no-push",
+  "delete-source-branch",
+]);
 
 /**
  * @param {string[]} argv the args after the node/script path

package/src/cli.js

@@ -125,12 +125,15 @@ export async function run(argv, io = {}) {
   const { key, command, rest } = match;
 
   let config;
+  let configError = null;
 
   try {
     config = resolveConfig();
   } catch (err) {
     if (!(err instanceof ConfigError)) throw err;
 
+    configError = err;
+
     // `where` is a diagnostic: it must still report what the checkout implies
     // when there is no daemon to ask, since that is exactly when it is consulted.
     if (command.method !== "LOCAL") {
@@ -149,7 +152,9 @@ export async function run(argv, io = {}) {
       queryContext: config
         ? createContextQuery(config, request)
         : async () => {
-            throw new Error("the DevFlow desktop app is not running (no gateway token).");
+            // Report only what was actually checked — the token file. Whether the
+            // app is running is unknown here, since the gateway was never called.
+            throw new Error(configError?.message ?? "no gateway token available.");
           },
     });
 

package/src/commands.js

@@ -20,6 +20,20 @@ function toInt(name, value) {
   return n;
 }
 
+/** Valid `--method` values for `mr merge`, mirroring the provider merge strategies. */
+const MERGE_METHODS = ["merge", "squash", "rebase"];
+
+/** Parse a `--method` flag into a merge strategy, or fail with the allowed set. */
+function toMergeMethod(value) {
+  const method = String(value);
+
+  if (!MERGE_METHODS.includes(method)) {
+    throw new UsageError(`"--method" must be one of ${MERGE_METHODS.join(", ")}, got "${method}".`);
+  }
+
+  return method;
+}
+
 /** Parse a `--values` JSON-object flag into a plain object, or fail clearly. */
 function toValues(flag, raw) {
   if (raw === undefined) return undefined;
@@ -144,6 +158,20 @@ const COMMANDS = {
     usage: "mr close <prId> [--issue KEY] [--project KEY] --force",
     buildArgs: ([prId]) => [toInt("prId", prId)],
   },
+  "mr merge": {
+    method: "POST",
+    action: "mergePullRequest",
+    destructive: true,
+    usage:
+      "mr merge <prId> [--method merge|squash|rebase] [--delete-source-branch] " +
+      "[--issue KEY] [--project KEY] --force",
+    buildArgs: ([prId], flags) => {
+      const mergeMethod = flags.method === undefined ? undefined : toMergeMethod(flags.method);
+      const deleteSourceBranch = flags["delete-source-branch"] ? true : undefined;
+
+      return [toInt("prId", prId), { mergeMethod, deleteSourceBranch }];
+    },
+  },
   "mr assign": {
     method: "POST",
     action: "assignPr",

package/src/config.js

@@ -1,18 +1,12 @@
 // Resolves how the CLI reaches the local gateway: base URL (port) and the Bearer
-// token. The token is read from the same userData dir the desktop daemon writes it
-// to (see desktop/src/gateway/token.js) so scripts "just work" with no setup. Env
-// vars override for tests / non-standard installs.
+// token. Path/port resolution lives in the generated gatewayDataDir.js copy
+// (authored at shared/gatewayDataDir.js) so the CLI, the MCP server and the
+// desktop daemon can never disagree about where the token lives. Env vars
+// override for tests / non-standard installs.
 
 import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
 
-/** Loopback host — the gateway only ever binds 127.0.0.1. */
-const HOST = "127.0.0.1";
-/** Default gateway port (matches desktop server DEFAULT_PORT). */
-const DEFAULT_PORT = 8787;
-/** Token filename under the app's userData dir (matches token.js TOKEN_FILE). */
-const TOKEN_FILE = "gateway-token";
+import { describeMissingToken, resolveGatewayBaseUrl, resolveTokenPath } from "./gatewayDataDir.js";
 
 /** A tagged config-resolution failure, so the CLI can print a clear message. */
 export class ConfigError extends Error {
@@ -22,38 +16,9 @@ export class ConfigError extends Error {
   }
 }
 
-/**
- * The daemon's userData dir, matching desktop/src/gateway/token.js's fallback
- * (the CLI runs under plain node, never Electron, so it always uses the fallback).
- * @returns {string}
- */
-function resolveDataDir() {
-  const home = os.homedir();
-
-  if (process.platform === "darwin") {
-    return path.join(home, "Library", "Application Support", "devflow");
-  }
-
-  if (process.platform === "win32") {
-    const base = process.env.APPDATA || path.join(home, "AppData", "Roaming");
-
-    return path.join(base, "devflow");
-  }
-
-  return path.join(home, ".config", "devflow");
-}
-
-/** Resolve the gateway port from `DEVFLOW_GATEWAY_PORT`, else the default. */
-function resolvePort() {
-  const port = Number.parseInt(process.env.DEVFLOW_GATEWAY_PORT, 10);
-
-  return Number.isInteger(port) && port > 0 && port < 65536 ? port : DEFAULT_PORT;
-}
-
 /**
  * Read the gateway token: `DEVFLOW_GATEWAY_TOKEN` wins, else the token file the
- * daemon persisted. Throws {@link ConfigError} with an actionable message when
- * neither is available.
+ * daemon persisted. Throws {@link ConfigError} naming the exact path probed.
  * @returns {string}
  */
 function resolveToken() {
@@ -61,23 +26,20 @@ function resolveToken() {
 
   if (fromEnv) return fromEnv;
 
-  const tokenPath = path.join(resolveDataDir(), TOKEN_FILE);
+  const tokenPath = resolveTokenPath();
+  let contents;
 
   try {
-    const token = fs.readFileSync(tokenPath, "utf8").trim();
+    contents = fs.readFileSync(tokenPath, "utf8");
+  } catch {
+    throw new ConfigError(describeMissingToken(tokenPath, "missing"));
+  }
 
-    if (token) return token;
+  const token = contents.trim();
 
-    throw new ConfigError(`Gateway token file is empty: ${tokenPath}`);
-  } catch (err) {
-    if (err instanceof ConfigError) throw err;
+  if (!token) throw new ConfigError(describeMissingToken(tokenPath, "empty"));
 
-    throw new ConfigError(
-      `Could not read the gateway token at ${tokenPath}. ` +
-        `Is the DevFlow desktop app running? ` +
-        `(Or set DEVFLOW_GATEWAY_TOKEN to override.)`,
-    );
-  }
+  return token;
 }
 
 /**
@@ -85,10 +47,8 @@ function resolveToken() {
  * @returns {{ baseUrl: string, token: string }}
  */
 export function resolveConfig() {
-  const port = resolvePort();
-
   return {
-    baseUrl: `http://${HOST}:${port}`,
+    baseUrl: resolveGatewayBaseUrl(),
     token: resolveToken(),
   };
 }

package/src/gatewayDataDir.js

@@ -0,0 +1,86 @@
+// GENERATED FILE — do not edit.
+// Source of truth: shared/gatewayDataDir.js. Regenerate with:
+//   node scripts/sync-context-resolver.mjs
+
+// Where the desktop daemon keeps its gateway state (bearer token, routing mirror),
+// and where the CLI and MCP server read it back from. Authored once here because
+// three independent copies of this logic is exactly how the clients ended up
+// reading a directory the app never wrote to.
+//
+// The daemon itself resolves via Electron's `app.getPath("userData")`; this module
+// is that path's plain-node equivalent. Electron derives userData from the app's
+// package `name`, so APP_DIR_NAME must track `desktop/package.json`'s `name`.
+
+import path from "node:path";
+import os from "node:os";
+
+/** Matches `desktop/package.json` `name` — Electron's userData dir is `<appData>/<name>`. */
+export const APP_DIR_NAME = "devflow";
+
+/** Filename the daemon writes the gateway token to, under the data dir. */
+export const TOKEN_FILE = "gateway-token";
+
+/** Default gateway port — must match desktop/src/gateway/server.js. */
+export const DEFAULT_PORT = 8787;
+
+/** Loopback host; the gateway only ever binds 127.0.0.1. */
+export const HOST = "127.0.0.1";
+
+/**
+ * Resolve the daemon's data dir for the current platform.
+ * `DEVFLOW_GATEWAY_DATA_DIR` overrides, so tests never touch real user data.
+ * @returns {string} absolute directory path
+ */
+export function resolveGatewayDataDir() {
+  if (process.env.DEVFLOW_GATEWAY_DATA_DIR) return process.env.DEVFLOW_GATEWAY_DATA_DIR;
+
+  const home = os.homedir();
+
+  if (process.platform === "darwin") {
+    return path.join(home, "Library", "Application Support", APP_DIR_NAME);
+  }
+
+  if (process.platform === "win32") {
+    const base = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+
+    return path.join(base, APP_DIR_NAME);
+  }
+
+  return path.join(home, ".config", APP_DIR_NAME);
+}
+
+/** Absolute path of the gateway token file. */
+export function resolveTokenPath() {
+  return path.join(resolveGatewayDataDir(), TOKEN_FILE);
+}
+
+/** Resolve the gateway port from `DEVFLOW_GATEWAY_PORT`, else {@link DEFAULT_PORT}. */
+export function resolveGatewayPort() {
+  const parsed = Number.parseInt(process.env.DEVFLOW_GATEWAY_PORT ?? "", 10);
+
+  return Number.isInteger(parsed) && parsed > 0 && parsed < 65536 ? parsed : DEFAULT_PORT;
+}
+
+/** Gateway base URL, honouring `DEVFLOW_GATEWAY_PORT`. */
+export function resolveGatewayBaseUrl() {
+  return `http://${HOST}:${resolveGatewayPort()}`;
+}
+
+/**
+ * Message for "the token file isn't readable". States only what was checked —
+ * the probed path — and never asserts why, since nothing here touches the network.
+ * @param {string} tokenPath
+ * @param {"missing" | "empty"} [reason]
+ */
+export function describeMissingToken(tokenPath, reason = "missing") {
+  const what =
+    reason === "empty"
+      ? `The gateway token file at ${tokenPath} is empty.`
+      : `No gateway token file at ${tokenPath}.`;
+
+  return (
+    `${what} That file is written by the DevFlow desktop app on first run. ` +
+    `Set DEVFLOW_GATEWAY_TOKEN to use a token from elsewhere, or ` +
+    `DEVFLOW_GATEWAY_DATA_DIR if the app stores its data in another location.`
+  );
+}