@gitping/cli 0.0.1 → 0.1.0

package/package.json

@@ -1,7 +1,27 @@
 {
   "name": "@gitping/cli",
-  "version": "0.0.1",
-  "description": "GitPing terminal client",
+  "version": "0.1.0",
+  "description": "GitPing terminal client — Ping the poeple",
+  "keywords": [
+    "gitping",
+    "cli",
+    "github",
+    "messaging",
+    "developer",
+    "terminal",
+    "ping"
+  ],
+  "homepage": "https://github.com/aialok/gitping#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aialok/gitping.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "bin": {
     "gitping": "./dist/index.js"
   },
@@ -11,22 +31,18 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@gitping/shared": "workspace:*",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "conf": "^15.1.0",
-    "ink": "^5.2.0",
     "keytar": "^7.9.0",
     "ky": "^1.14.3",
     "open": "^11.0.0",
     "ora": "^9.3.0",
-    "react": "^18.3.1",
-    "react-devtools-core": "^7.0.1",
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@gitping/shared": "workspace:*",
     "@types/node": "^25.5.0",
-    "@types/react": "^18.3.18",
     "@types/ws": "^8.18.1",
     "bun-types": "^1.3.10",
     "typescript": "^5.9.3"

package/src/api/client.ts

@@ -1,53 +0,0 @@
-import ky, { type KyInstance, type Options as KyOptions } from 'ky'
-import { getApiBaseUrl } from '../config.ts'
-import { getToken } from '../auth/keychain.ts'
-
-export class ApiError extends Error {
-  constructor(
-    public readonly code: string,
-    message: string,
-    public readonly status: number,
-  ) {
-    super(message)
-    this.name = 'ApiError'
-  }
-}
-
-async function buildHeaders(): Promise<Record<string, string>> {
-  const token = await getToken()
-  if (!token) return {}
-  return { Authorization: `Bearer ${token}` }
-}
-
-/**
- * Creates a ky instance with auth headers injected per-request.
- * All commands must go through this client — never call ky directly.
- */
-export async function createClient(extraOptions?: KyOptions): Promise<KyInstance> {
-  const headers = await buildHeaders()
-  return ky.create({
-    prefixUrl: getApiBaseUrl(),
-    headers,
-    hooks: {
-      afterResponse: [
-        async (_req, _opts, response) => {
-          if (!response.ok) {
-            let code = 'INTERNAL_ERROR'
-            let message = response.statusText
-            try {
-              const body = (await response.clone().json()) as {
-                error?: { code?: string; message?: string }
-              }
-              code = body?.error?.code ?? code
-              message = body?.error?.message ?? message
-            } catch {
-              /* ignore parse errors */
-            }
-            throw new ApiError(code, message, response.status)
-          }
-        },
-      ],
-    },
-    ...extraOptions,
-  })
-}

package/src/api/pings.ts

@@ -1,79 +0,0 @@
-import { createClient } from './client.ts'
-import type { Ping } from '@gitping/shared'
-
-/** Server extends Ping with an optional thread_id when status is accepted. */
-export interface PingWithThread extends Ping {
-  thread_id?: string
-}
-
-export interface SendPingInput {
-  recipient: string
-  message: string
-  category: string
-}
-
-export interface PingsFilter {
-  filter?: 'unread' | 'pending' | 'sent'
-  cursor?: string
-}
-
-export interface PingsPage {
-  data: PingWithThread[]
-  nextCursor: string | null
-}
-
-/** Send a new ping to a recipient. */
-export async function sendPing(input: SendPingInput): Promise<Ping> {
-  const client = await createClient()
-  return client.post('v1/pings', { json: input }).json<Ping>()
-}
-
-/** List pings in the authenticated user's inbox. */
-export async function listPings(opts: PingsFilter = {}): Promise<PingsPage> {
-  const client = await createClient()
-  const searchParams: Record<string, string> = {}
-  if (opts.filter) searchParams['filter'] = opts.filter
-  if (opts.cursor) searchParams['cursor'] = opts.cursor
-  return client.get('v1/pings', { searchParams }).json<PingsPage>()
-}
-
-/** Get a single ping by ID. */
-export async function getPing(id: string): Promise<PingWithThread> {
-  const client = await createClient()
-  return client.get(`v1/pings/${id}`).json<PingWithThread>()
-}
-
-export interface AcceptPingResponse {
-  thread_id: string
-  ping_id: string
-}
-
-export interface PingActionResponse {
-  message: string
-}
-
-/** Accept a ping by ID. Returns thread_id for opening a chat. */
-export async function acceptPing(id: string): Promise<AcceptPingResponse> {
-  const client = await createClient()
-  return client.patch(`v1/pings/${id}/accept`).json<AcceptPingResponse>()
-}
-
-/** Accept a ping by the sender's username. Returns thread_id for opening a chat. */
-export async function acceptPingByUsername(username: string): Promise<AcceptPingResponse> {
-  const client = await createClient()
-  return client
-    .patch(`v1/pings/by-sender/${encodeURIComponent(username)}/accept`)
-    .json<AcceptPingResponse>()
-}
-
-/** Ignore a ping by ID. */
-export async function ignorePing(id: string): Promise<PingActionResponse> {
-  const client = await createClient()
-  return client.patch(`v1/pings/${id}/ignore`).json<PingActionResponse>()
-}
-
-/** Block the sender of a ping by ID. */
-export async function blockPing(id: string): Promise<PingActionResponse> {
-  const client = await createClient()
-  return client.patch(`v1/pings/${id}/block`).json<PingActionResponse>()
-}

package/src/api/threads.ts

@@ -1,14 +0,0 @@
-import { createClient } from './client.ts'
-import type { Thread, Message } from '@gitping/shared'
-
-/** Get a thread and its messages by thread ID. */
-export async function getThread(id: string): Promise<{ thread: Thread; messages: Message[] }> {
-  const client = await createClient()
-  return client.get(`v1/threads/${id}`).json<{ thread: Thread; messages: Message[] }>()
-}
-
-/** Send a message in a thread. */
-export async function sendMessage(threadId: string, body: string): Promise<Message> {
-  const client = await createClient()
-  return client.post(`v1/threads/${threadId}/messages`, { json: { body } }).json<Message>()
-}

package/src/api/users.ts

@@ -1,43 +0,0 @@
-import { createClient } from './client.ts'
-import type { User, PublicProfile } from '@gitping/shared'
-
-export interface UpdateProfileInput {
-  availability?: string
-  availability_msg?: string
-  bio?: string
-}
-
-/** Get the authenticated user's full profile. */
-export async function getMe(): Promise<User> {
-  const client = await createClient()
-  return client.get('v1/me').json<User>()
-}
-
-/** Update the authenticated user's profile. */
-export async function updateMe(input: UpdateProfileInput): Promise<User> {
-  const client = await createClient()
-  return client.patch('v1/me', { json: input }).json<User>()
-}
-
-/** Get a user's public profile by GitHub username. */
-export async function getUser(username: string): Promise<PublicProfile> {
-  const client = await createClient()
-  return client.get(`v1/users/${username}`).json<PublicProfile>()
-}
-
-export interface LeaderboardEntry {
-  github_username: string
-  avatar_url: string | null
-  rep_score: number
-  rep_tier: string
-  ping_count: number
-}
-
-/** Get the leaderboard of most-pinged developers. */
-export async function getLeaderboard(rising?: boolean): Promise<LeaderboardEntry[]> {
-  const client = await createClient()
-  const searchParams: Record<string, string> = {}
-  if (rising) searchParams['rising'] = 'true'
-  // Server needs to implement: GET /v1/users/leaderboard?rising=true
-  return client.get('v1/users/leaderboard', { searchParams }).json<LeaderboardEntry[]>()
-}

package/src/auth/keychain.ts

@@ -1,28 +0,0 @@
-const SERVICE = 'gitping-cli'
-const ACCOUNT = 'jwt'
-
-/** Returns the stored JWT, or null if not found. */
-export async function getToken(): Promise<string | null> {
-  try {
-    const { default: keytar } = await import('keytar')
-    return keytar.getPassword(SERVICE, ACCOUNT)
-  } catch {
-    return null
-  }
-}
-
-/** Persists the JWT in the OS keychain. */
-export async function setToken(token: string): Promise<void> {
-  const { default: keytar } = await import('keytar')
-  await keytar.setPassword(SERVICE, ACCOUNT, token)
-}
-
-/** Removes the stored JWT from the OS keychain. */
-export async function deleteToken(): Promise<void> {
-  try {
-    const { default: keytar } = await import('keytar')
-    await keytar.deletePassword(SERVICE, ACCOUNT)
-  } catch {
-    // nothing to delete
-  }
-}

package/src/auth/pkce.ts

@@ -1,24 +0,0 @@
-import crypto from 'crypto'
-
-/**
- * Generates a PKCE code_verifier: a cryptographically random URL-safe string.
- * RFC 7636 §4.1
- */
-export function generateCodeVerifier(): string {
-  return crypto.randomBytes(32).toString('base64url')
-}
-
-/**
- * Derives the code_challenge from a code_verifier using SHA-256.
- * RFC 7636 §4.2
- */
-export function generateCodeChallenge(verifier: string): string {
-  return crypto.createHash('sha256').update(verifier).digest('base64url')
-}
-
-/**
- * Generates a cryptographically random state parameter to prevent CSRF.
- */
-export function generateState(): string {
-  return crypto.randomBytes(16).toString('hex')
-}

package/src/commands/accept.ts

@@ -1,43 +0,0 @@
-import chalk from 'chalk'
-import ora from 'ora'
-import { acceptPing, acceptPingByUsername } from '../api/pings.ts'
-import { getToken } from '../auth/keychain.ts'
-
-interface AcceptOptions {
-  json?: boolean
-}
-
-export async function acceptCommand(target: string, options: AcceptOptions): Promise<void> {
-  const token = await getToken()
-  if (!token) {
-    console.error(chalk.red('Not logged in. Run `gitping login` first.'))
-    throw Object.assign(new Error('Not authenticated'), { exitCode: 2 })
-  }
-
-  const isUsername = target.startsWith('@')
-  const label = isUsername ? target : target.slice(0, 8)
-
-  const spinner = ora(`Accepting ping from ${isUsername ? target : `ping ${label}…`}`).start()
-
-  let result
-  try {
-    if (isUsername) {
-      const username = target.slice(1)
-      result = await acceptPingByUsername(username)
-    } else {
-      result = await acceptPing(target)
-    }
-  } catch (err) {
-    spinner.fail('Failed to accept ping')
-    throw Object.assign(err instanceof Error ? err : new Error(String(err)), { exitCode: 3 })
-  }
-
-  spinner.succeed(
-    chalk.green(`Ping accepted! Thread opened.`) +
-      chalk.dim(` (thread ${result.thread_id.slice(0, 8)})`),
-  )
-
-  if (options.json) {
-    console.log(JSON.stringify(result))
-  }
-}

package/src/commands/block.ts

@@ -1,48 +0,0 @@
-import chalk from 'chalk'
-import ora from 'ora'
-import { blockPing, listPings } from '../api/pings.ts'
-import { getToken } from '../auth/keychain.ts'
-
-interface BlockOptions {
-  json?: boolean
-}
-
-export async function blockCommand(rawTarget: string, options: BlockOptions): Promise<void> {
-  const token = await getToken()
-  if (!token) {
-    console.error(chalk.red('Not logged in. Run `gitping login` first.'))
-    throw Object.assign(new Error('Not authenticated'), { exitCode: 2 })
-  }
-
-  const isUsername = rawTarget.startsWith('@')
-  const username = isUsername ? rawTarget.slice(1) : rawTarget
-
-  const spinner = ora(
-    `Blocking ${isUsername ? '@' + username : 'sender of ping ' + username.slice(0, 8)}…`,
-  ).start()
-
-  try {
-    if (isUsername) {
-      // Find the most recent delivered ping from this sender and block it
-      const page = await listPings()
-      const ping = page.data.find((p) => p.sender_username === username && p.status === 'delivered')
-      if (!ping) {
-        spinner.fail(`No actionable ping found from @${username}`)
-        throw Object.assign(new Error('Ping not found'), { exitCode: 1 })
-      }
-      const blocked = await blockPing(ping.id)
-      spinner.succeed(chalk.red(`Blocked @${username}.`))
-      if (options.json) console.log(JSON.stringify(blocked))
-    } else {
-      // Treat rawTarget as a ping ID
-      const blocked = await blockPing(rawTarget)
-      spinner.succeed(chalk.red(`Blocked sender of ping ${rawTarget.slice(0, 8)}.`))
-      if (options.json) console.log(JSON.stringify(blocked))
-    }
-  } catch (err) {
-    const typed = err as NodeJS.ErrnoException & { exitCode?: number }
-    if (typed.exitCode) throw err
-    spinner.fail('Failed to block')
-    throw Object.assign(err instanceof Error ? err : new Error(String(err)), { exitCode: 3 })
-  }
-}

package/src/commands/chat.ts

@@ -1,181 +0,0 @@
-import chalk from 'chalk'
-import ora from 'ora'
-import readline from 'node:readline'
-import WebSocket from 'ws'
-import { listPings } from '../api/pings.ts'
-import { getMe } from '../api/users.ts'
-import { getThread, sendMessage } from '../api/threads.ts'
-import { getToken } from '../auth/keychain.ts'
-import { getApiBaseUrl } from '../config.ts'
-import type { Message, WSEvent } from '@gitping/shared'
-import { WSEventType } from '@gitping/shared'
-
-interface ChatOptions {
-  json?: boolean
-}
-
-export async function chatCommand(rawUsername: string, _options: ChatOptions): Promise<void> {
-  const token = await getToken()
-  if (!token) {
-    console.error(chalk.red('Not logged in. Run `gitping login` first.'))
-    throw Object.assign(new Error('Not authenticated'), { exitCode: 2 })
-  }
-
-  const username = rawUsername.startsWith('@') ? rawUsername.slice(1) : rawUsername
-
-  const spinner = ora(`Opening chat with @${username}…`).start()
-
-  let me: { id: string }
-  let threadId: string
-  try {
-    me = await getMe()
-    // Fetch both received and sent pings — the current user may be either side
-    const [receivedPage, sentPage] = await Promise.all([listPings(), listPings({ filter: 'sent' })])
-    const allPings = [...receivedPage.data, ...sentPage.data]
-    const ping = allPings.find(
-      (p) =>
-        p.status === 'accepted' &&
-        (p.sender_username === username || p.recipient_username === username),
-    )
-
-    if (!ping) {
-      spinner.fail(
-        `No accepted ping found with @${username}. ` +
-          `Send a ping first with \`gitping ping @${username} "message"\` and have them accept it.`,
-      )
-      throw Object.assign(new Error('No accepted ping'), { exitCode: 1 })
-    }
-
-    if (!ping.thread_id) {
-      spinner.fail(
-        `No thread found for accepted ping with @${username}. The server did not return a thread_id.`,
-      )
-      throw Object.assign(new Error('No thread_id on accepted ping'), { exitCode: 1 })
-    }
-    threadId = ping.thread_id
-  } catch (err) {
-    const typed = err as { exitCode?: number }
-    if (typed.exitCode) throw err
-    spinner.fail('Failed to load chat')
-    throw Object.assign(err instanceof Error ? err : new Error(String(err)), { exitCode: 3 })
-  }
-
-  spinner.succeed(`Chat with @${username} opened`)
-
-  // Load existing messages
-  let messages: Message[] = []
-  try {
-    const data = await getThread(threadId)
-    messages = data.messages
-  } catch {
-    // Non-fatal — we can still chat without history
-  }
-
-  // Print header
-  console.log()
-  console.log(chalk.cyan.bold('  ┌─────────────────────────────────────────┐'))
-  console.log(
-    chalk.cyan.bold('  │') +
-      chalk.bold(` ⚡ GitPing Chat with @${username}`) +
-      ' '.repeat(Math.max(0, 20 - username.length)) +
-      chalk.cyan.bold('│'),
-  )
-  console.log(chalk.cyan.bold('  └─────────────────────────────────────────┘'))
-  console.log()
-
-  // Print existing messages
-  for (const msg of messages) {
-    printMessage(msg, me.id)
-  }
-  if (messages.length === 0) {
-    console.log(chalk.dim('  No messages yet. Start the conversation!'))
-  }
-  console.log()
-
-  // Connect WebSocket for live messages
-  const baseUrl = getApiBaseUrl().replace(/^http/, 'ws')
-  const ws = new WebSocket(`${baseUrl}/v1/ws?token=${encodeURIComponent(token)}`)
-
-  let connected = false
-  ws.on('open', () => {
-    connected = true
-  })
-
-  ws.on('message', (data) => {
-    try {
-      const event = JSON.parse(data.toString()) as WSEvent
-      if (event.type === WSEventType.MESSAGE_RECEIVED) {
-        const payload = event.payload as { message: Message }
-        const msg = payload.message ?? (event.payload as Message)
-        if (msg.thread_id === threadId && msg.sender_id !== me.id) {
-          // Clear the current input line, print the message, then redisplay prompt
-          readline.clearLine(process.stdout, 0)
-          readline.cursorTo(process.stdout, 0)
-          printMessage(msg, me.id)
-          rl.prompt()
-        }
-      }
-    } catch {
-      /* ignore malformed events */
-    }
-  })
-
-  ws.on('error', () => {
-    console.log(chalk.yellow('  ⚠ WebSocket connection failed — messages may be delayed'))
-  })
-
-  // Set up readline for input
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    prompt: chalk.cyan('  > '),
-    terminal: true,
-  })
-
-  rl.prompt()
-
-  rl.on('line', async (line) => {
-    const body = line.trim()
-    if (!body) {
-      rl.prompt()
-      return
-    }
-
-    if (body === '/quit' || body === '/exit' || body === '/q') {
-      rl.close()
-      return
-    }
-
-    try {
-      const msg = await sendMessage(threadId, body)
-      // Move up to overwrite the input line, print our message
-      printMessage(msg, me.id)
-    } catch {
-      console.log(chalk.red('  ✗ Failed to send message'))
-    }
-    rl.prompt()
-  })
-
-  rl.on('close', () => {
-    ws.close()
-    console.log()
-    console.log(chalk.dim('  Chat ended. Goodbye!'))
-    console.log()
-  })
-
-  // Wait for readline to close (user types /quit or Ctrl+C/Ctrl+D)
-  await new Promise<void>((resolve) => {
-    rl.on('close', resolve)
-  })
-}
-
-function printMessage(msg: Message, myUserId: string): void {
-  const isMe = msg.sender_id === myUserId
-  const time = new Date(msg.created_at).toLocaleTimeString([], {
-    hour: '2-digit',
-    minute: '2-digit',
-  })
-  const sender = isMe ? chalk.cyan.bold('You') : chalk.white.bold('Them')
-  const prefix = isMe ? chalk.cyan('  ▸ ') : chalk.white('  ◂ ')
-  console.log(`${prefix}${sender} ${chalk.dim(time)}  ${msg.body}`)
-}

package/src/commands/ignore.ts

@@ -1,43 +0,0 @@
-import chalk from 'chalk'
-import ora from 'ora'
-import { ignorePing, listPings } from '../api/pings.ts'
-import { getToken } from '../auth/keychain.ts'
-
-interface IgnoreOptions {
-  json?: boolean
-}
-
-export async function ignoreCommand(target: string, options: IgnoreOptions): Promise<void> {
-  const token = await getToken()
-  if (!token) {
-    console.error(chalk.red('Not logged in. Run `gitping login` first.'))
-    throw Object.assign(new Error('Not authenticated'), { exitCode: 2 })
-  }
-
-  const isUsername = target.startsWith('@')
-  const spinner = ora(isUsername ? `Ignoring ping from ${target}…` : 'Ignoring ping…').start()
-
-  try {
-    if (isUsername) {
-      const username = target.slice(1)
-      const page = await listPings()
-      const ping = page.data.find((p) => p.sender_username === username && p.status === 'delivered')
-      if (!ping) {
-        spinner.fail(`No actionable ping found from @${username}`)
-        throw Object.assign(new Error('Ping not found'), { exitCode: 1 })
-      }
-      const result = await ignorePing(ping.id)
-      spinner.succeed(chalk.dim(`Ping from @${username} ignored.`))
-      if (options.json) console.log(JSON.stringify(result))
-    } else {
-      const result = await ignorePing(target)
-      spinner.succeed(chalk.dim(`Ping ${target.slice(0, 8)} ignored.`))
-      if (options.json) console.log(JSON.stringify(result))
-    }
-  } catch (err) {
-    const typed = err as { exitCode?: number }
-    if (typed.exitCode) throw err
-    spinner.fail('Failed to ignore ping')
-    throw Object.assign(err instanceof Error ? err : new Error(String(err)), { exitCode: 3 })
-  }
-}