@remogram/cli 0.1.0-beta.6 → 0.1.0-beta.8

package/cli-dispatch.js

@@ -3,6 +3,7 @@ import {
   PACKET_TYPES,
   ERROR_CODES,
   forgeError,
+  sanitizeField,
   assertGitRef,
   assertGitRemote,
   throwIfStaleHeadByNumber,
@@ -11,6 +12,15 @@ import {
   assertWriteCommandConfigured,
   parseSinceObservedAt,
   normalizeAllowedPaths,
+  assertExpectedSha,
+  buildMergeExecuteBeforeFacts,
+  collectMergeExecuteBlockers,
+  buildCrMergeBlockedBody,
+  buildCrMergedBody,
+  buildMergeExecuteAfterFacts,
+  buildMergeExecuteMergeFacts,
+  mergeExecuteViewFacts,
+  isOpenPrState,
 } from '@remogram/core';
 import { parseAllowedPathFlags, parsePositiveInt } from './cli-argv.js';
 
@@ -211,8 +221,8 @@ export async function dispatchForgeCommand({ group, sub, flags, positional, ctx,
       ctx,
       PACKET_TYPES.PR_STATUS,
       body,
-      body.head_ref,
-      body.head_sha,
+      body.forge_source_branch_ref,
+      body.forge_source_sha,
     );
     return forgePacket(PACKET_TYPES.PR_STATUS, ctx, body);
   }
@@ -229,9 +239,9 @@ export async function dispatchForgeCommand({ group, sub, flags, positional, ctx,
       throwIfStaleHeadByNumber(
         ctx,
         PACKET_TYPES.PR_CHECKS,
-        { head_sha: view.head_sha },
-        view.head_ref,
-        view.head_sha,
+        { forge_source_sha: view.forge_source_sha },
+        view.forge_source_branch_ref,
+        view.forge_source_sha,
       );
     }
     return forgePacket(
@@ -257,6 +267,183 @@ export async function dispatchForgeCommand({ group, sub, flags, positional, ctx,
       }),
     );
   }
+  if (group === 'merge' && sub === 'execute') {
+    if (typeof provider.mergeExecute !== 'function') {
+      throw Object.assign(new Error('merge execute not implemented for provider'), {
+        forgeError: forgeError(
+          ERROR_CODES.PROVIDER_UNSUPPORTED,
+          'merge execute not implemented for provider',
+        ),
+      });
+    }
+    const number = parsePositiveInt(flags.number, '--number');
+    if (number == null) {
+      throw Object.assign(new Error('--number required'), {
+        forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--number required for merge execute'),
+      });
+    }
+    if (!flags.expected_base_sha || !flags.expected_head_sha) {
+      throw Object.assign(new Error('expected SHAs required'), {
+        forgeError: forgeError(
+          ERROR_CODES.INVALID_ARGS,
+          '--expected-base-sha and --expected-head-sha required for merge execute',
+        ),
+      });
+    }
+    const method = flags.method ? String(flags.method).toLowerCase() : 'merge';
+    if (method !== 'merge') {
+      throw Object.assign(new Error('Unsupported merge method'), {
+        forgeError: forgeError(
+          ERROR_CODES.INVALID_ARGS,
+          'Only --method merge is supported in v1',
+        ),
+      });
+    }
+    const expectedBaseSha = assertExpectedSha(flags.expected_base_sha, '--expected-base-sha');
+    const expectedHeadSha = assertExpectedSha(flags.expected_head_sha, '--expected-head-sha');
+    assertWriteCommandConfigured(ctx.config, 'merge');
+
+    const view = await provider.prView(ctx, { number });
+    const checks = await provider.prChecks(ctx, { number });
+    const mergePlanBody = await provider.mergePlan(ctx, { number });
+    const expected = { baseSha: expectedBaseSha, headSha: expectedHeadSha };
+    const viewFacts = mergeExecuteViewFacts(view);
+
+    let forgeHeadRefSha = null;
+    const headRef = viewFacts.sourceBranchRef ? String(viewFacts.sourceBranchRef).trim() : '';
+    if (!headRef && isOpenPrState(view.state)) {
+      const before = buildMergeExecuteBeforeFacts(view, checks, mergePlanBody, null);
+      return forgePacket(
+        PACKET_TYPES.CR_MERGE_BLOCKED,
+        ctx,
+        buildCrMergeBlockedBody({
+          prNumber: number,
+          expected,
+          before,
+          blockers: ['head_ref_missing'],
+        }),
+        forgeError(ERROR_CODES.MERGE_BLOCKED, 'Open change request missing head branch ref'),
+      );
+    }
+    if (headRef) {
+      if (typeof provider.branchHeadSha !== 'function') {
+        const before = buildMergeExecuteBeforeFacts(view, checks, mergePlanBody, null);
+        return forgePacket(
+          PACKET_TYPES.CR_MERGE_BLOCKED,
+          ctx,
+          buildCrMergeBlockedBody({
+            prNumber: number,
+            expected,
+            before,
+            blockers: ['head_ref_unverified'],
+          }),
+          forgeError(
+            ERROR_CODES.MERGE_BLOCKED,
+            'Forge head branch verification not implemented for provider',
+          ),
+        );
+      }
+      try {
+        assertGitRef(headRef, 'head_ref');
+      } catch (err) {
+        const before = buildMergeExecuteBeforeFacts(view, checks, mergePlanBody, null);
+        return forgePacket(
+          PACKET_TYPES.CR_MERGE_BLOCKED,
+          ctx,
+          buildCrMergeBlockedBody({
+            prNumber: number,
+            expected,
+            before,
+            blockers: ['head_ref_invalid'],
+          }),
+          forgeError(
+            ERROR_CODES.INVALID_ARGS,
+            sanitizeField(err.forgeError?.message || err.message || err.invalidArgs)
+              || 'Head branch ref invalid',
+          ),
+        );
+      }
+      try {
+        forgeHeadRefSha = await provider.branchHeadSha(ctx, headRef, {
+          repoId: view.forge_source_repo_id ?? null,
+        });
+      } catch (err) {
+        const before = buildMergeExecuteBeforeFacts(view, checks, mergePlanBody, null);
+        return forgePacket(
+          PACKET_TYPES.CR_MERGE_BLOCKED,
+          ctx,
+          buildCrMergeBlockedBody({
+            prNumber: number,
+            expected,
+            before,
+            blockers: ['head_ref_unreadable'],
+          }),
+          forgeError(
+            ERROR_CODES.MERGE_BLOCKED,
+            sanitizeField(err.forgeError?.message || err.message) || 'Head branch ref unreadable',
+            err.status ?? err.forgeError?.status ?? null,
+          ),
+        );
+      }
+    }
+
+    const before = buildMergeExecuteBeforeFacts(view, checks, mergePlanBody, forgeHeadRefSha);
+    const blockers = collectMergeExecuteBlockers(
+      view,
+      checks,
+      mergePlanBody,
+      expected,
+      { forgeHeadRefSha },
+    );
+
+    if (blockers.length > 0) {
+      return forgePacket(
+        PACKET_TYPES.CR_MERGE_BLOCKED,
+        ctx,
+        buildCrMergeBlockedBody({ prNumber: number, expected, before, blockers }),
+        forgeError(ERROR_CODES.MERGE_BLOCKED, 'Merge blocked by preflight'),
+      );
+    }
+
+    try {
+      const providerResult = await provider.mergeExecute(ctx, {
+        number,
+        method,
+        expectedHeadSha: expected.headSha,
+      });
+      const merge = buildMergeExecuteMergeFacts(method, providerResult);
+      const after = buildMergeExecuteAfterFacts(view, providerResult);
+      return forgePacket(
+        PACKET_TYPES.CR_MERGED,
+        ctx,
+        buildCrMergedBody({ prNumber: number, expected, before, merge, after }),
+      );
+    } catch (err) {
+      const status = err.status ?? err.forgeError?.status ?? null;
+      const blockers =
+        Array.isArray(err.mergeBlockedBlockers) && err.mergeBlockedBlockers.length > 0
+          ? err.mergeBlockedBlockers
+          : ['merge_endpoint_failed'];
+      const fe =
+        err.forgeError
+        ?? forgeError(
+          ERROR_CODES.MERGE_ENDPOINT_FAILED,
+          sanitizeField(err.message) || 'Forge merge request failed',
+          status,
+        );
+      return forgePacket(
+        PACKET_TYPES.CR_MERGE_BLOCKED,
+        ctx,
+        buildCrMergeBlockedBody({
+          prNumber: number,
+          expected,
+          before,
+          blockers,
+        }),
+        fe,
+      );
+    }
+  }
   if (group === 'branch' && sub === 'protection') {
     const branchRef = flags.branch_ref;
     if (!branchRef) {
@@ -306,7 +493,7 @@ export async function dispatchForgeCommand({ group, sub, flags, positional, ctx,
   throw Object.assign(new Error(`Unknown command: ${positional.join(' ')}`), {
     forgeError: forgeError(
       ERROR_CODES.INVALID_ARGS,
-      'Unknown command. Try: provider capabilities, repo status, refs compare, refs inventory, cr inventory, cr files, cr comments, cr open, status set, forge changes, pr view, pr checks, merge plan, sync plan, whoami, branch protection',
+      'Unknown command. Try: provider capabilities, repo status, refs compare, refs inventory, cr inventory, cr files, cr comments, cr open, status set, forge changes, pr view, pr checks, merge plan, merge execute, sync plan, whoami, branch protection',
     ),
   });
 }

package/cli-doctor.js

@@ -4,6 +4,7 @@ import {
   gitRemoteUrl,
   parseRemoteUrl,
   trustedBaseUrl,
+  normalizedForgeOrigin,
   assertConfigMatchesRemote,
   forgePacket,
   unknownForgeContext,
@@ -132,6 +133,9 @@ export async function buildDoctorPacket(cwd, providers) {
       );
     } else {
       checks.push(doctorCheck('host_binding', 'pass', 'Configured host binding is trusted'));
+      if (config.baseUrl) {
+        ctx = { ...ctx, baseUrl: normalizedForgeOrigin(config) };
+      }
     }
   }
 

package/cli-io.js

@@ -1,15 +1,26 @@
-import { forgePacket, forgeErrorPacket, ERROR_CODES, forgeError } from '@remogram/core';
+import {
+  forgePacket,
+  forgeErrorPacket,
+  forgeError,
+  ERROR_CODES,
+  normalizedForgeOrigin,
+  trustedBaseUrl,
+} from '@remogram/core';
 
 export function output(packet, asJson) {
   console.log(JSON.stringify(packet, null, asJson ? 2 : 0));
 }
 
 export function handleError(err, ctx, asJson) {
-  const fe = err.forgeError || {
-    code: ERROR_CODES.API_ERROR,
-    message: err.message,
-    status: err.status,
-  };
+  const fe =
+    err.forgeError
+    || (err.invalidArgs
+      ? forgeError(ERROR_CODES.INVALID_ARGS, err.invalidArgs)
+      : {
+          code: ERROR_CODES.API_ERROR,
+          message: err.message,
+          status: err.status,
+        });
   const baseCtx = ctx || {
     providerId: 'unknown',
     remoteName: 'origin',
@@ -25,7 +36,7 @@ export function handleError(err, ctx, asJson) {
 }
 
 export function contextFromConfig(config, cwd, parsed = null) {
-  return {
+  const ctx = {
     providerId: config.provider,
     remoteName: config.remote,
     repoId: parsed ? `${parsed.owner}/${parsed.repo}` : `${config.owner}/${config.repo}`,
@@ -33,4 +44,8 @@ export function contextFromConfig(config, cwd, parsed = null) {
     cwd,
     parsed,
   };
+  if (config.baseUrl && (!parsed || trustedBaseUrl(config, parsed.host))) {
+    ctx.baseUrl = normalizedForgeOrigin(config);
+  }
+  return ctx;
 }

package/index.js

@@ -64,6 +64,7 @@ export async function runCli(argv, options = {}) {
   try {
     const packet = await dispatchForgeCommand({ group, sub, flags, positional, ctx, provider });
     output(packet, asJson);
+    if (!packet.ok) process.exitCode = 1;
   } catch (err) {
     handleError(err, ctx, asJson);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remogram/cli",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.8",
   "description": "Remogram forge boundary CLI",
   "type": "module",
   "license": "MIT",
@@ -27,11 +27,11 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@remogram/core": "0.1.0-beta.6",
-    "@remogram/provider-gitea-api": "0.1.0-beta.6",
-    "@remogram/provider-github-api": "0.1.0-beta.6",
-    "@remogram/provider-gitlab-api": "0.1.0-beta.6",
-    "@remogram/provider-gitea-tea": "0.1.0-beta.6",
-    "@remogram/provider-github-gh": "0.1.0-beta.6"
+    "@remogram/core": "0.1.0-beta.8",
+    "@remogram/provider-gitea-api": "0.1.0-beta.8",
+    "@remogram/provider-github-api": "0.1.0-beta.8",
+    "@remogram/provider-gitlab-api": "0.1.0-beta.8",
+    "@remogram/provider-gitea-tea": "0.1.0-beta.8",
+    "@remogram/provider-github-gh": "0.1.0-beta.8"
   }
 }