pilothub 0.0.1

package/packages/pilothub/src/cli/commands/delete.ts

@@ -0,0 +1,83 @@
+import { readGlobalConfig } from '../../config.js'
+import { apiRequest } from '../../http.js'
+import { ApiRoutes, ApiV1DeleteResponseSchema, parseArk } from '../../schema/index.js'
+import { getRegistry } from '../registry.js'
+import type { GlobalOpts } from '../types.js'
+import { createSpinner, fail, formatError, isInteractive, promptConfirm } from '../ui.js'
+
+async function requireToken() {
+  const cfg = await readGlobalConfig()
+  const token = cfg?.token
+  if (!token) fail('Not logged in. Run: pilothub login')
+  return token
+}
+
+export async function cmdDeleteSkill(
+  opts: GlobalOpts,
+  slugArg: string,
+  options: { yes?: boolean },
+  inputAllowed: boolean,
+) {
+  const slug = slugArg.trim().toLowerCase()
+  if (!slug) fail('Slug required')
+  const allowPrompt = isInteractive() && inputAllowed !== false
+
+  if (!options.yes) {
+    if (!allowPrompt) fail('Pass --yes (no input)')
+    const ok = await promptConfirm(`Delete ${slug}? (soft delete)`)
+    if (!ok) return
+  }
+
+  const token = await requireToken()
+  const registry = await getRegistry(opts, { cache: true })
+  const spinner = createSpinner(`Deleting ${slug}`)
+  try {
+    const result = await apiRequest(
+      registry,
+      { method: 'DELETE', path: `${ApiRoutes.skills}/${encodeURIComponent(slug)}`, token },
+      ApiV1DeleteResponseSchema,
+    )
+    spinner.succeed(`OK. Deleted ${slug}`)
+    return parseArk(ApiV1DeleteResponseSchema, result, 'Delete response')
+  } catch (error) {
+    spinner.fail(formatError(error))
+    throw error
+  }
+}
+
+export async function cmdUndeleteSkill(
+  opts: GlobalOpts,
+  slugArg: string,
+  options: { yes?: boolean },
+  inputAllowed: boolean,
+) {
+  const slug = slugArg.trim().toLowerCase()
+  if (!slug) fail('Slug required')
+  const allowPrompt = isInteractive() && inputAllowed !== false
+
+  if (!options.yes) {
+    if (!allowPrompt) fail('Pass --yes (no input)')
+    const ok = await promptConfirm(`Undelete ${slug}?`)
+    if (!ok) return
+  }
+
+  const token = await requireToken()
+  const registry = await getRegistry(opts, { cache: true })
+  const spinner = createSpinner(`Undeleting ${slug}`)
+  try {
+    const result = await apiRequest(
+      registry,
+      {
+        method: 'POST',
+        path: `${ApiRoutes.skills}/${encodeURIComponent(slug)}/undelete`,
+        token,
+      },
+      ApiV1DeleteResponseSchema,
+    )
+    spinner.succeed(`OK. Undeleted ${slug}`)
+    return parseArk(ApiV1DeleteResponseSchema, result, 'Undelete response')
+  } catch (error) {
+    spinner.fail(formatError(error))
+    throw error
+  }
+}

package/packages/pilothub/src/cli/commands/publish.test.ts

@@ -0,0 +1,122 @@
+/* @vitest-environment node */
+
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { GlobalOpts } from '../types'
+
+vi.mock('../../config.js', () => ({
+  readGlobalConfig: vi.fn(async () => ({ registry: 'https://pilothub.com', token: 'tkn' })),
+}))
+
+const mockGetRegistry = vi.fn(async (_opts: unknown, _params?: unknown) => 'https://pilothub.com')
+vi.mock('../registry.js', () => ({
+  getRegistry: (opts: unknown, params?: unknown) => mockGetRegistry(opts, params),
+}))
+
+const mockApiRequestForm = vi.fn()
+vi.mock('../../http.js', () => ({
+  apiRequestForm: (registry: unknown, args: unknown, schema?: unknown) =>
+    mockApiRequestForm(registry, args, schema),
+}))
+
+const mockFail = vi.fn((message: string) => {
+  throw new Error(message)
+})
+const mockSpinner = { text: '', succeed: vi.fn(), fail: vi.fn() }
+vi.mock('../ui.js', () => ({
+  createSpinner: vi.fn(() => mockSpinner),
+  fail: (message: string) => mockFail(message),
+  formatError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+}))
+
+const { cmdPublish } = await import('./publish')
+
+async function makeTmpWorkdir() {
+  const root = await mkdtemp(join(tmpdir(), 'pilothub-publish-'))
+  return root
+}
+
+function makeOpts(workdir: string): GlobalOpts {
+  return {
+    workdir,
+    dir: join(workdir, 'skills'),
+    site: 'https://pilothub.com',
+    registry: 'https://pilothub.com',
+    registrySource: 'default',
+  }
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.clearAllMocks()
+})
+
+describe('cmdPublish', () => {
+  it('publishes SKILL.md from disk (mocked HTTP)', async () => {
+    const workdir = await makeTmpWorkdir()
+    try {
+      const folder = join(workdir, 'my-skill')
+      await mkdir(folder, { recursive: true })
+      const skillContent = '# Skill\n\nHello\n'
+      const notesContent = 'notes\n'
+      await writeFile(join(folder, 'SKILL.md'), skillContent, 'utf8')
+      await writeFile(join(folder, 'notes.md'), notesContent, 'utf8')
+
+      mockApiRequestForm.mockResolvedValueOnce({ ok: true, skillId: 'skill_1', versionId: 'ver_1' })
+
+      await cmdPublish(makeOpts(workdir), 'my-skill', {
+        slug: 'my-skill',
+        name: 'My Skill',
+        version: '1.0.0',
+        changelog: '',
+        tags: 'latest',
+      })
+
+      const publishCall = mockApiRequestForm.mock.calls.find((call) => {
+        const req = call[1] as { path?: string } | undefined
+        return req?.path === '/api/v1/skills'
+      })
+      if (!publishCall) throw new Error('Missing publish call')
+      const publishForm = (publishCall[1] as { form?: FormData }).form as FormData
+      const payloadEntry = publishForm.get('payload')
+      if (typeof payloadEntry !== 'string') throw new Error('Missing publish payload')
+      const payload = JSON.parse(payloadEntry)
+      expect(payload.slug).toBe('my-skill')
+      expect(payload.displayName).toBe('My Skill')
+      expect(payload.version).toBe('1.0.0')
+      expect(payload.changelog).toBe('')
+      expect(payload.tags).toEqual(['latest'])
+      const files = publishForm.getAll('files') as Array<Blob & { name?: string }>
+      expect(files.map((file) => String(file.name ?? '')).sort()).toEqual(['SKILL.md', 'notes.md'])
+    } finally {
+      await rm(workdir, { recursive: true, force: true })
+    }
+  })
+
+  it('allows empty changelog when updating an existing skill', async () => {
+    const workdir = await makeTmpWorkdir()
+    try {
+      const folder = join(workdir, 'existing-skill')
+      await mkdir(folder, { recursive: true })
+      await writeFile(join(folder, 'SKILL.md'), '# Skill\n', 'utf8')
+
+      mockApiRequestForm.mockResolvedValueOnce({ ok: true, skillId: 'skill_1', versionId: 'ver_2' })
+
+      await cmdPublish(makeOpts(workdir), 'existing-skill', {
+        version: '1.0.1',
+        changelog: '',
+        tags: 'latest',
+      })
+
+      expect(mockApiRequestForm).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ path: '/api/v1/skills', method: 'POST' }),
+        expect.anything(),
+      )
+    } finally {
+      await rm(workdir, { recursive: true, force: true })
+    }
+  })
+})

package/packages/pilothub/src/cli/commands/publish.ts

@@ -0,0 +1,108 @@
+import { stat } from 'node:fs/promises'
+import { basename, resolve } from 'node:path'
+import semver from 'semver'
+import { readGlobalConfig } from '../../config.js'
+import { apiRequestForm } from '../../http.js'
+import { ApiRoutes, ApiV1PublishResponseSchema } from '../../schema/index.js'
+import { listTextFiles } from '../../skills.js'
+import { getRegistry } from '../registry.js'
+import { sanitizeSlug, titleCase } from '../slug.js'
+import type { GlobalOpts } from '../types.js'
+import { createSpinner, fail, formatError } from '../ui.js'
+
+export async function cmdPublish(
+  opts: GlobalOpts,
+  folderArg: string,
+  options: {
+    slug?: string
+    name?: string
+    version?: string
+    changelog?: string
+    tags?: string
+    forkOf?: string
+  },
+) {
+  const folder = folderArg ? resolve(opts.workdir, folderArg) : null
+  if (!folder) fail('Path required')
+  const folderStat = await stat(folder).catch(() => null)
+  if (!folderStat || !folderStat.isDirectory()) fail('Path must be a folder')
+
+  const cfg = await readGlobalConfig()
+  const token = cfg?.token
+  if (!token) fail('Not logged in. Run: pilothub login')
+  const registry = await getRegistry(opts, { cache: true })
+
+  const slug = options.slug ?? sanitizeSlug(basename(folder))
+  const displayName = options.name ?? titleCase(basename(folder))
+  const version = options.version
+  const changelog = options.changelog ?? ''
+  const tagsValue = options.tags ?? 'latest'
+  const tags = tagsValue
+    .split(',')
+    .map((tag) => tag.trim())
+    .filter(Boolean)
+
+  const forkOfRaw = options.forkOf?.trim()
+  const forkOf = forkOfRaw ? parseForkOf(forkOfRaw) : undefined
+
+  if (!slug) fail('--slug required')
+  if (!displayName) fail('--name required')
+  if (!version || !semver.valid(version)) fail('--version must be valid semver')
+
+  const spinner = createSpinner(`Preparing ${slug}@${version}`)
+  try {
+    const filesOnDisk = await listTextFiles(folder)
+    if (filesOnDisk.length === 0) fail('No files found')
+    if (
+      !filesOnDisk.some((file) => {
+        const lower = file.relPath.toLowerCase()
+        return lower === 'skill.md' || lower === 'skills.md'
+      })
+    ) {
+      fail('SKILL.md required')
+    }
+
+    const form = new FormData()
+    form.set(
+      'payload',
+      JSON.stringify({
+        slug,
+        displayName,
+        version,
+        changelog,
+        tags,
+        ...(forkOf ? { forkOf } : {}),
+      }),
+    )
+
+    let index = 0
+    for (const file of filesOnDisk) {
+      index += 1
+      spinner.text = `Uploading ${file.relPath} (${index}/${filesOnDisk.length})`
+      const blob = new Blob([Buffer.from(file.bytes)], { type: file.contentType ?? 'text/plain' })
+      form.append('files', blob, file.relPath)
+    }
+
+    spinner.text = `Publishing ${slug}@${version}`
+    const result = await apiRequestForm(
+      registry,
+      { method: 'POST', path: ApiRoutes.skills, token, form },
+      ApiV1PublishResponseSchema,
+    )
+
+    spinner.succeed(`OK. Published ${slug}@${version} (${result.versionId})`)
+  } catch (error) {
+    spinner.fail(formatError(error))
+    throw error
+  }
+}
+
+function parseForkOf(value: string) {
+  const trimmed = value.trim()
+  const [slugRaw, versionRaw] = trimmed.split('@')
+  const slug = (slugRaw ?? '').trim().toLowerCase()
+  if (!slug) fail('--fork-of must be <slug> or <slug@version>')
+  const version = (versionRaw ?? '').trim()
+  if (version && !semver.valid(version)) fail('--fork-of version must be valid semver')
+  return { slug, version: version || undefined }
+}

package/packages/pilothub/src/cli/commands/skills.test.ts

@@ -0,0 +1,191 @@
+/* @vitest-environment node */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { ApiRoutes } from '../../schema/index.js'
+import type { GlobalOpts } from '../types.js'
+
+const mockApiRequest = vi.fn()
+const mockDownloadZip = vi.fn()
+vi.mock('../../http.js', () => ({
+  apiRequest: (...args: unknown[]) => mockApiRequest(...args),
+  downloadZip: (...args: unknown[]) => mockDownloadZip(...args),
+}))
+
+const mockGetRegistry = vi.fn(async () => 'https://pilothub.com')
+vi.mock('../registry.js', () => ({
+  getRegistry: () => mockGetRegistry(),
+}))
+
+const mockSpinner = {
+  stop: vi.fn(),
+  fail: vi.fn(),
+  start: vi.fn(),
+  succeed: vi.fn(),
+  isSpinning: false,
+  text: '',
+}
+vi.mock('../ui.js', () => ({
+  createSpinner: vi.fn(() => mockSpinner),
+  fail: (message: string) => {
+    throw new Error(message)
+  },
+  formatError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+  isInteractive: () => false,
+  promptConfirm: vi.fn(async () => false),
+}))
+
+vi.mock('../../skills.js', () => ({
+  extractZipToDir: vi.fn(),
+  hashSkillFiles: vi.fn(),
+  listTextFiles: vi.fn(),
+  readLockfile: vi.fn(),
+  readSkillOrigin: vi.fn(),
+  writeLockfile: vi.fn(),
+  writeSkillOrigin: vi.fn(),
+}))
+
+vi.mock('node:fs/promises', () => ({
+  mkdir: vi.fn(),
+  rm: vi.fn(),
+  stat: vi.fn(),
+}))
+
+const { clampLimit, cmdExplore, cmdUpdate, formatExploreLine } = await import('./skills.js')
+const {
+  extractZipToDir,
+  hashSkillFiles,
+  listTextFiles,
+  readLockfile,
+  readSkillOrigin,
+  writeLockfile,
+  writeSkillOrigin,
+} = await import('../../skills.js')
+const { rm, stat } = await import('node:fs/promises')
+
+const mockLog = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+function makeOpts(): GlobalOpts {
+  return {
+    workdir: '/work',
+    dir: '/work/skills',
+    site: 'https://pilothub.com',
+    registry: 'https://pilothub.com',
+    registrySource: 'default',
+  }
+}
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('explore helpers', () => {
+  it('clamps explore limits and handles non-finite values', () => {
+    expect(clampLimit(-5)).toBe(1)
+    expect(clampLimit(0)).toBe(1)
+    expect(clampLimit(1)).toBe(1)
+    expect(clampLimit(50)).toBe(50)
+    expect(clampLimit(99)).toBe(99)
+    expect(clampLimit(200)).toBe(200)
+    expect(clampLimit(250)).toBe(200)
+    expect(clampLimit(Number.NaN)).toBe(25)
+    expect(clampLimit(Number.POSITIVE_INFINITY)).toBe(25)
+    expect(clampLimit(Number.NaN, 10)).toBe(10)
+  })
+
+  it('formats explore lines with relative time and truncation', () => {
+    const now = 4 * 60 * 60 * 1000
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(now)
+    const summary = 'a'.repeat(60)
+    const line = formatExploreLine({
+      slug: 'weather',
+      summary,
+      updatedAt: now - 2 * 60 * 60 * 1000,
+      latestVersion: null,
+    })
+    expect(line).toBe(`weather  v?  2h ago  ${'a'.repeat(49)}…`)
+    nowSpy.mockRestore()
+  })
+})
+
+describe('cmdExplore', () => {
+  it('clamps limit and handles empty results', async () => {
+    mockApiRequest.mockResolvedValue({ items: [] })
+
+    await cmdExplore(makeOpts(), { limit: 0 })
+
+    const [, args] = mockApiRequest.mock.calls[0] ?? []
+    const url = new URL(String(args?.url))
+    expect(url.searchParams.get('limit')).toBe('1')
+    expect(mockLog).toHaveBeenCalledWith('No skills found.')
+  })
+
+  it('prints formatted results', async () => {
+    const now = 10 * 60 * 1000
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(now)
+    const item = {
+      slug: 'gog',
+      summary: 'Google Workspace CLI for Gmail, Calendar, Drive and more.',
+      updatedAt: now - 90 * 1000,
+      latestVersion: { version: '1.2.3' },
+    }
+    mockApiRequest.mockResolvedValue({ items: [item] })
+
+    await cmdExplore(makeOpts(), { limit: 250 })
+
+    const [, args] = mockApiRequest.mock.calls[0] ?? []
+    const url = new URL(String(args?.url))
+    expect(url.searchParams.get('limit')).toBe('200')
+    expect(mockLog).toHaveBeenCalledWith(formatExploreLine(item))
+    nowSpy.mockRestore()
+  })
+
+  it('supports sort and json output', async () => {
+    const payload = { items: [], nextCursor: null }
+    mockApiRequest.mockResolvedValue(payload)
+
+    await cmdExplore(makeOpts(), { limit: 10, sort: 'installs', json: true })
+
+    const [, args] = mockApiRequest.mock.calls[0] ?? []
+    const url = new URL(String(args?.url))
+    expect(url.searchParams.get('limit')).toBe('10')
+    expect(url.searchParams.get('sort')).toBe('installsCurrent')
+    expect(mockLog).toHaveBeenCalledWith(JSON.stringify(payload, null, 2))
+  })
+
+  it('supports all-time installs and trending sorts', async () => {
+    mockApiRequest.mockResolvedValue({ items: [], nextCursor: null })
+
+    await cmdExplore(makeOpts(), { limit: 5, sort: 'installsAllTime' })
+    await cmdExplore(makeOpts(), { limit: 5, sort: 'trending' })
+
+    const first = new URL(String(mockApiRequest.mock.calls[0]?.[1]?.url))
+    const second = new URL(String(mockApiRequest.mock.calls[1]?.[1]?.url))
+    expect(first.searchParams.get('sort')).toBe('installsAllTime')
+    expect(second.searchParams.get('sort')).toBe('trending')
+  })
+})
+
+describe('cmdUpdate', () => {
+  it('uses path-based skill lookup when no local fingerprint is available', async () => {
+    mockApiRequest.mockResolvedValue({ latestVersion: { version: '1.0.0' } })
+    mockDownloadZip.mockResolvedValue(new Uint8Array([1, 2, 3]))
+    vi.mocked(readLockfile).mockResolvedValue({
+      version: 1,
+      skills: { demo: { version: '0.1.0', installedAt: 123 } },
+    })
+    vi.mocked(writeLockfile).mockResolvedValue()
+    vi.mocked(readSkillOrigin).mockResolvedValue(null)
+    vi.mocked(writeSkillOrigin).mockResolvedValue()
+    vi.mocked(extractZipToDir).mockResolvedValue()
+    vi.mocked(listTextFiles).mockResolvedValue([])
+    vi.mocked(hashSkillFiles).mockReturnValue({ fingerprint: 'hash', files: [] })
+    vi.mocked(stat).mockRejectedValue(new Error('missing'))
+    vi.mocked(rm).mockResolvedValue()
+
+    await cmdUpdate(makeOpts(), 'demo', {}, false)
+
+    const [, args] = mockApiRequest.mock.calls[0] ?? []
+    expect(args?.path).toBe(`${ApiRoutes.skills}/${encodeURIComponent('demo')}`)
+    expect(args?.url).toBeUndefined()
+  })
+})