bingocode 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/commands/release-notes/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const releaseNotes: Command = {
+  description: 'View release notes',
+  name: 'release-notes',
+  type: 'local',
+  supportsNonInteractive: true,
+  load: () => import('./release-notes.js'),
+}
+
+export default releaseNotes

package/src/commands/release-notes/release-notes.ts

@@ -0,0 +1,50 @@
+import type { LocalCommandResult } from '../../types/command.js'
+import {
+  CHANGELOG_URL,
+  fetchAndStoreChangelog,
+  getAllReleaseNotes,
+  getStoredChangelog,
+} from '../../utils/releaseNotes.js'
+
+function formatReleaseNotes(notes: Array<[string, string[]]>): string {
+  return notes
+    .map(([version, notes]) => {
+      const header = `Version ${version}:`
+      const bulletPoints = notes.map(note => `· ${note}`).join('\n')
+      return `${header}\n${bulletPoints}`
+    })
+    .join('\n\n')
+}
+
+export async function call(): Promise<LocalCommandResult> {
+  // Try to fetch the latest changelog with a 500ms timeout
+  let freshNotes: Array<[string, string[]]> = []
+
+  try {
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      setTimeout(rej => rej(new Error('Timeout')), 500, reject)
+    })
+
+    await Promise.race([fetchAndStoreChangelog(), timeoutPromise])
+    freshNotes = getAllReleaseNotes(await getStoredChangelog())
+  } catch {
+    // Either fetch failed or timed out - just use cached notes
+  }
+
+  // If we have fresh notes from the quick fetch, use those
+  if (freshNotes.length > 0) {
+    return { type: 'text', value: formatReleaseNotes(freshNotes) }
+  }
+
+  // Otherwise check cached notes
+  const cachedNotes = getAllReleaseNotes(await getStoredChangelog())
+  if (cachedNotes.length > 0) {
+    return { type: 'text', value: formatReleaseNotes(cachedNotes) }
+  }
+
+  // Nothing available, show link
+  return {
+    type: 'text',
+    value: `See the full changelog at: ${CHANGELOG_URL}`,
+  }
+}

package/src/server/__tests__/fixtures/mock-sdk-cli.ts

@@ -0,0 +1,123 @@
+const args = process.argv.slice(2)
+
+function getArg(name: string): string | undefined {
+  const index = args.indexOf(name)
+  return index >= 0 ? args[index + 1] : undefined
+}
+
+function emit(ws: WebSocket, payload: Record<string, unknown>) {
+  ws.send(JSON.stringify(payload) + '\n')
+}
+
+function extractUserText(message: any): string {
+  const content = message?.message?.content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((block: any) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block: any) => block.text)
+    .join(' ')
+}
+
+const sdkUrl = getArg('--sdk-url')
+const sessionId = getArg('--session-id') || crypto.randomUUID()
+const initMode = process.env.MOCK_SDK_INIT_MODE || 'on_open'
+let initSent = false
+
+if (!sdkUrl) {
+  console.error('Missing --sdk-url')
+  process.exit(1)
+}
+
+const ws = new WebSocket(sdkUrl)
+
+function sendInit() {
+  if (initSent) return
+  initSent = true
+  emit(ws, {
+    type: 'system',
+    subtype: 'init',
+    model: 'mock-opus',
+    slash_commands: [{ name: 'help', description: 'Show help' }],
+    session_id: sessionId,
+  })
+}
+
+ws.addEventListener('open', () => {
+  if (initMode !== 'on_first_user') {
+    sendInit()
+  }
+})
+
+ws.addEventListener('message', (event) => {
+  const payload = typeof event.data === 'string' ? event.data : String(event.data)
+  const lines = payload.split('\n').map(line => line.trim()).filter(Boolean)
+
+  for (const line of lines) {
+    const parsed = JSON.parse(line)
+
+    if (parsed.type === 'user') {
+      sendInit()
+      const text = extractUserText(parsed)
+      emit(ws, {
+        type: 'stream_event',
+        event: { type: 'message_start' },
+        session_id: sessionId,
+      })
+      emit(ws, {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_start',
+          index: 0,
+          content_block: { type: 'text', text: '' },
+        },
+        session_id: sessionId,
+      })
+      emit(ws, {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_delta',
+          index: 0,
+          delta: { type: 'thinking_delta', thinking: 'Mock thinking...' },
+        },
+        session_id: sessionId,
+      })
+      emit(ws, {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_delta',
+          index: 0,
+          delta: { type: 'text_delta', text: `Echo: ${text}` },
+        },
+        session_id: sessionId,
+      })
+      emit(ws, {
+        type: 'stream_event',
+        event: { type: 'content_block_stop', index: 0 },
+        session_id: sessionId,
+      })
+      emit(ws, {
+        type: 'result',
+        subtype: 'success',
+        is_error: false,
+        result: `Echo: ${text}`,
+        usage: { input_tokens: 3, output_tokens: 2 },
+        session_id: sessionId,
+      })
+    }
+
+    if (parsed.type === 'control_request' && parsed.request?.subtype === 'interrupt') {
+      emit(ws, {
+        type: 'result',
+        subtype: 'success',
+        is_error: false,
+        result: 'Interrupted',
+        usage: { input_tokens: 0, output_tokens: 0 },
+        session_id: sessionId,
+      })
+    }
+  }
+})
+
+ws.addEventListener('close', () => {
+  process.exit(0)
+})