@gitping/cli 0.0.1

package/src/index.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+import { Command } from 'commander'
+import { loginCommand } from './commands/login.ts'
+import { logoutCommand } from './commands/logout.ts'
+import { whoamiCommand } from './commands/whoami.ts'
+import { inboxCommand } from './commands/inbox.ts'
+import { pingCommand } from './commands/ping.ts'
+import { acceptCommand } from './commands/accept.ts'
+import { ignoreCommand } from './commands/ignore.ts'
+import { blockCommand } from './commands/block.ts'
+import { chatCommand } from './commands/chat.ts'
+import { statusCommand } from './commands/status.ts'
+import { searchCommand } from './commands/search.ts'
+import { leaderboardCommand } from './commands/leaderboard.ts'
+
+const program = new Command()
+
+program
+  .name('gitping')
+  .description('Contact any developer using their GitHub identity')
+  .version('0.0.1')
+  .action(() => {
+    program.help()
+  })
+
+// ─── Auth ───────────────────────────────────────────────────────────────────
+
+program
+  .command('login')
+  .description('Authenticate with GitHub (opens browser)')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(loginCommand))
+
+program
+  .command('logout')
+  .description('Clear stored credentials and config')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(logoutCommand))
+
+program
+  .command('whoami')
+  .description('Show your profile, rep score, and availability')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(whoamiCommand))
+
+// ─── Inbox ───────────────────────────────────────────────────────────────────
+
+program
+  .command('inbox')
+  .description('List your received pings')
+  .option('--unread', 'show unread pings only')
+  .option('--watch', 'live mode via WebSocket')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(inboxCommand))
+
+// ─── Ping ────────────────────────────────────────────────────────────────────
+
+program
+  .command('ping <recipient> <message>')
+  .description('Send a ping to a developer (e.g. gitping ping @torvalds "Hey!")')
+  .option('--cat <category>', 'category: job | collab | oss | feedback', 'collab')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(pingCommand))
+
+program
+  .command('accept <target>')
+  .description('Accept a ping by @username or ping-id')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(acceptCommand))
+
+program
+  .command('ignore <target>')
+  .description('Ignore a ping by @username or ping-id')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(ignoreCommand))
+
+program
+  .command('block <target>')
+  .description('Block a sender by @username or ping-id')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(blockCommand))
+
+// ─── Chat ────────────────────────────────────────────────────────────────────
+
+program
+  .command('chat <recipient>')
+  .description('Open an interactive real-time thread with a developer')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(chatCommand))
+
+// ─── Status ──────────────────────────────────────────────────────────────────
+
+program
+  .command('status')
+  .description('Show or update your availability status')
+  .option(
+    '--set <mode>',
+    'set availability: open-to-collab | open-to-work | selective | heads-down',
+  )
+  .option('--message <msg>', 'set a custom status message')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(statusCommand))
+
+// ─── Discovery ───────────────────────────────────────────────────────────────
+
+program
+  .command('search <username>')
+  .description('Look up a developer by GitHub username')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(searchCommand))
+
+program
+  .command('leaderboard')
+  .description('Show the most pinged developers')
+  .option('--rising', 'show developers with the biggest spike this week')
+  .option('--json', 'output as JSON')
+  .action(withExitCode(leaderboardCommand))
+
+program.parseAsync(process.argv).catch((err) => {
+  const code = (err as { exitCode?: number }).exitCode ?? 1
+  process.exit(code)
+})
+
+/**
+ * Wraps a command handler so that thrown errors with an `exitCode` property
+ * cause the process to exit with the correct code.
+ * Per AGENTS.md: never call process.exit inside a command handler.
+ */
+function withExitCode<T extends unknown[]>(
+  fn: (...args: T) => Promise<void>,
+): (...args: T) => Promise<void> {
+  return async (...args: T) => {
+    try {
+      await fn(...args)
+    } catch (err) {
+      const code = (err as { exitCode?: number }).exitCode
+      if (code !== undefined) {
+        const message = err instanceof Error ? err.message : String(err)
+        if (code !== 0 && message && message !== 'Not authenticated' && message !== 'Not found') {
+          // Most errors already printed by the command, but surface unexpected ones
+        }
+        process.exit(code)
+      }
+      throw err
+    }
+  }
+}

package/src/ui/ChatView.tsx

@@ -0,0 +1,195 @@
+import React, { useState, useEffect, useRef, useCallback } from 'react'
+import { Box, Text, useInput, useApp } from 'ink'
+import tty from 'node:tty'
+import WebSocket from 'ws'
+import { getApiBaseUrl } from '../config.ts'
+import { getThread, sendMessage } from '../api/threads.ts'
+import type { Message, WSEvent } from '@gitping/shared'
+import { WSEventType } from '@gitping/shared'
+
+interface ChatViewProps {
+  threadId: string
+  token: string
+  myUserId: string
+  /** The tty.ReadStream opened on /dev/tty — passed in so we can destroy it on exit. */
+  ttyStream: tty.ReadStream
+}
+
+export default function ChatView({
+  threadId,
+  token,
+  myUserId,
+  ttyStream,
+}: ChatViewProps): React.JSX.Element {
+  const { exit } = useApp()
+  const [messages, setMessages] = useState<Message[]>([])
+  const [input, setInput] = useState('')
+  const [status, setStatus] = useState<'connecting' | 'connected' | 'disconnected' | 'error'>(
+    'connecting',
+  )
+  const [error, setError] = useState<string | null>(null)
+  const wsRef = useRef<WebSocket | null>(null)
+
+  // sendingRef tracks an in-flight send so we can show a visual indicator without
+  // blocking keypresses — the useInput handler is kept synchronous to avoid
+  // Ink's input lock being held across an await.
+  const sendingRef = useRef(false)
+  const mountedRef = useRef(true)
+
+  // Load existing messages on mount
+  useEffect(() => {
+    getThread(threadId)
+      .then(({ messages: msgs }) => {
+        if (mountedRef.current) setMessages(msgs)
+      })
+      .catch((err) => {
+        if (mountedRef.current) setError(String(err))
+      })
+  }, [threadId])
+
+  // Connect WebSocket
+  useEffect(() => {
+    const baseUrl = getApiBaseUrl().replace(/^http/, 'ws')
+    const ws = new WebSocket(`${baseUrl}/v1/ws?token=${encodeURIComponent(token)}`)
+    wsRef.current = ws
+
+    ws.on('open', () => {
+      if (mountedRef.current) setStatus('connected')
+    })
+
+    ws.on('error', () => {
+      if (mountedRef.current) {
+        setStatus('error')
+        setError('WebSocket connection failed')
+      }
+    })
+
+    ws.on('close', () => {
+      if (mountedRef.current) setStatus('disconnected')
+    })
+
+    ws.on('message', (data) => {
+      try {
+        const event = JSON.parse(data.toString()) as WSEvent
+        if (event.type === WSEventType.MESSAGE_RECEIVED) {
+          const msg = event.payload as Message
+          if (msg.thread_id === threadId && mountedRef.current) {
+            setMessages((prev) => [...prev, msg])
+          }
+        }
+      } catch {
+        /* ignore malformed events */
+      }
+    })
+
+    return () => {
+      mountedRef.current = false
+      ws.close()
+    }
+  }, [threadId, token])
+
+  // doSend fires the network call without blocking useInput (which must stay sync).
+  const doSend = useCallback(
+    (body: string) => {
+      sendingRef.current = true
+      sendMessage(threadId, body)
+        .then((msg) => {
+          if (mountedRef.current) setMessages((prev) => [...prev, msg])
+        })
+        .catch((err) => {
+          if (mountedRef.current) setError(String(err))
+        })
+        .finally(() => {
+          sendingRef.current = false
+        })
+    },
+    [threadId],
+  )
+
+  // IMPORTANT: useInput handler MUST be synchronous.
+  // Ink wraps each call in reconciler.batchedUpdates() — if the callback is async,
+  // the batchedUpdates scope exits before state setters run and subsequent keypresses
+  // pile up in the event queue while the previous await is still pending, causing
+  // the terminal to appear completely frozen.
+  useInput((inputChar, key) => {
+    if (key.ctrl && inputChar === 'c') {
+      // Flag unmounted first so no in-flight async callbacks write state after this.
+      mountedRef.current = false
+      // Close the WebSocket before tearing down the UI.
+      wsRef.current?.close()
+      // exit() resolves waitUntilExit() in chat.ts, which then destroys ttyStream
+      // and restores the terminal.  We do NOT touch ttyStream here because Ink's
+      // App.componentWillUnmount() calls setRawMode(false) on it — if we destroy
+      // it first that call would throw.
+      exit()
+      return
+    }
+
+    if (key.return) {
+      const body = input.trim()
+      if (!body || sendingRef.current) return
+      setInput('')
+      doSend(body)
+      return
+    }
+
+    if (key.backspace || key.delete) {
+      setInput((prev) => prev.slice(0, -1))
+      return
+    }
+
+    if (!key.ctrl && !key.meta && inputChar) {
+      setInput((prev) => prev + inputChar)
+    }
+  })
+
+  const statusColor =
+    status === 'connected'
+      ? 'green'
+      : status === 'error' || status === 'disconnected'
+        ? 'red'
+        : 'yellow'
+
+  const statusLabel = status === 'disconnected' ? 'disconnected' : status
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Box borderStyle="single" borderColor="cyan" paddingX={1} marginBottom={1}>
+        <Text bold color="cyan">
+          GitPing Chat
+        </Text>
+        <Text> — thread </Text>
+        <Text dimColor>{threadId.slice(0, 8)}</Text>
+        <Text> </Text>
+        <Text color={statusColor}>● {statusLabel}</Text>
+      </Box>
+
+      <Box flexDirection="column" flexGrow={1} marginBottom={1}>
+        {messages.length === 0 && <Text dimColor>No messages yet. Start the conversation!</Text>}
+        {messages.map((msg) => (
+          <Box key={msg.id} marginBottom={0}>
+            <Text color={msg.sender_id === myUserId ? 'cyan' : 'white'} bold>
+              {msg.sender_id === myUserId ? 'You' : 'Them'}
+            </Text>
+            <Text dimColor> {new Date(msg.created_at).toLocaleTimeString()} </Text>
+            <Text>{msg.body}</Text>
+          </Box>
+        ))}
+      </Box>
+
+      {error && (
+        <Box marginBottom={1}>
+          <Text color="red">Error: {error}</Text>
+        </Box>
+      )}
+
+      <Box borderStyle="round" borderColor="gray" paddingX={1}>
+        <Text color="cyan">{'> '}</Text>
+        <Text>{input}</Text>
+        {sendingRef.current ? <Text dimColor> sending…</Text> : <Text dimColor>█</Text>}
+      </Box>
+
+      <Text dimColor> Press Enter to send · Ctrl+C to quit</Text>
+    </Box>
+  )
+}

package/src/ui/InboxWatch.tsx

@@ -0,0 +1,134 @@
+import React, { useState, useEffect } from 'react'
+import { Box, Text, useApp } from 'ink'
+import WebSocket from 'ws'
+import { getApiBaseUrl } from '../config.ts'
+import { listPings } from '../api/pings.ts'
+import type { Ping, WSEvent } from '@gitping/shared'
+import { WSEventType } from '@gitping/shared'
+
+interface InboxWatchProps {
+  token: string
+}
+
+export default function InboxWatch({ token }: InboxWatchProps): React.JSX.Element {
+  const { exit } = useApp()
+  const [pings, setPings] = useState<Ping[]>([])
+  const [status, setStatus] = useState<'loading' | 'live' | 'error'>('loading')
+  const [error, setError] = useState<string | null>(null)
+  const [lastUpdate, setLastUpdate] = useState<Date>(new Date())
+
+  // Initial load
+  useEffect(() => {
+    listPings()
+      .then((page) => {
+        setPings(page.data)
+        setStatus('live')
+      })
+      .catch((err) => {
+        setStatus('error')
+        setError(String(err))
+      })
+  }, [])
+
+  // WebSocket live updates
+  useEffect(() => {
+    const baseUrl = getApiBaseUrl().replace(/^http/, 'ws')
+    const ws = new WebSocket(`${baseUrl}/v1/ws?token=${encodeURIComponent(token)}`)
+
+    ws.on('open', () => setStatus('live'))
+    ws.on('error', () => {
+      setStatus('error')
+      setError('WebSocket connection failed — showing cached data')
+    })
+    ws.on('message', (data) => {
+      try {
+        const event = JSON.parse(data.toString()) as WSEvent
+        if (event.type === WSEventType.PING_RECEIVED) {
+          const newPing = event.payload as Ping
+          setPings((prev) => [newPing, ...prev])
+          setLastUpdate(new Date())
+        }
+      } catch {
+        /* ignore malformed events */
+      }
+    })
+
+    const handleExit = (): void => {
+      ws.close()
+      exit()
+    }
+
+    process.on('SIGINT', handleExit)
+
+    return () => {
+      ws.close()
+      process.off('SIGINT', handleExit)
+    }
+  }, [token, exit])
+
+  const statusColor = status === 'live' ? 'green' : status === 'error' ? 'red' : 'yellow'
+  const statusLabel = status === 'live' ? 'LIVE' : status === 'error' ? 'ERROR' : 'LOADING'
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Box borderStyle="single" borderColor="cyan" paddingX={1} marginBottom={1}>
+        <Text bold color="cyan">
+          GitPing Inbox
+        </Text>
+        <Text> </Text>
+        <Text color={statusColor}>● {statusLabel}</Text>
+        <Text dimColor> last updated {lastUpdate.toLocaleTimeString()}</Text>
+      </Box>
+
+      {error && (
+        <Box marginBottom={1}>
+          <Text color="yellow">⚠ {error}</Text>
+        </Box>
+      )}
+
+      {pings.length === 0 && status !== 'loading' && (
+        <Text dimColor>No pings yet. Waiting for new pings…</Text>
+      )}
+
+      {status === 'loading' && <Text color="yellow">Loading…</Text>}
+
+      {pings.map((ping) => (
+        <Box key={ping.id} flexDirection="column" marginBottom={1} paddingLeft={1}>
+          <Box>
+            <Text bold color="cyan">
+              @{ping.sender_username}
+            </Text>
+            <Text dimColor> → </Text>
+            <Text bold>@{ping.recipient_username}</Text>
+            <Text> </Text>
+            <Text color={statusBadgeColor(ping.status)}>[{ping.status}]</Text>
+            <Text> </Text>
+            <Text color="yellow">{ping.category}</Text>
+            <Text dimColor> {ping.id.slice(0, 8)}</Text>
+          </Box>
+          <Box paddingLeft={2}>
+            <Text italic>{ping.message}</Text>
+          </Box>
+          <Box paddingLeft={2}>
+            <Text dimColor>{new Date(ping.created_at).toLocaleString()}</Text>
+          </Box>
+        </Box>
+      ))}
+
+      <Box marginTop={1}>
+        <Text dimColor>Ctrl+C to exit</Text>
+      </Box>
+    </Box>
+  )
+}
+
+function statusBadgeColor(status: string): string {
+  const map: Record<string, string> = {
+    pending: 'gray',
+    delivered: 'blue',
+    accepted: 'green',
+    ignored: 'yellow',
+    blocked: 'red',
+  }
+  return map[status] ?? 'white'
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src/**/*"]
+}