@rpcbase/cli 0.120.0 → 0.122.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/cli",
-  "version": "0.120.0",
+  "version": "0.122.0",
   "type": "module",
   "main": "./index.js",
   "bin": {

package/src/cmd-deploy/detect-compose-changes.js

@@ -0,0 +1,157 @@
+import crypto from "crypto"
+import fs from "fs"
+import os from "os"
+import path from "path"
+import { execSync } from "child_process"
+
+
+export const baseExcludeList = [
+  ".husky/",
+  ".github/",
+  ".git/",
+  ".wireit/",
+  "coverage/",
+  "node_modules/",
+  "infrastructure/data/",
+  ".gitignore",
+  "*.css.map",
+  // "*.env*",
+  // "*.js.map",
+  "*.md",
+]
+
+const hashTree = (rootDir) => {
+  const fileHashes = {}
+
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        walk(fullPath)
+      } else {
+        const rel = path.relative(rootDir, fullPath)
+        const content = fs.readFileSync(fullPath)
+        const digest = crypto.createHash("sha256").update(content).digest("hex")
+        fileHashes[rel] = digest
+      }
+    }
+  }
+
+  walk(rootDir)
+
+  const aggregate = crypto.createHash("sha256")
+  Object.keys(fileHashes).sort().forEach((rel) => {
+    aggregate.update(rel)
+    aggregate.update("\0")
+    aggregate.update(fileHashes[rel])
+    aggregate.update("\0")
+  })
+
+  return {
+    treeHash: aggregate.digest("hex"),
+    fileHashes,
+  }
+}
+
+const buildRsyncCmd = ({ includeArgs, excludeArgs, keyPath, source, dest, remote }) => {
+  const parts = [
+    "rsync -az --delete --filter=':- .gitignore'",
+    includeArgs.join(" "),
+    excludeArgs,
+    remote ? `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"` : null,
+    source,
+    dest,
+  ].filter(Boolean)
+
+  return parts.join(" ")
+}
+
+const runRsync = (cmd) => {
+  try {
+    execSync(cmd, { stdio: "ignore" })
+  } catch (err) {
+    const allowed = [23, 24]
+    if (!allowed.includes(err?.status)) throw err
+  }
+}
+
+// Pull remote compose files into a temp dir, mirror local ones into another, then hash trees to detect diffs.
+// This is informational only; callers should treat errors as non-blocking.
+export const detectComposeChanges = ({ keyPath, user, host, deployDir, log, extraExcludes = [] }) => {
+  const includeArgs = ["--include='*/'", "--include='*compose*.yml'", "--exclude='*'"]
+  const excludeArgs = baseExcludeList
+    .concat(extraExcludes)
+    .map((p) => `--exclude='${p}'`)
+    .join(" ")
+
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rb-compose-"))
+  const remoteDir = path.join(tempRoot, "remote")
+  const localDir = path.join(tempRoot, "local")
+  fs.mkdirSync(remoteDir)
+  fs.mkdirSync(localDir)
+
+  const cleanup = () => {
+    try {
+      fs.rmSync(tempRoot, { recursive: true, force: true })
+    } catch (err) {
+      console.warn(`Cleanup failed for ${tempRoot}: ${err}`)
+    }
+  }
+
+  try {
+    const remoteSyncCmd = buildRsyncCmd({
+      includeArgs,
+      excludeArgs,
+      keyPath,
+      source: `${user}@${host}:~/apps/${deployDir}/`,
+      dest: `${remoteDir}/`,
+      remote: true,
+    })
+    log?.(`Syncing remote compose files: ${remoteSyncCmd}`)
+    runRsync(remoteSyncCmd)
+
+    const localSyncCmd = buildRsyncCmd({
+      includeArgs,
+      excludeArgs,
+      keyPath,
+      source: "./",
+      dest: `${localDir}/`,
+      remote: false,
+    })
+    log?.(`Syncing local compose files: ${localSyncCmd}`)
+    runRsync(localSyncCmd)
+
+    const remoteHashes = hashTree(remoteDir)
+    const localHashes = hashTree(localDir)
+
+    const remotePaths = new Set(Object.keys(remoteHashes.fileHashes))
+    const localPaths = new Set(Object.keys(localHashes.fileHashes))
+
+    const missingLocal = [...remotePaths].filter((p) => !localPaths.has(p))
+    const missingRemote = [...localPaths].filter((p) => !remotePaths.has(p))
+    const changed = [...remotePaths].filter(
+      (p) => localPaths.has(p) && remoteHashes.fileHashes[p] !== localHashes.fileHashes[p],
+    )
+
+    const hasChanges = (
+      remoteHashes.treeHash !== localHashes.treeHash ||
+      missingLocal.length > 0 ||
+      missingRemote.length > 0 ||
+      changed.length > 0
+    )
+
+    const summary = [
+      `local tree:  ${localHashes.treeHash}`,
+      `remote tree: ${remoteHashes.treeHash}`,
+    ]
+
+    if (missingLocal.length) summary.push(`Only on remote: ${missingLocal.join(", ")}`)
+    if (missingRemote.length) summary.push(`Only on local: ${missingRemote.join(", ")}`)
+    if (changed.length) summary.push(`Content differs: ${changed.join(", ")}`)
+    if (!hasChanges) summary.push("Compose files are identical.")
+
+    return { hasChanges, output: summary.join("\n") }
+  } finally {
+    cleanup()
+  }
+}

package/src/{cmd-deploy.js → cmd-deploy/index.js}

@@ -1,77 +1,12 @@
 import { execSync } from "child_process"
 import fs from "fs"
-import path from "path"
 import os from "os"
+import path from "path"
 
 import validator from "validator"
 
-import { purgeCloudflareCaches } from "./cloudflare-purge.js"
-
-
-const baseExcludeList = [
-  ".husky/",
-  ".github/",
-  ".git/",
-  ".wireit/",
-  "coverage/",
-  "node_modules/",
-  "infrastructure/data/",
-  ".gitignore",
-  "*.css.map",
-  // "*.env*",
-  // "*.js.map",
-  "*.md",
-]
-
-
-const detectComposeChanges = ({ keyPath, user, host, deployDir, log, extraExcludes = [] }) => {
-  const includeArgs = ["--include='*/'", "--include='*compose*.yml'", "--exclude='*'"]
-  const excludeArgs = baseExcludeList
-    .concat(extraExcludes)
-    .map((p) => `--exclude='${p}'`)
-    .join(" ")
-
-  // keep --delete so remote-only compose files show up as *deleting in dry-run; dropping it hides stale files
-  const rsyncCmd = [
-    "rsync -avzn --delete --itemize-changes --filter=':- .gitignore'",
-    includeArgs.join(" "),
-    excludeArgs,
-    `-e "ssh -i '${keyPath}' -o StrictHostKeyChecking=no"`,
-    ".",
-    `${user}@${host}:~/apps/${deployDir}/`,
-  ].filter(Boolean).join(" ")
-
-  log(`Checking compose files (dry-run): ${rsyncCmd}`)
-
-  let out
-  try {
-    out = execSync(rsyncCmd, { stdio: "pipe" }).toString()
-  } catch (error) {
-    const allowedExitCodes = [23, 24]
-    if (allowedExitCodes.includes(error?.status) && error?.stdout) {
-      out = error.stdout.toString()
-    } else {
-      throw error
-    }
-  }
-
-  // rsync --itemize-changes prefixes change lines; any line that isn't a summary indicates a diff
-  const changeLines = out
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => {
-      if (!line) return false
-      if (line.startsWith("sending ")) return false
-      if (line.startsWith("sent ")) return false
-      if (line.startsWith("total size")) return false
-      if (line.startsWith("receiving incremental file list")) return false
-      return true
-    })
-
-  const hasChanges = changeLines.length > 0
-
-  return { hasChanges, output: out }
-}
+import { purgeCloudflareCaches } from "./purge-cloudflare.js"
+import { baseExcludeList, detectComposeChanges } from "./detect-compose-changes.js"
 
 
 export const deploy = async (argv) => {
@@ -153,14 +88,22 @@ export const deploy = async (argv) => {
     console.log(`${user}@${host}`, res)
     await ssh(`mkdir -p ~/apps/${deployDir}`)
 
-    const { hasChanges: infrastructureChanged, output: infrastructureDiff } = detectComposeChanges({
-      keyPath,
-      user,
-      host,
-      deployDir,
-      log,
-      extraExcludes: argv.ignore || [],
-    })
+    let infrastructureChanged = false
+    let infrastructureDiff = ""
+    try {
+      ({ hasChanges: infrastructureChanged, output: infrastructureDiff } = detectComposeChanges({
+        keyPath,
+        user,
+        host,
+        deployDir,
+        log,
+        extraExcludes: argv.ignore || [],
+      }))
+    } catch (diffError) {
+      console.warn(
+        `Compose diff check skipped (non-blocking): ${diffError instanceof Error ? diffError.message : diffError}`,
+      )
+    }
 
     if (infrastructureChanged) {
       console.log("Infrastructure compose files differ between local and remote (info only; deploy proceeds).")
@@ -169,7 +112,6 @@ export const deploy = async (argv) => {
 
     const excludeList = baseExcludeList.concat(argv.ignore)
 
-
     const excludeArgs = excludeList.map((p) => `--exclude='${p}'`).join(" ")
 
     const rsyncCmd = [

package/src/index.js

@@ -7,7 +7,7 @@ import { hideBin } from "yargs/helpers"
 import dotenv from "dotenv"
 import { expand } from "dotenv-expand"
 
-import { deploy } from "./cmd-deploy.js"
+import { deploy } from "./cmd-deploy/index.js"
 import { ssh } from "./cmd-ssh.js"
 import { waitFor } from "./cmd-wait-for/index.js"