pilothub 0.0.1 → 0.0.2

package/convex/lib/githubSoulBackup.ts

@@ -1,443 +0,0 @@
-'use node'
-
-import { createPrivateKey, createSign } from 'node:crypto'
-import type { Id } from '../_generated/dataModel'
-import type { ActionCtx } from '../_generated/server'
-
-const GITHUB_API = 'https://api.github.com'
-const DEFAULT_REPO = 'pilotbot/souls'
-const DEFAULT_ROOT = 'souls'
-const META_FILENAME = '_meta.json'
-const USER_AGENT = 'pilothub/souls-backup'
-
-type BackupFile = {
-  path: string
-  size: number
-  storageId: Id<'_storage'>
-  sha256: string
-  contentType?: string
-}
-
-type BackupParams = {
-  slug: string
-  version: string
-  displayName: string
-  ownerHandle: string
-  files: BackupFile[]
-  publishedAt: number
-}
-
-type RepoInfo = {
-  default_branch?: string
-}
-
-type GitRef = {
-  object: { sha: string }
-}
-
-type GitCommit = {
-  sha: string
-  tree: { sha: string }
-}
-
-type GitTreeEntry = {
-  path?: string
-  type?: string
-}
-
-type GitTree = {
-  tree?: GitTreeEntry[]
-}
-
-type MetaFile = {
-  owner: string
-  slug: string
-  displayName: string
-  latest: {
-    version: string
-    publishedAt: number
-    commit: string | null
-  }
-  history: Array<{
-    version: string
-    publishedAt: number
-    commit: string
-  }>
-}
-
-export type GitHubBackupContext = {
-  token: string
-  repo: string
-  repoOwner: string
-  repoName: string
-  branch: string
-  root: string
-}
-
-export function isGitHubSoulBackupConfigured() {
-  return Boolean(
-    process.env.GITHUB_APP_ID &&
-      process.env.GITHUB_APP_PRIVATE_KEY &&
-      process.env.GITHUB_APP_INSTALLATION_ID,
-  )
-}
-
-export async function getGitHubSoulBackupContext(): Promise<GitHubBackupContext> {
-  const repo = process.env.GITHUB_SOULS_REPO ?? DEFAULT_REPO
-  const root = process.env.GITHUB_SOULS_ROOT ?? DEFAULT_ROOT
-  const [repoOwner, repoName] = parseRepo(repo)
-  const token = await createInstallationToken()
-  const repoInfo = await githubGet<RepoInfo>(token, `/repos/${repoOwner}/${repoName}`)
-  const branch = repoInfo.default_branch ?? 'main'
-
-  return { token, repo, repoOwner, repoName, branch, root }
-}
-
-export async function fetchGitHubSoulMeta(
-  context: GitHubBackupContext,
-  ownerHandle: string,
-  slug: string,
-): Promise<MetaFile | null> {
-  const soulRoot = buildSoulRoot(context.root, ownerHandle, slug)
-  return fetchMetaFile(
-    context.token,
-    context.repoOwner,
-    context.repoName,
-    `${soulRoot}/${META_FILENAME}`,
-    context.branch,
-  )
-}
-
-export async function backupSoulToGitHub(
-  ctx: ActionCtx,
-  params: BackupParams,
-  context?: GitHubBackupContext,
-) {
-  if (!isGitHubSoulBackupConfigured()) return
-
-  const resolved = context ?? (await getGitHubSoulBackupContext())
-  const soulRoot = buildSoulRoot(resolved.root, params.ownerHandle, params.slug)
-  const ref = await githubGet<GitRef>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/ref/heads/${resolved.branch}`,
-  )
-  const baseCommitSha = ref.object.sha
-  const baseCommit = await githubGet<GitCommit>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/commits/${baseCommitSha}`,
-  )
-  const baseTreeSha = baseCommit.tree.sha
-  const existingTree = await githubGet<GitTree>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/trees/${baseTreeSha}?recursive=1`,
-  )
-
-  const prefix = `${soulRoot}/`
-  const existingPaths = new Set(
-    (existingTree.tree ?? [])
-      .filter((entry) => entry.type === 'blob' && entry.path?.startsWith(prefix))
-      .map((entry) => entry.path ?? ''),
-  )
-
-  const newPaths = new Set<string>()
-  const treeEntries: Array<{
-    path: string
-    mode: '100644'
-    type: 'blob'
-    sha: string | null
-  }> = []
-
-  for (const file of params.files) {
-    const content = await fetchStorageBase64(ctx, file.storageId)
-    const blobSha = await createBlob(resolved.token, resolved.repoOwner, resolved.repoName, content)
-    const path = `${soulRoot}/${file.path}`
-    newPaths.add(path)
-    treeEntries.push({ path, mode: '100644', type: 'blob', sha: blobSha })
-  }
-
-  const existingMeta = await fetchMetaFile(
-    resolved.token,
-    resolved.repoOwner,
-    resolved.repoName,
-    `${soulRoot}/${META_FILENAME}`,
-    resolved.branch,
-  )
-  const metaPath = `${soulRoot}/${META_FILENAME}`
-  const metaDraft = buildMetaFile(params, existingMeta, resolved.repo, baseCommitSha, null)
-  const metaDraftContent = `${JSON.stringify(metaDraft, null, 2)}\n`
-  const metaDraftSha = await createBlob(
-    resolved.token,
-    resolved.repoOwner,
-    resolved.repoName,
-    toBase64(metaDraftContent),
-  )
-  newPaths.add(metaPath)
-  treeEntries.push({ path: metaPath, mode: '100644', type: 'blob', sha: metaDraftSha })
-
-  for (const path of existingPaths) {
-    if (newPaths.has(path)) continue
-    treeEntries.push({ path, mode: '100644', type: 'blob', sha: null })
-  }
-
-  const newTree = await githubPost<{ sha: string }>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/trees`,
-    {
-      base_tree: baseTreeSha,
-      tree: treeEntries,
-    },
-  )
-
-  const commit = await githubPost<GitCommit>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/commits`,
-    {
-      message: `soul: ${params.slug} v${params.version}`,
-      tree: newTree.sha,
-      parents: [baseCommitSha],
-    },
-  )
-
-  const metaFinal = buildMetaFile(params, existingMeta, resolved.repo, baseCommitSha, commit.sha)
-  const metaFinalContent = `${JSON.stringify(metaFinal, null, 2)}\n`
-  const metaFinalSha = await createBlob(
-    resolved.token,
-    resolved.repoOwner,
-    resolved.repoName,
-    toBase64(metaFinalContent),
-  )
-  const metaTree = await githubPost<{ sha: string }>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/trees`,
-    {
-      base_tree: commit.tree.sha,
-      tree: [{ path: metaPath, mode: '100644', type: 'blob', sha: metaFinalSha }],
-    },
-  )
-  const metaCommit = await githubPost<GitCommit>(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/commits`,
-    {
-      message: `meta: ${params.slug} v${params.version}`,
-      tree: metaTree.sha,
-      parents: [commit.sha],
-    },
-  )
-
-  await githubPatch(
-    resolved.token,
-    `/repos/${resolved.repoOwner}/${resolved.repoName}/git/refs/heads/${resolved.branch}`,
-    {
-      sha: metaCommit.sha,
-    },
-  )
-}
-
-function buildMetaFile(
-  params: BackupParams,
-  existing: MetaFile | null,
-  repo: string,
-  baseCommitSha: string,
-  latestCommitSha: string | null,
-): MetaFile {
-  let history = [...(existing?.history ?? [])]
-  if (existing?.latest?.version) {
-    const previousCommit = existing.latest.commit ?? commitUrl(repo, baseCommitSha)
-    const previous = {
-      version: existing.latest.version,
-      publishedAt: existing.latest.publishedAt,
-      commit: previousCommit,
-    }
-    history = [previous, ...history.filter((entry) => entry.version !== previous.version)]
-  }
-
-  return {
-    owner: normalizeOwner(params.ownerHandle),
-    slug: params.slug,
-    displayName: params.displayName,
-    latest: {
-      version: params.version,
-      publishedAt: params.publishedAt,
-      commit: latestCommitSha ? commitUrl(repo, latestCommitSha) : null,
-    },
-    history: history.slice(0, 200),
-  }
-}
-
-async function fetchMetaFile(
-  token: string,
-  repoOwner: string,
-  repoName: string,
-  path: string,
-  branch: string,
-): Promise<MetaFile | null> {
-  try {
-    const response = await githubGet<{ content?: string }>(
-      token,
-      `/repos/${repoOwner}/${repoName}/contents/${encodePath(path)}?ref=${branch}`,
-    )
-    if (!response.content) return null
-    const raw = fromBase64(response.content)
-    return JSON.parse(raw) as MetaFile
-  } catch (error) {
-    if (isNotFoundError(error)) return null
-    throw error
-  }
-}
-
-async function fetchStorageBase64(ctx: ActionCtx, storageId: Id<'_storage'>) {
-  const blob = await ctx.storage.get(storageId)
-  if (!blob) throw new Error('File missing in storage')
-  const buffer = Buffer.from(await blob.arrayBuffer())
-  return buffer.toString('base64')
-}
-
-async function createInstallationToken() {
-  const appId = process.env.GITHUB_APP_ID
-  const installationId = process.env.GITHUB_APP_INSTALLATION_ID
-  if (!appId || !installationId) {
-    throw new Error('GitHub App credentials missing')
-  }
-  const jwt = createAppJwt(appId)
-  const response = await fetch(`${GITHUB_API}/app/installations/${installationId}/access_tokens`, {
-    method: 'POST',
-    headers: buildHeaders(jwt, true),
-  })
-  if (!response.ok) {
-    const message = await response.text()
-    throw new Error(`GitHub App token failed: ${message}`)
-  }
-  const payload = (await response.json()) as { token?: string }
-  if (!payload.token) throw new Error('GitHub App token missing')
-  return payload.token
-}
-
-function createAppJwt(appId: string) {
-  const privateKey = loadPrivateKey()
-  const now = Math.floor(Date.now() / 1000)
-  const header = { alg: 'RS256', typ: 'JWT' }
-  const payload = { iat: now - 60, exp: now + 9 * 60, iss: appId }
-  const encodedHeader = base64Url(JSON.stringify(header))
-  const encodedPayload = base64Url(JSON.stringify(payload))
-  const signingInput = `${encodedHeader}.${encodedPayload}`
-  const sign = createSign('RSA-SHA256')
-  sign.update(signingInput)
-  sign.end()
-  const signature = sign.sign(privateKey)
-  return `${signingInput}.${base64Url(signature)}`
-}
-
-function loadPrivateKey() {
-  const raw = process.env.GITHUB_APP_PRIVATE_KEY
-  if (!raw) throw new Error('GITHUB_APP_PRIVATE_KEY is not configured')
-  const normalized = raw.replace(/\\n/g, '\n')
-  return createPrivateKey(normalized)
-}
-
-async function createBlob(token: string, repoOwner: string, repoName: string, content: string) {
-  const result = await githubPost<{ sha: string }>(
-    token,
-    `/repos/${repoOwner}/${repoName}/git/blobs`,
-    {
-      content,
-      encoding: 'base64',
-    },
-  )
-  if (!result.sha) throw new Error('GitHub blob missing sha')
-  return result.sha
-}
-
-async function githubGet<T>(token: string, path: string): Promise<T> {
-  const response = await fetch(`${GITHUB_API}${path}`, {
-    headers: buildHeaders(token),
-  })
-  if (!response.ok) {
-    const message = await response.text()
-    throw new Error(`GitHub GET ${path} failed: ${message}`)
-  }
-  return (await response.json()) as T
-}
-
-async function githubPost<T>(token: string, path: string, body: unknown): Promise<T> {
-  const response = await fetch(`${GITHUB_API}${path}`, {
-    method: 'POST',
-    headers: buildHeaders(token),
-    body: JSON.stringify(body),
-  })
-  if (!response.ok) {
-    const message = await response.text()
-    throw new Error(`GitHub POST ${path} failed: ${message}`)
-  }
-  return (await response.json()) as T
-}
-
-async function githubPatch(token: string, path: string, body: unknown) {
-  const response = await fetch(`${GITHUB_API}${path}`, {
-    method: 'PATCH',
-    headers: buildHeaders(token),
-    body: JSON.stringify(body),
-  })
-  if (!response.ok) {
-    const message = await response.text()
-    throw new Error(`GitHub PATCH ${path} failed: ${message}`)
-  }
-}
-
-function buildHeaders(token: string, isAppJwt = false) {
-  return {
-    Authorization: `${isAppJwt ? 'Bearer' : 'token'} ${token}`,
-    Accept: 'application/vnd.github+json',
-    'User-Agent': USER_AGENT,
-  }
-}
-
-function parseRepo(repo: string) {
-  const [owner, name] = repo.split('/')
-  if (!owner || !name) throw new Error('GITHUB_SOULS_REPO must be owner/repo')
-  return [owner, name] as const
-}
-
-function normalizeOwner(value: string) {
-  const normalized = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-+|-+$/g, '')
-  return normalized || 'unknown'
-}
-
-function commitUrl(repo: string, sha: string) {
-  return `https://github.com/${repo}/commit/${sha}`
-}
-
-function buildSoulRoot(root: string, ownerHandle: string, slug: string) {
-  const ownerSegment = normalizeOwner(ownerHandle)
-  return `${root}/${ownerSegment}/${slug}`
-}
-
-function encodePath(path: string) {
-  return path
-    .split('/')
-    .map((segment) => encodeURIComponent(segment))
-    .join('/')
-}
-
-function base64Url(value: string | Buffer) {
-  const buffer = typeof value === 'string' ? Buffer.from(value) : value
-  return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '')
-}
-
-function toBase64(value: string) {
-  return Buffer.from(value).toString('base64')
-}
-
-function fromBase64(value: string) {
-  return Buffer.from(value, 'base64').toString('utf8')
-}
-
-function isNotFoundError(error: unknown) {
-  return (
-    error instanceof Error && (error.message.includes('404') || error.message.includes('Not Found'))
-  )
-}

package/convex/lib/leaderboards.ts

@@ -1,103 +0,0 @@
-import type { Id } from '../_generated/dataModel'
-import type { MutationCtx, QueryCtx } from '../_generated/server'
-
-const DAY_MS = 24 * 60 * 60 * 1000
-export const TRENDING_DAYS = 7
-
-type LeaderboardEntry = {
-  skillId: Id<'skills'>
-  score: number
-  installs: number
-  downloads: number
-}
-
-export function toDayKey(timestamp: number) {
-  return Math.floor(timestamp / DAY_MS)
-}
-
-export function getTrendingRange(now: number) {
-  const endDay = toDayKey(now)
-  const startDay = endDay - (TRENDING_DAYS - 1)
-  return { startDay, endDay }
-}
-
-export async function buildTrendingLeaderboard(
-  ctx: QueryCtx | MutationCtx,
-  params: { limit: number; now?: number },
-) {
-  const now = params.now ?? Date.now()
-  const { startDay, endDay } = getTrendingRange(now)
-  const rows = await ctx.db
-    .query('skillDailyStats')
-    .withIndex('by_day', (q) => q.gte('day', startDay).lte('day', endDay))
-    .collect()
-
-  const totals = new Map<Id<'skills'>, { installs: number; downloads: number }>()
-  for (const row of rows) {
-    const current = totals.get(row.skillId) ?? { installs: 0, downloads: 0 }
-    current.installs += row.installs
-    current.downloads += row.downloads
-    totals.set(row.skillId, current)
-  }
-
-  const entries = Array.from(totals, ([skillId, totalsEntry]) => ({
-    skillId,
-    installs: totalsEntry.installs,
-    downloads: totalsEntry.downloads,
-    score: totalsEntry.installs,
-  }))
-
-  const items = topN(entries, params.limit, compareTrendingEntries).sort((a, b) =>
-    compareTrendingEntries(b, a),
-  )
-
-  return { startDay, endDay, items }
-}
-
-function compareTrendingEntries(a: LeaderboardEntry, b: LeaderboardEntry) {
-  if (a.score !== b.score) return a.score - b.score
-  if (a.downloads !== b.downloads) return a.downloads - b.downloads
-  return 0
-}
-
-function topN<T>(entries: T[], limit: number, compare: (a: T, b: T) => number) {
-  if (entries.length <= limit) return entries.slice()
-
-  const heap: T[] = []
-  for (const entry of entries) {
-    if (heap.length < limit) {
-      heap.push(entry)
-      siftUp(heap, heap.length - 1, compare)
-      continue
-    }
-    if (compare(entry, heap[0]) <= 0) continue
-    heap[0] = entry
-    siftDown(heap, 0, compare)
-  }
-  return heap
-}
-
-function siftUp<T>(heap: T[], index: number, compare: (a: T, b: T) => number) {
-  let current = index
-  while (current > 0) {
-    const parent = Math.floor((current - 1) / 2)
-    if (compare(heap[current], heap[parent]) >= 0) break
-    ;[heap[current], heap[parent]] = [heap[parent], heap[current]]
-    current = parent
-  }
-}
-
-function siftDown<T>(heap: T[], index: number, compare: (a: T, b: T) => number) {
-  let current = index
-  const length = heap.length
-  while (true) {
-    const left = current * 2 + 1
-    const right = current * 2 + 2
-    let smallest = current
-    if (left < length && compare(heap[left], heap[smallest]) < 0) smallest = left
-    if (right < length && compare(heap[right], heap[smallest]) < 0) smallest = right
-    if (smallest === current) break
-    ;[heap[current], heap[smallest]] = [heap[smallest], heap[current]]
-    current = smallest
-  }
-}

package/convex/lib/moderation.ts

@@ -1,42 +0,0 @@
-import type { Doc } from '../_generated/dataModel'
-
-const FLAG_RULES: Array<{ flag: string; pattern: RegExp }> = [
-  { flag: 'suspicious.keyword', pattern: /(malware|stealer|phish|phishing|keylogger)/i },
-  { flag: 'suspicious.secrets', pattern: /(api[-_ ]?key|token|password|private key|secret)/i },
-  { flag: 'suspicious.crypto', pattern: /(wallet|seed phrase|mnemonic|crypto)/i },
-  { flag: 'suspicious.webhook', pattern: /(discord\.gg|webhook|hooks\.slack)/i },
-  { flag: 'suspicious.script', pattern: /(curl[^\n]+\|\s*(sh|bash))/i },
-  { flag: 'suspicious.url_shortener', pattern: /(bit\.ly|tinyurl\.com|t\.co|goo\.gl|is\.gd)/i },
-]
-
-export function deriveModerationFlags({
-  skill,
-  parsed,
-  files,
-}: {
-  skill: Pick<Doc<'skills'>, 'slug' | 'displayName' | 'summary'>
-  parsed: Doc<'skillVersions'>['parsed']
-  files: Doc<'skillVersions'>['files']
-}) {
-  const text = [
-    skill.slug,
-    skill.displayName,
-    skill.summary ?? '',
-    JSON.stringify(parsed?.frontmatter ?? {}),
-    JSON.stringify(parsed?.metadata ?? {}),
-    JSON.stringify((parsed as { pilotbot?: unknown } | undefined)?.pilotbot ?? {}),
-    ...files.map((file) => file.path),
-  ]
-    .filter(Boolean)
-    .join('\n')
-
-  const flags = new Set<string>()
-
-  for (const rule of FLAG_RULES) {
-    if (rule.pattern.test(text)) {
-      flags.add(rule.flag)
-    }
-  }
-
-  return Array.from(flags)
-}

package/convex/lib/public.ts

@@ -1,89 +0,0 @@
-import type { Doc } from '../_generated/dataModel'
-
-export type PublicUser = Pick<
-  Doc<'users'>,
-  '_id' | '_creationTime' | 'handle' | 'name' | 'displayName' | 'image' | 'bio'
->
-
-export type PublicSkill = Pick<
-  Doc<'skills'>,
-  | '_id'
-  | '_creationTime'
-  | 'slug'
-  | 'displayName'
-  | 'summary'
-  | 'ownerUserId'
-  | 'canonicalSkillId'
-  | 'forkOf'
-  | 'latestVersionId'
-  | 'tags'
-  | 'badges'
-  | 'stats'
-  | 'createdAt'
-  | 'updatedAt'
->
-
-export type PublicSoul = Pick<
-  Doc<'souls'>,
-  | '_id'
-  | '_creationTime'
-  | 'slug'
-  | 'displayName'
-  | 'summary'
-  | 'ownerUserId'
-  | 'latestVersionId'
-  | 'tags'
-  | 'stats'
-  | 'createdAt'
-  | 'updatedAt'
->
-
-export function toPublicUser(user: Doc<'users'> | null | undefined): PublicUser | null {
-  if (!user || user.deletedAt) return null
-  return {
-    _id: user._id,
-    _creationTime: user._creationTime,
-    handle: user.handle,
-    name: user.name,
-    displayName: user.displayName,
-    image: user.image,
-    bio: user.bio,
-  }
-}
-
-export function toPublicSkill(skill: Doc<'skills'> | null | undefined): PublicSkill | null {
-  if (!skill || skill.softDeletedAt) return null
-  return {
-    _id: skill._id,
-    _creationTime: skill._creationTime,
-    slug: skill.slug,
-    displayName: skill.displayName,
-    summary: skill.summary,
-    ownerUserId: skill.ownerUserId,
-    canonicalSkillId: skill.canonicalSkillId,
-    forkOf: skill.forkOf,
-    latestVersionId: skill.latestVersionId,
-    tags: skill.tags,
-    badges: skill.badges,
-    stats: skill.stats,
-    createdAt: skill.createdAt,
-    updatedAt: skill.updatedAt,
-  }
-}
-
-export function toPublicSoul(soul: Doc<'souls'> | null | undefined): PublicSoul | null {
-  if (!soul || soul.softDeletedAt) return null
-  return {
-    _id: soul._id,
-    _creationTime: soul._creationTime,
-    slug: soul.slug,
-    displayName: soul.displayName,
-    summary: soul.summary,
-    ownerUserId: soul.ownerUserId,
-    latestVersionId: soul.latestVersionId,
-    tags: soul.tags,
-    stats: soul.stats,
-    createdAt: soul.createdAt,
-    updatedAt: soul.updatedAt,
-  }
-}