Only deploy commands when they have actually changed

The container's CMD is `validate && deploy && start`, so every restart bulk
overwrote every global command — needless API traffic, and a rate-limit risk
during a crash loop. Global command propagation is also not instant, so
redeploying identical payloads on every boot bought nothing.

deploy-commands.ts now fingerprints what it is about to send (the global
payload, the owner-guild payload, the client id and the guild id) and stores
the hash in the existing Keyv/SQLite store. If the fingerprint matches the
last successful deploy it skips entirely. `--force` / `-f` overrides, and
`--clear` drops the stored fingerprint so the next deploy runs.

setCommands() now reports whether the calls succeeded, and the fingerprint is
recorded only if they did. It previously caught and logged errors while
returning normally, so without that the first failed deploy would have been
remembered as successful and never retried.

Verified end to end against a bogus token:

  1. failed deploy    -> nothing recorded, "the next run will retry"
  2. run again        -> retries, does not skip
  3. fingerprint seeded as a success -> skips, zero API calls
  4. --force          -> deploys anyway
  5. BOT_GUILD_ID changed -> fingerprint differs, deploys
  6. a command description edited -> fingerprint differs, deploys
  7. edit reverted    -> skips again

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015hDX4g1EjTN7424A5wnptE

Author: claude

Dockerfile

@@ -20,5 +20,6 @@ COPY --link . /app
 # Setup some default files
 RUN touch settings.sqlite3
 
-# Refresh commands when starting the bot
+# Validate config, then deploy commands only if they changed since the last
+# start (see scripts/deploy-commands.ts), then run the bot
 CMD ["sh", "-c", "bun run validate && bun run deploy && bun run start"]

scripts/deploy-commands.ts

@@ -1,13 +1,28 @@
+import {createHash} from "node:crypto";
 import path from "node:path";
 import {fileURLToPath} from "node:url";
 import {REST, type RESTPostAPIChatInputApplicationCommandsJSONBody} from "discord.js";
 import {API} from "@discordjs/core";
 import {loadCommands} from "../src/framework";
+import {globalDB} from "../src/db";
 import "dotenv/config";
 
 
 // Check CLI arguments for clear flag
 const shouldClear = process.argv.includes("--clear") || process.argv.includes("-c");
+const shouldForce = process.argv.includes("--force") || process.argv.includes("-f");
+
+/**
+ * The container runs this on every start, so an unguarded deploy meant a bulk
+ * overwrite of every global command on every restart — needless API traffic,
+ * and a rate-limit risk during a crash loop. The fingerprint covers what is
+ * sent and where, so a redeploy happens exactly when one of those changes.
+ */
+const FINGERPRINT_KEY = "deployedCommandsFingerprint";
+
+const fingerprintOf = (global: unknown, guild: unknown) => createHash("sha256")
+    .update(JSON.stringify({global, guild, clientId: process.env.BOT_CLIENT_ID, guildId: process.env.BOT_GUILD_ID}))
+    .digest("hex");
 
 // Setup file paths
 const __filename = fileURLToPath(import.meta.url);
@@ -17,7 +32,10 @@ const __dirname = path.dirname(__filename);
 const rest = new REST().setToken(process.env.BOT_TOKEN!);
 const api = new API(rest);
 
-async function setCommands(globalCommands: RESTPostAPIChatInputApplicationCommandsJSONBody[], guildCommands: RESTPostAPIChatInputApplicationCommandsJSONBody[]) {
+/** Returns whether every part that was attempted succeeded. */
+async function setCommands(globalCommands: RESTPostAPIChatInputApplicationCommandsJSONBody[], guildCommands: RESTPostAPIChatInputApplicationCommandsJSONBody[]): Promise<boolean> {
+    let ok = true;
+
     // Deploy global commands
     try {
         console.log(`\n🚀 Started ${shouldClear ? "clearing" : "registering"} global application commands...`);
@@ -26,6 +44,7 @@ async function setCommands(globalCommands: RESTPostAPIChatInputApplicationComman
     }
     catch (error) {
         console.error(`❌ Failed to ${shouldClear ? "clear" : "register"} global commands:`, error);
+        ok = false;
     }
 
     // Deploy guild commands (owner commands)
@@ -37,13 +56,15 @@ async function setCommands(globalCommands: RESTPostAPIChatInputApplicationComman
         }
         catch (error) {
             console.error(`❌ Failed to ${shouldClear ? "clear" : "register"} guild commands:`, error);
+            ok = false;
         }
     }
     else if (!process.env.BOT_GUILD_ID) {
         console.log(`⚠️  BOT_GUILD_ID not set - skipping owner command ${shouldClear ? "clearing" : "deployment"}`);
     }
 
     console.log(`\n🎉 Command ${shouldClear ? "clearing" : "deployment"} complete!`);
+    return ok;
 }
 
 if (!shouldClear) {
@@ -66,9 +87,23 @@ if (!shouldClear) {
     }
 
     console.log(`📁 Loaded ${commands.length} global commands and ${ownerCommands.length} owner commands`);
-    await setCommands(commands, ownerCommands);
+
+    const fingerprint = fingerprintOf(commands, ownerCommands);
+    const deployed = await globalDB.get(FINGERPRINT_KEY);
+
+    if (deployed === fingerprint && !shouldForce) {
+        console.log("\n⏭️  Commands are unchanged since the last deploy - skipping. Use --force to deploy anyway.");
+    }
+    else {
+        // Only remember the fingerprint if everything actually landed, so a
+        // failed deploy retries on the next start instead of being skipped.
+        const ok = await setCommands(commands, ownerCommands);
+        if (ok) await globalDB.set(FINGERPRINT_KEY, fingerprint);
+        else console.log("⚠️  Not recording the fingerprint; the next run will retry.");
+    }
 }
 else {
     console.log("🗑️  Clearing all commands...");
     await setCommands([], []);
+    await globalDB.delete(FINGERPRINT_KEY);
 }