@otto-assistant/bridge 0.4.92

package/src/discord-urls.ts

@@ -0,0 +1,88 @@
+// Configurable Discord API endpoint URLs.
+// Base URL for REST calls lives in the centralized zustand store (store.ts),
+// replacing the old process.env['DISCORD_REST_BASE_URL'] mutation.
+//
+// DISCORD_GATEWAY_URL: WebSocket gateway URL (default: undefined, auto-discovered via /gateway/bot)
+//   discord.js has no direct ws.gateway option — the gateway URL comes from the
+//   GET /gateway/bot REST response. If using a proxy, the proxy's /gateway/bot
+//   endpoint should return the desired gateway URL. This constant is provided
+//   for non-discord.js consumers (e.g. the Rust gateway-proxy config).
+
+import { REST } from 'discord.js'
+import { store } from './store.js'
+
+/**
+ * Base URL for Discord (default: https://discord.com).
+ * All REST API and raw fetch calls derive their URLs from this.
+ * Reads from the centralized store so gateway mode can set it via
+ * store.setState({ discordBaseUrl }) after startup.
+ */
+export function getDiscordRestBaseUrl(): string {
+  return store.getState().discordBaseUrl
+}
+
+/**
+ * The REST api path that discord.js expects (base + /api).
+ * discord.js appends /v10/... to this internally.
+ */
+export function getDiscordRestApiUrl(): string {
+  return new URL('/api', getDiscordRestBaseUrl()).toString()
+}
+
+/**
+ * WebSocket gateway URL override (default: undefined = auto-discover).
+ * When undefined, discord.js fetches it from GET /gateway/bot via REST.
+ * Provided as a constant for external consumers like the Rust gateway-proxy.
+ */
+export const DISCORD_GATEWAY_URL =
+  process.env['DISCORD_GATEWAY_URL'] || undefined
+
+/**
+ * Build a full Discord REST API URL for raw fetch() calls.
+ * Uses new URL() for safe path concatenation.
+ *
+ * Example: discordApiUrl(`/channels/${id}/messages`) →
+ *   "https://discord.com/api/v10/channels/123/messages"
+ */
+export function discordApiUrl(path: string): string {
+  return new URL(`/api/v10${path}`, getDiscordRestBaseUrl()).toString()
+}
+
+/**
+ * Create a discord.js REST client pointed at the configured base URL.
+ * Centralizes the REST instantiation so all call sites use the override.
+ */
+export function createDiscordRest(token: string): REST {
+  return new REST({ api: getDiscordRestApiUrl() }).setToken(token)
+}
+
+/**
+ * Returns the internet-reachable base URL for this kimaki instance.
+ * When KIMAKI_INTERNET_REACHABLE_URL is set (e.g. "https://my-kimaki.fly.dev"),
+ * kimaki binds the hrana server to 0.0.0.0 and exposes a /kimaki/wake endpoint
+ * so the gateway-proxy can wake this instance. Discord traffic still flows
+ * through the normal path (gateway-proxy in gateway mode, direct in self-hosted).
+ * Returns null when not set (kimaki only reachable on localhost).
+ */
+export function getInternetReachableBaseUrl(): string | null {
+  return process.env['KIMAKI_INTERNET_REACHABLE_URL'] || null
+}
+
+/**
+ * Derive an HTTPS REST base URL from a WebSocket gateway URL.
+ * Swaps wss→https and ws→http. Used for gateway mode where the
+ * gateway proxy URL doubles as the REST proxy base.
+ */
+export function getGatewayProxyRestBaseUrl({ gatewayUrl }: { gatewayUrl: string }): string {
+  try {
+    const parsedUrl = new URL(gatewayUrl)
+    if (parsedUrl.protocol === 'wss:') {
+      parsedUrl.protocol = 'https:'
+    } else if (parsedUrl.protocol === 'ws:') {
+      parsedUrl.protocol = 'http:'
+    }
+    return parsedUrl.toString()
+  } catch {
+    return gatewayUrl
+  }
+}

package/src/discord-utils.test.ts

@@ -0,0 +1,153 @@
+import { PermissionsBitField } from 'discord.js'
+import { describe, expect, test } from 'vitest'
+import { hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js'
+
+describe('splitMarkdownForDiscord', () => {
+  test('never returns chunks over the max length with code fences', () => {
+    const maxLength = 2000
+    const header = '## Summary of Current Architecture\n\n'
+    const codeFenceStart = '```\n'
+    const codeFenceEnd = '\n```\n'
+    const codeLine = 'x'.repeat(180)
+    const codeBlock = Array.from({ length: 20 })
+      .map(() => codeLine)
+      .join('\n')
+    const markdown = `${header}${codeFenceStart}${codeBlock}${codeFenceEnd}`
+
+    const chunks = splitMarkdownForDiscord({ content: markdown, maxLength })
+
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(maxLength)
+    }
+  })
+
+  // Without the lineLength fix for opening fences on non-empty chunks, the opening
+  // fence text "```\n" gets appended without being counted in the overflow check.
+  // When the chunk is later flushed with a closing fence, it exceeds maxLength.
+  test('opening fence on non-empty chunk is counted in overflow check', () => {
+    const maxLength = 60
+    // 55 chars of text + paragraph break, then a code block.
+    // The text fills the chunk to ~57 chars. The opening fence "```\n" (4 chars)
+    // would push to 61 if not counted, then flushing adds "```\n" (4 more) = 65.
+    const markdown = 'a'.repeat(55) + '\n\n```\nshort code\n```\n'
+
+    const chunks = splitMarkdownForDiscord({ content: markdown, maxLength })
+
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(maxLength)
+    }
+  })
+
+  test('list item code block keeps newline before fence when splitting', () => {
+    const content = `- File: playwriter/src/aria-snapshot.ts
+- Add helper function (~line 477, after isTextRole):
+  \`\`\`ts
+  function isSubstringOfAny(needle: string, haystack: Set<string>): boolean {
+    for (const str of haystack) {
+      if (str.includes(needle)) {
+        return true
+      }
+    }
+    return false
+  }
+  \`\`\`
+`
+
+    const result = splitMarkdownForDiscord({ content, maxLength: 80 })
+    expect(result).toMatchInlineSnapshot(`
+      [
+        "- File: playwriter/src/aria-snapshot.ts
+      ",
+        "- Add helper function (~line 477, after isTextRole):
+        \`\`\`ts
+      ",
+        "  function isSubstringOfAny(needle: string, haystack: Set<string>): boolean {
+      ",
+        "    for (const str of haystack) {
+            if (str.includes(needle)) {
+      ",
+        "        return true
+            }
+          }
+          return false
+        }
+        \`\`\`
+      ",
+      ]
+    `)
+  })
+
+  test('task list code block does not duplicate checkbox marker when splitting', () => {
+    const content = `- [ ] Do thing
+  \`\`\`sh
+  echo hi
+  \`\`\`
+`
+
+    const result = splitMarkdownForDiscord({ content, maxLength: 80 })
+    expect(result.join('')).toContain('- [ ] Do thing\n')
+    expect(result.join('')).not.toContain('- [ ] [ ] Do thing')
+    expect(result).toMatchInlineSnapshot(`
+      [
+        "- [ ] Do thing
+        \`\`\`sh
+        echo hi
+        \`\`\`
+      ",
+      ]
+    `)
+  })
+})
+
+describe('hasKimakiBotPermission', () => {
+  test('allows API interaction member when kimaki role exists', () => {
+    const kimakiRoleId = '111'
+    const guild = {
+      ownerId: 'owner-id',
+      roles: {
+        cache: new Map([
+          [kimakiRoleId, { id: kimakiRoleId, name: 'Kimaki' }],
+        ]),
+      },
+    } as any
+
+    const member = {
+      user: { id: 'member-id' },
+      permissions: '0',
+      roles: [kimakiRoleId],
+    } as any
+
+    expect(hasKimakiBotPermission(member, guild)).toBe(true)
+  })
+
+  test('allows API interaction member with ManageGuild permission', () => {
+    const guild = {
+      ownerId: 'owner-id',
+      roles: { cache: new Map() },
+    } as any
+
+    const member = {
+      user: { id: 'member-id' },
+      permissions: PermissionsBitField.Flags.ManageGuild.toString(),
+      roles: [],
+    } as any
+
+    expect(hasKimakiBotPermission(member, guild)).toBe(true)
+  })
+
+  test('denies API interaction member with no role, owner, or admin rights', () => {
+    const guild = {
+      ownerId: 'owner-id',
+      roles: { cache: new Map() },
+    } as any
+
+    const member = {
+      user: { id: 'member-id' },
+      permissions: '0',
+      roles: [],
+    } as any
+
+    expect(hasKimakiBotPermission(member, guild)).toBe(false)
+  })
+})