pilothub 0.0.1 → 0.0.2

package/packages/pilothub/src/http.ts

@@ -1,301 +0,0 @@
-import { spawnSync } from 'node:child_process'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import pRetry, { AbortError } from 'p-retry'
-import { Agent, setGlobalDispatcher } from 'undici'
-import type { ArkValidator } from './schema/index.js'
-import { ApiRoutes, parseArk } from './schema/index.js'
-
-const REQUEST_TIMEOUT_MS = 15_000
-const REQUEST_TIMEOUT_SECONDS = Math.ceil(REQUEST_TIMEOUT_MS / 1000)
-const isBun = typeof process !== 'undefined' && Boolean(process.versions?.bun)
-
-if (typeof process !== 'undefined' && process.versions?.node) {
-  try {
-    setGlobalDispatcher(
-      new Agent({
-        allowH2: true,
-        connect: { timeout: REQUEST_TIMEOUT_MS },
-      }),
-    )
-  } catch {
-    // ignore dispatcher setup failures in non-node runtimes
-  }
-}
-
-type RequestArgs =
-  | { method: 'GET' | 'POST' | 'DELETE'; path: string; token?: string; body?: unknown }
-  | { method: 'GET' | 'POST' | 'DELETE'; url: string; token?: string; body?: unknown }
-
-export async function apiRequest<T>(registry: string, args: RequestArgs): Promise<T>
-export async function apiRequest<T>(
-  registry: string,
-  args: RequestArgs,
-  schema: ArkValidator<T>,
-): Promise<T>
-export async function apiRequest<T>(
-  registry: string,
-  args: RequestArgs,
-  schema?: ArkValidator<T>,
-): Promise<T> {
-  const url = 'url' in args ? args.url : new URL(args.path, registry).toString()
-  const json = await pRetry(
-    async () => {
-      if (isBun) {
-        return await fetchJsonViaCurl(url, args)
-      }
-
-      const headers: Record<string, string> = { Accept: 'application/json' }
-      if (args.token) headers.Authorization = `Bearer ${args.token}`
-      let body: string | undefined
-      if (args.method === 'POST') {
-        headers['Content-Type'] = 'application/json'
-        body = JSON.stringify(args.body ?? {})
-      }
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort('Timeout'), REQUEST_TIMEOUT_MS)
-      const response = await fetch(url, {
-        method: args.method,
-        headers,
-        body,
-        signal: controller.signal,
-      })
-      clearTimeout(timeout)
-      if (!response.ok) {
-        const text = await response.text().catch(() => '')
-        const message = text || `HTTP ${response.status}`
-        if (response.status === 429 || response.status >= 500) {
-          throw new Error(message)
-        }
-        throw new AbortError(message)
-      }
-      return (await response.json()) as unknown
-    },
-    { retries: 2 },
-  )
-  if (schema) return parseArk(schema, json, 'API response')
-  return json as T
-}
-
-type FormRequestArgs =
-  | { method: 'POST'; path: string; token?: string; form: FormData }
-  | { method: 'POST'; url: string; token?: string; form: FormData }
-
-export async function apiRequestForm<T>(registry: string, args: FormRequestArgs): Promise<T>
-export async function apiRequestForm<T>(
-  registry: string,
-  args: FormRequestArgs,
-  schema: ArkValidator<T>,
-): Promise<T>
-export async function apiRequestForm<T>(
-  registry: string,
-  args: FormRequestArgs,
-  schema?: ArkValidator<T>,
-): Promise<T> {
-  const url = 'url' in args ? args.url : new URL(args.path, registry).toString()
-  const json = await pRetry(
-    async () => {
-      if (isBun) {
-        return await fetchJsonFormViaCurl(url, args)
-      }
-
-      const headers: Record<string, string> = { Accept: 'application/json' }
-      if (args.token) headers.Authorization = `Bearer ${args.token}`
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort('Timeout'), REQUEST_TIMEOUT_MS)
-      const response = await fetch(url, {
-        method: args.method,
-        headers,
-        body: args.form,
-        signal: controller.signal,
-      })
-      clearTimeout(timeout)
-      if (!response.ok) {
-        const text = await response.text().catch(() => '')
-        const message = text || `HTTP ${response.status}`
-        if (response.status === 429 || response.status >= 500) {
-          throw new Error(message)
-        }
-        throw new AbortError(message)
-      }
-      return (await response.json()) as unknown
-    },
-    { retries: 2 },
-  )
-  if (schema) return parseArk(schema, json, 'API response')
-  return json as T
-}
-
-export async function downloadZip(registry: string, args: { slug: string; version?: string }) {
-  const url = new URL(ApiRoutes.download, registry)
-  url.searchParams.set('slug', args.slug)
-  if (args.version) url.searchParams.set('version', args.version)
-  return pRetry(
-    async () => {
-      if (isBun) {
-        return await fetchBinaryViaCurl(url.toString())
-      }
-
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort('Timeout'), REQUEST_TIMEOUT_MS)
-      const response = await fetch(url.toString(), { method: 'GET', signal: controller.signal })
-      clearTimeout(timeout)
-      if (!response.ok) {
-        const message = (await response.text().catch(() => '')) || `HTTP ${response.status}`
-        if (response.status === 429 || response.status >= 500) {
-          throw new Error(message)
-        }
-        throw new AbortError(message)
-      }
-      return new Uint8Array(await response.arrayBuffer())
-    },
-    { retries: 2 },
-  )
-}
-
-async function fetchJsonViaCurl(url: string, args: RequestArgs) {
-  const headers = ['-H', 'Accept: application/json']
-  if (args.token) {
-    headers.push('-H', `Authorization: Bearer ${args.token}`)
-  }
-  const curlArgs = [
-    '--silent',
-    '--show-error',
-    '--location',
-    '--max-time',
-    String(REQUEST_TIMEOUT_SECONDS),
-    '--write-out',
-    '\n%{http_code}',
-    '-X',
-    args.method,
-    ...headers,
-    url,
-  ]
-  if (args.method === 'POST') {
-    curlArgs.push('-H', 'Content-Type: application/json')
-    curlArgs.push('--data-binary', JSON.stringify(args.body ?? {}))
-  }
-
-  const result = spawnSync('curl', curlArgs, { encoding: 'utf8' })
-  if (result.status !== 0) {
-    throw new Error(result.stderr || 'curl failed')
-  }
-  const output = result.stdout ?? ''
-  const splitAt = output.lastIndexOf('\n')
-  if (splitAt === -1) throw new Error('curl response missing status')
-  const body = output.slice(0, splitAt)
-  const status = Number(output.slice(splitAt + 1).trim())
-  if (!Number.isFinite(status)) throw new Error('curl response missing status')
-  if (status < 200 || status >= 300) {
-    if (status === 429 || status >= 500) {
-      throw new Error(body || `HTTP ${status}`)
-    }
-    throw new AbortError(body || `HTTP ${status}`)
-  }
-  return JSON.parse(body || 'null') as unknown
-}
-
-async function fetchJsonFormViaCurl(url: string, args: FormRequestArgs) {
-  const headers = ['-H', 'Accept: application/json']
-  if (args.token) {
-    headers.push('-H', `Authorization: Bearer ${args.token}`)
-  }
-
-  const tempDir = await mkdtemp(join(tmpdir(), 'pilothub-upload-'))
-  try {
-    const formArgs: string[] = []
-    for (const [key, value] of args.form.entries()) {
-      if (value instanceof Blob) {
-        const filename = typeof (value as File).name === 'string' ? (value as File).name : 'file'
-        const filePath = join(tempDir, filename)
-        const bytes = new Uint8Array(await value.arrayBuffer())
-        await writeFile(filePath, bytes)
-        formArgs.push('-F', `${key}=@${filePath};filename=${filename}`)
-      } else {
-        formArgs.push('-F', `${key}=${String(value)}`)
-      }
-    }
-
-    const curlArgs = [
-      '--silent',
-      '--show-error',
-      '--location',
-      '--max-time',
-      String(REQUEST_TIMEOUT_SECONDS),
-      '--write-out',
-      '\n%{http_code}',
-      '-X',
-      args.method,
-      ...headers,
-      ...formArgs,
-      url,
-    ]
-
-    const result = spawnSync('curl', curlArgs, { encoding: 'utf8' })
-    if (result.status !== 0) {
-      throw new Error(result.stderr || 'curl failed')
-    }
-    const output = result.stdout ?? ''
-    const splitAt = output.lastIndexOf('\n')
-    if (splitAt === -1) throw new Error('curl response missing status')
-    const body = output.slice(0, splitAt)
-    const status = Number(output.slice(splitAt + 1).trim())
-    if (!Number.isFinite(status)) throw new Error('curl response missing status')
-    if (status < 200 || status >= 300) {
-      if (status === 429 || status >= 500) {
-        throw new Error(body || `HTTP ${status}`)
-      }
-      throw new AbortError(body || `HTTP ${status}`)
-    }
-    return JSON.parse(body || 'null') as unknown
-  } finally {
-    await rm(tempDir, { recursive: true, force: true })
-  }
-}
-
-async function fetchBinaryViaCurl(url: string) {
-  const tempDir = await mkdtemp(join(tmpdir(), 'pilothub-download-'))
-  const filePath = join(tempDir, 'payload.bin')
-  try {
-    const curlArgs = [
-      '--silent',
-      '--show-error',
-      '--location',
-      '--max-time',
-      String(REQUEST_TIMEOUT_SECONDS),
-      '-o',
-      filePath,
-      '--write-out',
-      '%{http_code}',
-      url,
-    ]
-    const result = spawnSync('curl', curlArgs, { encoding: 'utf8' })
-    if (result.status !== 0) {
-      throw new Error(result.stderr || 'curl failed')
-    }
-    const status = Number((result.stdout ?? '').trim())
-    if (!Number.isFinite(status)) throw new Error('curl response missing status')
-    if (status < 200 || status >= 300) {
-      const body = await readFileSafe(filePath)
-      const message = body ? new TextDecoder().decode(body) : `HTTP ${status}`
-      if (status === 429 || status >= 500) {
-        throw new Error(message)
-      }
-      throw new AbortError(message)
-    }
-    const bytes = await readFileSafe(filePath)
-    return bytes ? new Uint8Array(bytes) : new Uint8Array()
-  } finally {
-    await rm(tempDir, { recursive: true, force: true })
-  }
-}
-
-async function readFileSafe(path: string) {
-  try {
-    const { readFile } = await import('node:fs/promises')
-    return await readFile(path)
-  } catch {
-    return null
-  }
-}

package/packages/pilothub/src/schema/ark.ts

@@ -1,29 +0,0 @@
-import { ArkErrors } from 'arktype'
-
-export type ArkValidator<T> = (data: unknown) => T | ArkErrors
-
-export function parseArk<T>(schema: ArkValidator<T>, data: unknown, label: string) {
-  const result = schema(data)
-  if (result instanceof ArkErrors) {
-    throw new Error(`${label}: ${formatArkErrors(result)}`)
-  }
-  return result
-}
-
-export function formatArkErrors(errors: ArkErrors) {
-  const parts: string[] = []
-  for (const error of errors) {
-    if (parts.length >= 3) break
-    const path = Array.isArray(error.path) ? error.path.join('.') : ''
-    const location = path ? `${path}: ` : ''
-    const description =
-      typeof (error as { description?: unknown }).description === 'string'
-        ? ((error as { description: string }).description as string)
-        : 'invalid value'
-    parts.push(`${location}${description}`)
-  }
-  if (errors.count > parts.length) {
-    parts.push(`+${errors.count - parts.length} more`)
-  }
-  return parts.join('; ')
-}

package/packages/pilothub/src/schema/index.ts

@@ -1,5 +0,0 @@
-export type { ArkValidator } from './ark.js'
-export { formatArkErrors, parseArk } from './ark.js'
-export { ApiRoutes, LegacyApiRoutes } from './routes.js'
-export * from './schemas.js'
-export * from './textFiles.js'

package/packages/pilothub/src/schema/routes.ts

@@ -1,22 +0,0 @@
-export const LegacyApiRoutes = {
-  download: '/api/download',
-  search: '/api/search',
-  skill: '/api/skill',
-  skillResolve: '/api/skill/resolve',
-  cliWhoami: '/api/cli/whoami',
-  cliUploadUrl: '/api/cli/upload-url',
-  cliPublish: '/api/cli/publish',
-  cliTelemetrySync: '/api/cli/telemetry/sync',
-  cliSkillDelete: '/api/cli/skill/delete',
-  cliSkillUndelete: '/api/cli/skill/undelete',
-} as const
-
-export const ApiRoutes = {
-  search: '/api/v1/search',
-  resolve: '/api/v1/resolve',
-  download: '/api/v1/download',
-  skills: '/api/v1/skills',
-  stars: '/api/v1/stars',
-  souls: '/api/v1/souls',
-  whoami: '/api/v1/whoami',
-} as const

package/packages/pilothub/src/schema/schemas.ts

@@ -1,260 +0,0 @@
-import { type inferred, type } from 'arktype'
-
-export const GlobalConfigSchema = type({
-  registry: 'string',
-  token: 'string?',
-})
-export type GlobalConfig = (typeof GlobalConfigSchema)[inferred]
-
-export const WellKnownConfigSchema = type({
-  apiBase: 'string',
-  authBase: 'string?',
-  minCliVersion: 'string?',
-}).or({
-  registry: 'string',
-  authBase: 'string?',
-  minCliVersion: 'string?',
-})
-export type WellKnownConfig = (typeof WellKnownConfigSchema)[inferred]
-
-export const LockfileSchema = type({
-  version: '1',
-  skills: {
-    '[string]': {
-      version: 'string|null',
-      installedAt: 'number',
-    },
-  },
-})
-export type Lockfile = (typeof LockfileSchema)[inferred]
-
-export const ApiCliWhoamiResponseSchema = type({
-  user: {
-    handle: 'string|null',
-  },
-})
-
-export const ApiSearchResponseSchema = type({
-  results: type({
-    slug: 'string?',
-    displayName: 'string?',
-    version: 'string|null?',
-    score: 'number',
-  }).array(),
-})
-
-export const ApiSkillMetaResponseSchema = type({
-  latestVersion: type({
-    version: 'string',
-  }).optional(),
-  skill: 'unknown|null?',
-})
-
-export const ApiCliUploadUrlResponseSchema = type({
-  uploadUrl: 'string',
-})
-
-export const ApiUploadFileResponseSchema = type({
-  storageId: 'string',
-})
-
-export const CliPublishFileSchema = type({
-  path: 'string',
-  size: 'number',
-  storageId: 'string',
-  sha256: 'string',
-  contentType: 'string?',
-})
-export type CliPublishFile = (typeof CliPublishFileSchema)[inferred]
-
-export const CliPublishRequestSchema = type({
-  slug: 'string',
-  displayName: 'string',
-  version: 'string',
-  changelog: 'string',
-  tags: 'string[]?',
-  forkOf: type({
-    slug: 'string',
-    version: 'string?',
-  }).optional(),
-  files: CliPublishFileSchema.array(),
-})
-export type CliPublishRequest = (typeof CliPublishRequestSchema)[inferred]
-
-export const ApiCliPublishResponseSchema = type({
-  ok: 'true',
-  skillId: 'string',
-  versionId: 'string',
-})
-
-export const CliSkillDeleteRequestSchema = type({
-  slug: 'string',
-})
-export type CliSkillDeleteRequest = (typeof CliSkillDeleteRequestSchema)[inferred]
-
-export const ApiCliSkillDeleteResponseSchema = type({
-  ok: 'true',
-})
-
-export const ApiSkillResolveResponseSchema = type({
-  match: type({ version: 'string' }).or('null'),
-  latestVersion: type({ version: 'string' }).or('null'),
-})
-
-export const CliTelemetrySyncRequestSchema = type({
-  roots: type({
-    rootId: 'string',
-    label: 'string',
-    skills: type({
-      slug: 'string',
-      version: 'string|null?',
-    }).array(),
-  }).array(),
-})
-export type CliTelemetrySyncRequest = (typeof CliTelemetrySyncRequestSchema)[inferred]
-
-export const ApiCliTelemetrySyncResponseSchema = type({
-  ok: 'true',
-})
-
-export const ApiV1WhoamiResponseSchema = type({
-  user: {
-    handle: 'string|null',
-    displayName: 'string|null?',
-    image: 'string|null?',
-  },
-})
-
-export const ApiV1SearchResponseSchema = type({
-  results: type({
-    slug: 'string?',
-    displayName: 'string?',
-    summary: 'string|null?',
-    version: 'string|null?',
-    score: 'number',
-    updatedAt: 'number?',
-  }).array(),
-})
-
-export const ApiV1SkillListResponseSchema = type({
-  items: type({
-    slug: 'string',
-    displayName: 'string',
-    summary: 'string|null?',
-    tags: 'unknown',
-    stats: 'unknown',
-    createdAt: 'number',
-    updatedAt: 'number',
-    latestVersion: type({
-      version: 'string',
-      createdAt: 'number',
-      changelog: 'string',
-    }).optional(),
-  }).array(),
-  nextCursor: 'string|null',
-})
-
-export const ApiV1SkillResponseSchema = type({
-  skill: type({
-    slug: 'string',
-    displayName: 'string',
-    summary: 'string|null?',
-    tags: 'unknown',
-    stats: 'unknown',
-    createdAt: 'number',
-    updatedAt: 'number',
-  }).or('null'),
-  latestVersion: type({
-    version: 'string',
-    createdAt: 'number',
-    changelog: 'string',
-  }).or('null'),
-  owner: type({
-    handle: 'string|null',
-    displayName: 'string|null?',
-    image: 'string|null?',
-  }).or('null'),
-})
-
-export const ApiV1SkillVersionListResponseSchema = type({
-  items: type({
-    version: 'string',
-    createdAt: 'number',
-    changelog: 'string',
-    changelogSource: '"auto"|"user"|null?',
-  }).array(),
-  nextCursor: 'string|null',
-})
-
-export const ApiV1SkillVersionResponseSchema = type({
-  version: type({
-    version: 'string',
-    createdAt: 'number',
-    changelog: 'string',
-    changelogSource: '"auto"|"user"|null?',
-    files: 'unknown?',
-  }).or('null'),
-  skill: type({
-    slug: 'string',
-    displayName: 'string',
-  }).or('null'),
-})
-
-export const ApiV1SkillResolveResponseSchema = type({
-  match: type({ version: 'string' }).or('null'),
-  latestVersion: type({ version: 'string' }).or('null'),
-})
-
-export const ApiV1PublishResponseSchema = type({
-  ok: 'true',
-  skillId: 'string',
-  versionId: 'string',
-})
-
-export const ApiV1DeleteResponseSchema = type({
-  ok: 'true',
-})
-
-export const ApiV1StarResponseSchema = type({
-  ok: 'true',
-  starred: 'boolean',
-  alreadyStarred: 'boolean',
-})
-
-export const ApiV1UnstarResponseSchema = type({
-  ok: 'true',
-  unstarred: 'boolean',
-  alreadyUnstarred: 'boolean',
-})
-
-export const SkillInstallSpecSchema = type({
-  id: 'string?',
-  kind: '"brew"|"node"|"go"|"uv"',
-  label: 'string?',
-  bins: 'string[]?',
-  formula: 'string?',
-  tap: 'string?',
-  package: 'string?',
-  module: 'string?',
-})
-export type SkillInstallSpec = (typeof SkillInstallSpecSchema)[inferred]
-
-export const PilotbotRequiresSchema = type({
-  bins: 'string[]?',
-  anyBins: 'string[]?',
-  env: 'string[]?',
-  config: 'string[]?',
-})
-export type PilotbotRequires = (typeof PilotbotRequiresSchema)[inferred]
-
-export const PilotbotSkillMetadataSchema = type({
-  always: 'boolean?',
-  skillKey: 'string?',
-  primaryEnv: 'string?',
-  emoji: 'string?',
-  homepage: 'string?',
-  os: 'string[]?',
-  requires: PilotbotRequiresSchema.optional(),
-  install: SkillInstallSpecSchema.array().optional(),
-})
-export type PilotbotSkillMetadata = (typeof PilotbotSkillMetadataSchema)[inferred]

package/packages/pilothub/src/schema/textFiles.test.ts

@@ -1,23 +0,0 @@
-/* @vitest-environment node */
-
-import { describe, expect, it } from 'vitest'
-import * as schema from '.'
-import { isTextContentType, TEXT_FILE_EXTENSION_SET } from './textFiles'
-
-describe('packages/pilothub schema textFiles', () => {
-  it('exports text-file extension set', () => {
-    expect(TEXT_FILE_EXTENSION_SET.has('md')).toBe(true)
-    expect(TEXT_FILE_EXTENSION_SET.has('exe')).toBe(false)
-  })
-
-  it('detects text content types with parameters', () => {
-    expect(isTextContentType('text/plain; charset=utf-8')).toBe(true)
-    expect(isTextContentType('application/json; charset=utf-8')).toBe(true)
-    expect(isTextContentType('application/octet-stream')).toBe(false)
-  })
-
-  it('re-exports helpers from index', () => {
-    expect(typeof schema.isTextContentType).toBe('function')
-    expect(schema.isTextContentType('application/markdown')).toBe(true)
-  })
-})