pilothub 0.0.1

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

@@ -0,0 +1,66 @@
+const RAW_TEXT_FILE_EXTENSIONS = [
+  'md',
+  'mdx',
+  'txt',
+  'json',
+  'json5',
+  'yaml',
+  'yml',
+  'toml',
+  'js',
+  'cjs',
+  'mjs',
+  'ts',
+  'tsx',
+  'jsx',
+  'py',
+  'sh',
+  'rb',
+  'go',
+  'rs',
+  'swift',
+  'kt',
+  'java',
+  'cs',
+  'cpp',
+  'c',
+  'h',
+  'hpp',
+  'sql',
+  'csv',
+  'ini',
+  'cfg',
+  'env',
+  'xml',
+  'html',
+  'css',
+  'scss',
+  'sass',
+  'svg',
+] as const
+
+export const TEXT_FILE_EXTENSIONS = RAW_TEXT_FILE_EXTENSIONS
+export const TEXT_FILE_EXTENSION_SET = new Set<string>(TEXT_FILE_EXTENSIONS)
+
+const RAW_TEXT_CONTENT_TYPES = [
+  'application/json',
+  'application/xml',
+  'application/yaml',
+  'application/x-yaml',
+  'application/toml',
+  'application/javascript',
+  'application/typescript',
+  'application/markdown',
+  'image/svg+xml',
+] as const
+
+export const TEXT_CONTENT_TYPES = RAW_TEXT_CONTENT_TYPES
+export const TEXT_CONTENT_TYPE_SET = new Set<string>(TEXT_CONTENT_TYPES)
+
+export function isTextContentType(contentType: string) {
+  if (!contentType) return false
+  const normalized = contentType.split(';', 1)[0]?.trim().toLowerCase() ?? ''
+  if (!normalized) return false
+  if (normalized.startsWith('text/')) return true
+  return TEXT_CONTENT_TYPE_SET.has(normalized)
+}

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

@@ -0,0 +1,191 @@
+/* @vitest-environment node */
+import { mkdir, mkdtemp, readFile, stat, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { strToU8, zipSync } from 'fflate'
+import { describe, expect, it } from 'vitest'
+import type { SkillOrigin } from './skills'
+import {
+  buildSkillFingerprint,
+  extractZipToDir,
+  hashSkillFiles,
+  hashSkillZip,
+  listTextFiles,
+  readLockfile,
+  readSkillOrigin,
+  sha256Hex,
+  writeLockfile,
+  writeSkillOrigin,
+} from './skills'
+
+describe('skills', () => {
+  it('extracts zip into directory and skips traversal', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'pilothub-'))
+    const zip = zipSync({
+      'SKILL.md': strToU8('hello'),
+      '../evil.txt': strToU8('nope'),
+    })
+    await extractZipToDir(new Uint8Array(zip), dir)
+
+    expect((await readFile(join(dir, 'SKILL.md'), 'utf8')).trim()).toBe('hello')
+    await expect(stat(join(dir, '..', 'evil.txt'))).rejects.toBeTruthy()
+  })
+
+  it('writes and reads lockfile', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-work-'))
+    await writeLockfile(workdir, {
+      version: 1,
+      skills: { demo: { version: '1.0.0', installedAt: 1 } },
+    })
+    const read = await readLockfile(workdir)
+    expect(read.skills.demo?.version).toBe('1.0.0')
+  })
+
+  it('returns empty lockfile on invalid json', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-work-bad-'))
+    await mkdir(join(workdir, '.pilothub'), { recursive: true })
+    await writeFile(join(workdir, '.pilothub', 'lock.json'), '{', 'utf8')
+    const read = await readLockfile(workdir)
+    expect(read).toEqual({ version: 1, skills: {} })
+  })
+
+  it('returns empty lockfile on schema mismatch', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-work-schema-'))
+    await mkdir(join(workdir, '.pilothub'), { recursive: true })
+    await writeFile(
+      join(workdir, '.pilothub', 'lock.json'),
+      JSON.stringify({ version: 1, skills: 'nope' }),
+      'utf8',
+    )
+    const read = await readLockfile(workdir)
+    expect(read).toEqual({ version: 1, skills: {} })
+  })
+
+  it('skips dotfiles and node_modules when listing text files', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-files-'))
+    await writeFile(join(workdir, 'SKILL.md'), 'hi', 'utf8')
+    await writeFile(join(workdir, '.secret.txt'), 'no', 'utf8')
+    await mkdir(join(workdir, 'node_modules'), { recursive: true })
+    await writeFile(join(workdir, 'node_modules', 'a.txt'), 'no', 'utf8')
+    const files = await listTextFiles(workdir)
+    expect(files.map((file) => file.relPath)).toEqual(['SKILL.md'])
+  })
+
+  it('respects .gitignore and .pilothubignore', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-ignore-'))
+    await writeFile(join(workdir, '.gitignore'), 'ignored.md\n', 'utf8')
+    await writeFile(join(workdir, '.pilothubignore'), 'private.md\n', 'utf8')
+    await writeFile(join(workdir, 'SKILL.md'), 'hi', 'utf8')
+    await writeFile(join(workdir, 'ignored.md'), 'no', 'utf8')
+    await writeFile(join(workdir, 'private.md'), 'no', 'utf8')
+    await writeFile(join(workdir, 'public.json'), '{}', 'utf8')
+
+    const files = await listTextFiles(workdir)
+    const paths = files.map((file) => file.relPath).sort()
+    expect(paths).toEqual(['SKILL.md', 'public.json'])
+    expect(files.find((file) => file.relPath === 'SKILL.md')?.contentType).toMatch(/^text\//)
+    expect(files.find((file) => file.relPath === 'public.json')?.contentType).toBe(
+      'application/json',
+    )
+  })
+
+  it('falls back to text/plain for unknown text extensions', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-env-'))
+    await writeFile(join(workdir, 'SKILL.md'), 'hi', 'utf8')
+    await writeFile(join(workdir, 'config.env'), 'TOKEN=demo', 'utf8')
+    const files = await listTextFiles(workdir)
+    expect(files.find((file) => file.relPath === 'config.env')?.contentType).toBe('text/plain')
+  })
+
+  it('hashes skill files deterministically', async () => {
+    const { fingerprint } = hashSkillFiles([
+      { relPath: 'b.txt', bytes: strToU8('b') },
+      { relPath: 'a.txt', bytes: strToU8('a') },
+    ])
+    const expected = buildSkillFingerprint([
+      { path: 'a.txt', sha256: sha256Hex(strToU8('a')) },
+      { path: 'b.txt', sha256: sha256Hex(strToU8('b')) },
+    ])
+    expect(fingerprint).toBe(expected)
+  })
+
+  it('hashes text files inside a downloaded zip deterministically', () => {
+    const zip = zipSync({
+      'SKILL.md': strToU8('hello'),
+      'notes.md': strToU8('world'),
+      'image.png': strToU8('nope'),
+    })
+    const { fingerprint } = hashSkillZip(new Uint8Array(zip))
+    const expected = buildSkillFingerprint([
+      { path: 'SKILL.md', sha256: sha256Hex(strToU8('hello')) },
+      { path: 'notes.md', sha256: sha256Hex(strToU8('world')) },
+    ])
+    expect(fingerprint).toBe(expected)
+  })
+
+  it('ignores unsafe or non-text entries when hashing zips', () => {
+    const zip = zipSync({
+      'SKILL.md': strToU8('hello'),
+      'folder/': strToU8(''),
+      '../evil.txt': strToU8('nope'),
+      'bad\\path.txt': strToU8('nope'),
+      'image.png': strToU8('nope'),
+    })
+    const { files } = hashSkillZip(new Uint8Array(zip))
+    expect(files).toEqual([{ path: 'SKILL.md', sha256: sha256Hex(strToU8('hello')), size: 5 }])
+  })
+
+  it('builds fingerprints from valid entries only', () => {
+    const fingerprint = buildSkillFingerprint([
+      { path: '', sha256: '' },
+      { path: 'valid.txt', sha256: sha256Hex(strToU8('ok')) },
+    ])
+    const expected = buildSkillFingerprint([
+      { path: 'valid.txt', sha256: sha256Hex(strToU8('ok')) },
+    ])
+    expect(fingerprint).toBe(expected)
+  })
+
+  it('returns null for invalid skill origin metadata', async () => {
+    const workdir = await mkdtemp(join(tmpdir(), 'pilothub-origin-'))
+    expect(await readSkillOrigin(workdir)).toBeNull()
+
+    await mkdir(join(workdir, '.pilothub'), { recursive: true })
+    await writeFile(
+      join(workdir, '.pilothub', 'origin.json'),
+      JSON.stringify({ version: 2 }),
+      'utf8',
+    )
+    expect(await readSkillOrigin(workdir)).toBeNull()
+
+    await writeFile(
+      join(workdir, '.pilothub', 'origin.json'),
+      JSON.stringify({ version: 1, registry: 'demo', slug: 'x', installedAt: 1 }),
+      'utf8',
+    )
+    expect(await readSkillOrigin(workdir)).toBeNull()
+
+    await writeFile(
+      join(workdir, '.pilothub', 'origin.json'),
+      JSON.stringify({
+        version: 1,
+        registry: 'demo',
+        slug: 'x',
+        installedVersion: '0.1.0',
+        installedAt: 'nope',
+      }),
+      'utf8',
+    )
+    expect(await readSkillOrigin(workdir)).toBeNull()
+
+    const origin: SkillOrigin = {
+      version: 1,
+      registry: 'https://example.com',
+      slug: 'demo',
+      installedVersion: '1.2.3',
+      installedAt: 123,
+    }
+    await writeSkillOrigin(workdir, origin)
+    expect(await readSkillOrigin(workdir)).toEqual(origin)
+  })
+})

package/packages/pilothub/src/skills.ts

@@ -0,0 +1,172 @@
+import { createHash } from 'node:crypto'
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, join, relative, resolve, sep } from 'node:path'
+import { unzipSync } from 'fflate'
+import ignore from 'ignore'
+import mime from 'mime'
+import { type Lockfile, LockfileSchema, parseArk, TEXT_FILE_EXTENSION_SET } from './schema/index.js'
+
+export type SkillOrigin = {
+  version: 1
+  registry: string
+  slug: string
+  installedVersion: string
+  installedAt: number
+}
+
+export async function extractZipToDir(zipBytes: Uint8Array, targetDir: string) {
+  const entries = unzipSync(zipBytes)
+  await mkdir(targetDir, { recursive: true })
+  for (const [rawPath, data] of Object.entries(entries)) {
+    const safePath = sanitizeRelPath(rawPath)
+    if (!safePath) continue
+    const outPath = join(targetDir, safePath)
+    await mkdir(dirname(outPath), { recursive: true })
+    await writeFile(outPath, data)
+  }
+}
+
+export async function listTextFiles(root: string) {
+  const files: Array<{ relPath: string; bytes: Uint8Array; contentType?: string }> = []
+  const absRoot = resolve(root)
+  const ig = ignore()
+  ig.add(['.git/', 'node_modules/', '.pilothub/'])
+  await addIgnoreFile(ig, join(absRoot, '.gitignore'))
+  await addIgnoreFile(ig, join(absRoot, '.pilothubignore'))
+
+  await walk(absRoot, async (absPath) => {
+    const relPath = normalizePath(relative(absRoot, absPath))
+    if (!relPath) return
+    if (ig.ignores(relPath)) return
+    const ext = relPath.split('.').at(-1)?.toLowerCase() ?? ''
+    if (!ext || !TEXT_FILE_EXTENSION_SET.has(ext)) return
+    const buffer = await readFile(absPath)
+    const contentType = mime.getType(relPath) ?? 'text/plain'
+    files.push({ relPath, bytes: new Uint8Array(buffer), contentType })
+  })
+  return files
+}
+
+export type SkillFileHash = { path: string; sha256: string; size: number }
+
+export function sha256Hex(bytes: Uint8Array) {
+  return createHash('sha256').update(bytes).digest('hex')
+}
+
+export function buildSkillFingerprint(files: Array<{ path: string; sha256: string }>) {
+  const normalized = files
+    .filter((file) => Boolean(file.path) && Boolean(file.sha256))
+    .map((file) => ({ path: file.path, sha256: file.sha256 }))
+    .sort((a, b) => a.path.localeCompare(b.path))
+  const payload = normalized.map((file) => `${file.path}:${file.sha256}`).join('\n')
+  return createHash('sha256').update(payload).digest('hex')
+}
+
+export function hashSkillFiles(files: Array<{ relPath: string; bytes: Uint8Array }>) {
+  const hashed = files.map((file) => ({
+    path: file.relPath,
+    sha256: sha256Hex(file.bytes),
+    size: file.bytes.byteLength,
+  }))
+  return { files: hashed, fingerprint: buildSkillFingerprint(hashed) }
+}
+
+export function hashSkillZip(zipBytes: Uint8Array) {
+  const entries = unzipSync(zipBytes)
+  const hashed = Object.entries(entries)
+    .map(([rawPath, bytes]) => {
+      const safePath = sanitizeZipPath(rawPath)
+      if (!safePath) return null
+      const ext = safePath.split('.').at(-1)?.toLowerCase() ?? ''
+      if (!ext || !TEXT_FILE_EXTENSION_SET.has(ext)) return null
+      return { path: safePath, sha256: sha256Hex(bytes), size: bytes.byteLength }
+    })
+    .filter(Boolean) as SkillFileHash[]
+
+  return { files: hashed, fingerprint: buildSkillFingerprint(hashed) }
+}
+
+export async function readLockfile(workdir: string): Promise<Lockfile> {
+  const path = join(workdir, '.pilothub', 'lock.json')
+  try {
+    const raw = await readFile(path, 'utf8')
+    const parsed = JSON.parse(raw) as unknown
+    return parseArk(LockfileSchema, parsed, 'Lockfile')
+  } catch {
+    return { version: 1, skills: {} }
+  }
+}
+
+export async function writeLockfile(workdir: string, lock: Lockfile) {
+  const path = join(workdir, '.pilothub', 'lock.json')
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, `${JSON.stringify(lock, null, 2)}\n`, 'utf8')
+}
+
+export async function readSkillOrigin(skillFolder: string): Promise<SkillOrigin | null> {
+  const path = join(skillFolder, '.pilothub', 'origin.json')
+  try {
+    const raw = await readFile(path, 'utf8')
+    const parsed = JSON.parse(raw) as Partial<SkillOrigin>
+    if (parsed.version !== 1) return null
+    if (!parsed.registry || !parsed.slug || !parsed.installedVersion) return null
+    if (typeof parsed.installedAt !== 'number' || !Number.isFinite(parsed.installedAt)) return null
+    return {
+      version: 1,
+      registry: String(parsed.registry),
+      slug: String(parsed.slug),
+      installedVersion: String(parsed.installedVersion),
+      installedAt: parsed.installedAt,
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function writeSkillOrigin(skillFolder: string, origin: SkillOrigin) {
+  const path = join(skillFolder, '.pilothub', 'origin.json')
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, `${JSON.stringify(origin, null, 2)}\n`, 'utf8')
+}
+
+function normalizePath(path: string) {
+  return path
+    .split(sep)
+    .join('/')
+    .replace(/^\.\/+/, '')
+}
+
+function sanitizeRelPath(path: string) {
+  const normalized = path.replace(/^\.\/+/, '').replace(/^\/+/, '')
+  if (!normalized || normalized.endsWith('/')) return null
+  if (normalized.includes('..') || normalized.includes('\\')) return null
+  return normalized
+}
+
+function sanitizeZipPath(path: string) {
+  return sanitizeRelPath(path)
+}
+
+async function walk(dir: string, onFile: (path: string) => Promise<void>) {
+  const entries = await readdir(dir, { withFileTypes: true })
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue
+    if (entry.name === 'node_modules') continue
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      await walk(full, onFile)
+      continue
+    }
+    if (!entry.isFile()) continue
+    await onFile(full)
+  }
+}
+
+async function addIgnoreFile(ig: ReturnType<typeof ignore>, path: string) {
+  try {
+    const raw = await readFile(path, 'utf8')
+    ig.add(raw.split(/\r?\n/))
+  } catch {
+    // optional
+  }
+}

package/packages/pilothub/src/types.ts

@@ -0,0 +1,10 @@
+export type Lockfile = {
+  version: 1
+  skills: Record<
+    string,
+    {
+      version: string | null
+      installedAt: number
+    }
+  >
+}

package/packages/pilothub/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/packages/schema/README.md

@@ -0,0 +1,3 @@
+# pilothub-schema
+
+Shared runtime schemas (ArkType) for PilotHub.

package/packages/schema/dist/ark.d.ts

@@ -0,0 +1,4 @@
+import { ArkErrors } from 'arktype';
+export type ArkValidator<T> = (data: unknown) => T | ArkErrors;
+export declare function parseArk<T>(schema: ArkValidator<T>, data: unknown, label: string): T;
+export declare function formatArkErrors(errors: ArkErrors): string;

package/packages/schema/dist/ark.js

@@ -0,0 +1,26 @@
+import { ArkErrors } from 'arktype';
+export function parseArk(schema, data, label) {
+    const result = schema(data);
+    if (result instanceof ArkErrors) {
+        throw new Error(`${label}: ${formatArkErrors(result)}`);
+    }
+    return result;
+}
+export function formatArkErrors(errors) {
+    const parts = [];
+    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.description === 'string'
+            ? error.description
+            : 'invalid value';
+        parts.push(`${location}${description}`);
+    }
+    if (errors.count > parts.length) {
+        parts.push(`+${errors.count - parts.length} more`);
+    }
+    return parts.join('; ');
+}
+//# sourceMappingURL=ark.js.map

package/packages/schema/dist/ark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ark.js","sourceRoot":"","sources":["../src/ark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAInC,MAAM,UAAU,QAAQ,CAAI,MAAuB,EAAE,IAAa,EAAE,KAAa;IAC/E,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3B,IAAI,MAAM,YAAY,SAAS,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,KAAK,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IACzD,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,MAAiB;IAC/C,MAAM,KAAK,GAAa,EAAE,CAAA;IAC1B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;YAAE,MAAK;QAC5B,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAClE,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;QACxC,MAAM,WAAW,GACf,OAAQ,KAAmC,CAAC,WAAW,KAAK,QAAQ;YAClE,CAAC,CAAG,KAAiC,CAAC,WAAsB;YAC5D,CAAC,CAAC,eAAe,CAAA;QACrB,KAAK,CAAC,IAAI,CAAC,GAAG,QAAQ,GAAG,WAAW,EAAE,CAAC,CAAA;IACzC,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAChC,KAAK,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,OAAO,CAAC,CAAA;IACpD,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACzB,CAAC"}

package/packages/schema/dist/index.d.ts

@@ -0,0 +1,5 @@
+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/schema/dist/index.js

@@ -0,0 +1,5 @@
+export { formatArkErrors, parseArk } from './ark.js';
+export { ApiRoutes, LegacyApiRoutes } from './routes.js';
+export * from './schemas.js';
+export * from './textFiles.js';
+//# sourceMappingURL=index.js.map

package/packages/schema/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AACxD,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA"}

package/packages/schema/dist/routes.d.ts

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

package/packages/schema/dist/routes.js

@@ -0,0 +1,22 @@
+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',
+};
+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',
+};
+//# sourceMappingURL=routes.js.map

package/packages/schema/dist/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,QAAQ,EAAE,eAAe;IACzB,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE,YAAY;IACnB,YAAY,EAAE,oBAAoB;IAClC,SAAS,EAAE,iBAAiB;IAC5B,YAAY,EAAE,qBAAqB;IACnC,UAAU,EAAE,kBAAkB;IAC9B,gBAAgB,EAAE,yBAAyB;IAC3C,cAAc,EAAE,uBAAuB;IACvC,gBAAgB,EAAE,yBAAyB;CACnC,CAAA;AAEV,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,MAAM,EAAE,gBAAgB;IACxB,OAAO,EAAE,iBAAiB;IAC1B,QAAQ,EAAE,kBAAkB;IAC5B,MAAM,EAAE,gBAAgB;IACxB,KAAK,EAAE,eAAe;IACtB,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,gBAAgB;CAChB,CAAA"}