feat: post random immediately on startup if no recent post

- Add lastRandomPost tracking to state (timestamp per channel)
- Add getLastRandomPost, setLastRandomPost, shouldPostRandom methods
- On startup, check if interval has elapsed since last post
- If no last post or interval elapsed, post immediately
- Then start the recurring interval

Fixes issue where random posts only started after first interval.

Author: ryanio

src/index.ts

@@ -361,15 +361,66 @@ const getNextCollection = (
   return collection;
 };
 
+/**
+ * Post a random NFT to a channel
+ */
+const postRandomToChannel = async (
+  channel: TextBasedChannel,
+  channelId: string,
+  chanName: string,
+  targetCollections: CollectionConfig[]
+): Promise<void> => {
+  const stateManager = getStateManager();
+  const userLog: Log = [];
+  const startTime = Date.now();
+
+  // Get next collection in rotation
+  const collection = getNextCollection(channelId, targetCollections);
+  const tokenId = getUniqueRandomToken(collection, channelId);
+
+  const prefix = collection.prefix ? `${collection.prefix}#` : "#";
+  log.debug(
+    `Random posting to #${chanName}, ${collection.name} ${prefix}${tokenId}`
+  );
+
+  const embed = await buildEmbed(collection, tokenId, userLog);
+
+  if (embed) {
+    // Track this token and timestamp
+    stateManager.addRecentToken(channelId, tokenId);
+    stateManager.setLastRandomPost(channelId);
+    await stateManager.save();
+
+    userLog.push(
+      `Sending random ${collection.name} ${prefix}${tokenId} to #${chanName}`
+    );
+    await sendEmbed(channel, embed);
+
+    const duration = Date.now() - startTime;
+    log.info(
+      `Sent random ${collection.name} ${prefix}${tokenId} to #${chanName} (${duration}ms)`
+    );
+  }
+
+  if (userLog.length > 0) {
+    userLog.push(SEPARATOR);
+    for (const line of userLog) {
+      logger.info(line);
+    }
+  }
+};
+
 /**
  * Set up random interval posting for collections
  *
  * Format: CHANNEL_ID=minutes[:collection_option]
  * Examples:
- *   - 123456=30           (default collection every 30 min)
- *   - 123456=30:*         (rotate all collections every 30 min)
+ *   - 123456=30           (rotate all collections every 30 min)
+ *   - 123456=30:*         (rotate all collections every 30 min, explicit)
  *   - 123456=30:artifacts (artifacts collection every 30 min)
- *   - 123456=30:default+artifacts (rotate between default and artifacts)
+ *   - 123456=30:bots+artifacts (rotate between bots and artifacts)
+ *
+ * On startup, posts immediately if no previous post exists or if interval has elapsed.
  */
 const setupRandomIntervals = async (client: Client): Promise<void> => {
   if (!RANDOM_INTERVALS) {
@@ -401,47 +452,24 @@ const setupRandomIntervals = async (client: Client): Promise<void> => {
       continue;
     }
     const chanName = getChannelName(channel);
+    const intervalMs = minutes * SECONDS_PER_MINUTE * ONE_SECOND_MS;
+
+    // Post immediately on startup if no previous post or interval has elapsed
+    if (stateManager.shouldPostRandom(channelId, intervalMs)) {
+      log.info(`Posting initial random to #${chanName}`);
+      await postRandomToChannel(
+        channel,
+        channelId,
+        chanName,
+        targetCollections
+      );
+    }
 
+    // Set up recurring interval
     setInterval(
-      async () => {
-        const userLog: Log = [];
-        const startTime = Date.now();
-
-        // Get next collection in rotation
-        const collection = getNextCollection(channelId, targetCollections);
-        const tokenId = getUniqueRandomToken(collection, channelId);
-
-        const prefix = collection.prefix ? `${collection.prefix}#` : "#";
-        log.debug(
-          `Random interval triggered for #${chanName}, ${collection.name} ${prefix}${tokenId}`
-        );
-
-        const embed = await buildEmbed(collection, tokenId, userLog);
-
-        if (embed) {
-          // Track this token as recently sent
-          stateManager.addRecentToken(channelId, tokenId);
-          await stateManager.save();
-
-          userLog.push(
-            `Sending random ${collection.name} ${prefix}${tokenId} to #${chanName}`
-          );
-          await sendEmbed(channel, embed);
-
-          const duration = Date.now() - startTime;
-          log.info(
-            `Sent random ${collection.name} ${prefix}${tokenId} to #${chanName} (${duration}ms)`
-          );
-        }
-
-        if (userLog.length > 0) {
-          userLog.push(SEPARATOR);
-          for (const line of userLog) {
-            logger.info(line);
-          }
-        }
-      },
-      minutes * SECONDS_PER_MINUTE * ONE_SECOND_MS
+      () =>
+        postRandomToChannel(channel, channelId, chanName, targetCollections),
+      intervalMs
     );
   }
 };

src/state/state.ts

@@ -23,6 +23,8 @@ type StateData = {
   updatedAt: string;
   /** Recent random tokens per channel (to avoid repeats) */
   recentTokens: Record<string, number[]>;
+  /** Last random post timestamp per channel (ISO string) */
+  lastRandomPost: Record<string, string>;
   /** Custom state data (extensible) */
   custom: Record<string, unknown>;
 };
@@ -32,6 +34,7 @@ const createDefaultState = (): StateData => ({
   version: 1,
   updatedAt: new Date().toISOString(),
   recentTokens: {},
+  lastRandomPost: {},
   custom: {},
 });
 
@@ -106,6 +109,9 @@ class StateManager {
     if (parsed.recentTokens !== undefined) {
       this.state.recentTokens = parsed.recentTokens;
     }
+    if (parsed.lastRandomPost !== undefined) {
+      this.state.lastRandomPost = parsed.lastRandomPost;
+    }
     if (parsed.custom !== undefined) {
       this.state.custom = parsed.custom;
     }
@@ -198,6 +204,48 @@ class StateManager {
     }
   }
 
+  /**
+   * Get the last random post timestamp for a channel
+   * Returns undefined if no random post has been made
+   */
+  getLastRandomPost(channelId: string): Date | undefined {
+    const timestamp = this.state.lastRandomPost[channelId];
+    if (timestamp) {
+      return new Date(timestamp);
+    }
+    return;
+  }
+
+  /**
+   * Set the last random post timestamp for a channel
+   */
+  setLastRandomPost(channelId: string, timestamp: Date = new Date()): void {
+    this.state.lastRandomPost[channelId] = timestamp.toISOString();
+    this.markDirty();
+    log.debug(
+      `Set last random post for channel ${channelId}: ${timestamp.toISOString()}`
+    );
+  }
+
+  /**
+   * Check if enough time has passed since the last random post
+   * Returns true if no last post exists or if intervalMs has passed
+   */
+  shouldPostRandom(channelId: string, intervalMs: number): boolean {
+    const lastPost = this.getLastRandomPost(channelId);
+    if (!lastPost) {
+      log.debug(`No last random post for channel ${channelId}, should post`);
+      return true;
+    }
+    const elapsed = Date.now() - lastPost.getTime();
+    const shouldPost = elapsed >= intervalMs;
+    log.debug(
+      `Last random post for channel ${channelId} was ${Math.round(elapsed / 1000)}s ago, ` +
+        `interval is ${Math.round(intervalMs / 1000)}s, should post: ${shouldPost}`
+    );
+    return shouldPost;
+  }
+
   /**
    * Get a custom state value
    */

test/state.test.ts

@@ -211,6 +211,96 @@ describe("StateManager", () => {
     });
   });
 
+  describe("lastRandomPost", () => {
+    it("returns undefined when no last post exists", async () => {
+      await manager.load();
+      expect(manager.getLastRandomPost("channel1")).toBeUndefined();
+    });
+
+    it("sets and gets last random post timestamp", async () => {
+      await manager.load();
+      const now = new Date();
+      manager.setLastRandomPost("channel1", now);
+
+      const retrieved = manager.getLastRandomPost("channel1");
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.getTime()).toBe(now.getTime());
+    });
+
+    it("uses current time when no timestamp provided", async () => {
+      await manager.load();
+      const before = Date.now();
+      manager.setLastRandomPost("channel1");
+      const after = Date.now();
+
+      const retrieved = manager.getLastRandomPost("channel1");
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.getTime()).toBeGreaterThanOrEqual(before);
+      expect(retrieved?.getTime()).toBeLessThanOrEqual(after);
+    });
+
+    it("marks state as dirty when setting", async () => {
+      await manager.load();
+      expect(manager.isDirty()).toBe(false);
+
+      manager.setLastRandomPost("channel1");
+      expect(manager.isDirty()).toBe(true);
+    });
+
+    it("persists across save/load cycle", async () => {
+      await manager.load();
+      const timestamp = new Date("2024-01-15T12:00:00Z");
+      manager.setLastRandomPost("channel1", timestamp);
+      await manager.save();
+
+      const manager2 = createStateManager({
+        filePath: TEST_STATE_FILE,
+        enablePersistence: true,
+      });
+      await manager2.load();
+
+      const retrieved = manager2.getLastRandomPost("channel1");
+      expect(retrieved?.toISOString()).toBe(timestamp.toISOString());
+    });
+  });
+
+  describe("shouldPostRandom", () => {
+    it("returns true when no last post exists", async () => {
+      await manager.load();
+      expect(manager.shouldPostRandom("channel1", 60_000)).toBe(true);
+    });
+
+    it("returns true when interval has elapsed", async () => {
+      await manager.load();
+      // Set last post to 2 minutes ago
+      const twoMinutesAgo = new Date(Date.now() - 2 * 60 * 1000);
+      manager.setLastRandomPost("channel1", twoMinutesAgo);
+
+      // Should post if interval is 1 minute
+      expect(manager.shouldPostRandom("channel1", 60_000)).toBe(true);
+    });
+
+    it("returns false when interval has not elapsed", async () => {
+      await manager.load();
+      // Set last post to 30 seconds ago
+      const thirtySecondsAgo = new Date(Date.now() - 30 * 1000);
+      manager.setLastRandomPost("channel1", thirtySecondsAgo);
+
+      // Should not post if interval is 1 minute
+      expect(manager.shouldPostRandom("channel1", 60_000)).toBe(false);
+    });
+
+    it("returns true at exact interval boundary", async () => {
+      await manager.load();
+      // Set last post to exactly 1 minute ago
+      const oneMinuteAgo = new Date(Date.now() - 60 * 1000);
+      manager.setLastRandomPost("channel1", oneMinuteAgo);
+
+      // Should post if interval is 1 minute
+      expect(manager.shouldPostRandom("channel1", 60_000)).toBe(true);
+    });
+  });
+
   describe("persistence disabled", () => {
     it("does not save when persistence is disabled", async () => {
       const inMemoryManager = createStateManager({