@drawcall/market 0.1.5 → 0.1.6

package/src/commands/upload.ts

@@ -0,0 +1,262 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { zipSync } from 'fflate'
+import ora from 'ora'
+import semver from 'semver'
+import { getCliClient } from '../cli-client.js'
+import { unchangedUploadResult, uploadResult } from '../output.js'
+import { assetNameSchema, semverSchema, type AssetType } from '../schemas.js'
+
+export interface UploadCommandOptions {
+  type?: AssetType
+  version?: string
+  cwd?: string
+  baseUrl?: string
+}
+
+export async function uploadCommand(
+  name: string,
+  fileFilter: string,
+  description: string,
+  opts: UploadCommandOptions,
+): Promise<void> {
+  const spinner = ora({
+    text: 'Preparing upload',
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
+
+  try {
+    const parsedName = assetNameSchema.parse(name)
+    const parsedVersion = opts.version ? semverSchema.parse(opts.version) : undefined
+    const cwd = opts.cwd ?? process.cwd()
+    const file = await resolveOneFile(cwd, fileFilter)
+    const zip = await buildModelZip(file, description)
+    const { client } = await getCliClient({ baseUrl: opts.baseUrl, requireAuth: true })
+    const profile = await client.user.getProfile()
+    if (!profile) {
+      throw new Error('Not logged in. Run `market login` first.')
+    }
+    const existing = await client.asset.exact({
+      name: parsedName,
+      type: opts.type ?? 'model',
+      includeUnapproved: true,
+    })
+
+    if (existing && existing.ownerId !== profile.id) {
+      throw new Error(`Asset "${parsedName}" already exists and is owned by another user`)
+    }
+
+    if (existing) {
+      const latestZip = await client.asset.downloadZip({
+        name: parsedName,
+        version: existing.latestVersion,
+      })
+      const latestBytes = new Uint8Array(await latestZip.arrayBuffer())
+      if (existing.description === description && bytesEqual(latestBytes, zip)) {
+        spinner.stop()
+        console.log(unchangedUploadResult(parsedName, existing.latestVersion))
+        return
+      }
+    }
+
+    const version = parsedVersion ?? nextVersion(existing?.latestVersion)
+    spinner.text = `Uploading ${parsedName}@${version}`
+    const uploaded = await client.asset.uploadZip({
+      name: parsedName,
+      type: opts.type ?? 'model',
+      version,
+      description,
+      npmDependencies: {},
+      assetDependencies: {},
+      tags: [],
+      zip: new File([toArrayBuffer(zip)], `${parsedName}-${version}.zip`, {
+        type: 'application/zip',
+      }),
+    })
+
+    spinner.stop()
+    console.log(uploadResult(parsedName, uploaded.version))
+  } catch (err) {
+    spinner.stop()
+    throw err
+  }
+}
+
+async function buildModelZip(file: string, description: string): Promise<Uint8Array> {
+  const name = path.basename(file)
+  if (!/\.(glb|gltf)$/i.test(name)) {
+    throw new Error('Upload file filter must resolve to a .glb or .gltf file')
+  }
+
+  const files: Record<string, Uint8Array> = {
+    [`public/${name}`]: new Uint8Array(await fs.readFile(file)),
+    'README.md': new TextEncoder().encode(description),
+  }
+
+  if (/\.gltf$/i.test(name)) {
+    for (const dependency of await gltfDependencies(file)) {
+      files[`public/${dependency.publicPath}`] = new Uint8Array(
+        await fs.readFile(dependency.source),
+      )
+    }
+  }
+
+  return zipSync(files, { mtime: new Date('1980-01-01T00:00:00.000Z'), level: 0 })
+}
+
+interface GltfDependency {
+  source: string
+  publicPath: string
+}
+
+async function gltfDependencies(file: string): Promise<GltfDependency[]> {
+  const gltf = JSON.parse(await fs.readFile(file, 'utf-8')) as {
+    buffers?: Array<{ uri?: string }>
+    images?: Array<{ uri?: string }>
+  }
+  const uris = [...(gltf.buffers ?? []), ...(gltf.images ?? [])]
+    .map((entry) => entry.uri)
+    .filter((uri): uri is string => Boolean(uri && !uri.startsWith('data:')))
+  const dependencies = new Map<string, GltfDependency>()
+
+  for (const uri of uris) {
+    const decodedUri = decodeURIComponent(uri)
+    const publicPath = toPublicDependencyPath(decodedUri)
+    dependencies.set(publicPath, {
+      source: await resolveGltfDependency(file, decodedUri),
+      publicPath,
+    })
+  }
+
+  return [...dependencies.values()]
+}
+
+async function resolveGltfDependency(file: string, uri: string): Promise<string> {
+  const dir = path.dirname(file)
+  const direct = path.resolve(dir, uri)
+  if (await isFile(direct)) return direct
+
+  const basename = path.basename(uri)
+  const alternateBasenames = [basename]
+  const withoutBlenderSuffix = basename.replace(/_\d{3}(\.[^.]+)$/u, '$1')
+  if (withoutBlenderSuffix !== basename) {
+    alternateBasenames.push(withoutBlenderSuffix)
+  }
+  let current = dir
+  for (let depth = 0; depth < 8; depth += 1) {
+    for (const candidateBasename of alternateBasenames) {
+      const candidates = [
+        path.join(current, 'Textures', candidateBasename),
+        path.join(current, 'textures', candidateBasename),
+        path.join(current, candidateBasename),
+      ]
+      for (const candidate of candidates) {
+        if (await isFile(candidate)) return candidate
+      }
+    }
+
+    const parent = path.dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+
+  throw new Error(`Could not find glTF dependency "${uri}" for ${path.basename(file)}`)
+}
+
+async function isFile(file: string): Promise<boolean> {
+  return (await maybeStat(file))?.isFile() ?? false
+}
+
+function toPublicDependencyPath(uri: string): string {
+  if (/^[a-z]+:/i.test(uri) || path.isAbsolute(uri)) {
+    throw new Error(`Unsupported external glTF dependency "${uri}"`)
+  }
+
+  const normalized = path
+    .normalize(uri)
+    .split(path.sep)
+    .filter((part) => part.length > 0 && part !== '.')
+    .join('/')
+  if (!normalized || normalized.startsWith('../') || normalized === '..') {
+    throw new Error(`Unsupported glTF dependency path "${uri}"`)
+  }
+  return normalized
+}
+
+async function resolveOneFile(cwd: string, fileFilter: string): Promise<string> {
+  const absolute = path.resolve(cwd, fileFilter)
+  const stat = await maybeStat(absolute)
+  if (stat?.isFile()) return absolute
+
+  const files = await listFiles(cwd)
+  const matches = files
+    .filter((file) => matchesFilter(path.relative(cwd, file), fileFilter))
+    .filter((file) => /\.(glb|gltf)$/i.test(file))
+    .sort()
+
+  if (matches.length === 0) {
+    throw new Error(`No .glb or .gltf files matched "${fileFilter}"`)
+  }
+  if (matches.length > 1) {
+    throw new Error(`File filter matched ${matches.length} models; upload one asset at a time`)
+  }
+
+  return matches[0]
+}
+
+async function maybeStat(file: string) {
+  try {
+    return await fs.stat(file)
+  } catch {
+    return null
+  }
+}
+
+async function listFiles(dir: string): Promise<string[]> {
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+  const files: string[] = []
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...(await listFiles(fullPath)))
+    } else if (entry.isFile()) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+function matchesFilter(file: string, filter: string): boolean {
+  const normalizedFile = file.split(path.sep).join('/')
+  const normalizedFilter = filter.split(path.sep).join('/')
+  const pattern =
+    '^' +
+    escapeRegExp(normalizedFilter)
+      .replace(/\\\*\\\*/g, '.*')
+      .replace(/\\\*/g, '[^/]*') +
+    '$'
+  return new RegExp(pattern).test(normalizedFile)
+}
+
+function nextVersion(latest?: string): string {
+  if (!latest) return '1.0.0'
+  return semver.inc(latest, 'patch') ?? '1.0.0'
+}
+
+function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
+function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  return new Uint8Array(bytes).buffer
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[|\\{}()[\]^$+?.*]/g, '\\$&')
+}

package/src/config.ts

@@ -3,12 +3,16 @@ import * as os from 'os'
 import * as path from 'path'
 import { z } from 'zod'
 
-const configSchema = z.object({
-  apiKey: z.string().startsWith('mk_'),
+const rawConfigSchema = z.object({
+  authToken: z.string().min(1).optional(),
+  apiKey: z.string().min(1).optional(),
   baseUrl: z.string().url().optional(),
 })
 
-export type Config = z.infer<typeof configSchema>
+export interface Config {
+  authToken: string
+  baseUrl?: string
+}
 
 function configDir(): string {
   if (process.platform === 'win32' && process.env.APPDATA) {
@@ -25,8 +29,10 @@ function configPath(): string {
 export async function loadConfig(): Promise<Config | null> {
   try {
     const raw = await fs.readFile(configPath(), 'utf-8')
-    const parsed = configSchema.safeParse(JSON.parse(raw))
-    return parsed.success ? parsed.data : null
+    const parsed = rawConfigSchema.safeParse(JSON.parse(raw))
+    if (!parsed.success) return null
+    const authToken = parsed.data.authToken ?? parsed.data.apiKey
+    return authToken ? { authToken, baseUrl: parsed.data.baseUrl } : null
   } catch {
     return null
   }

package/src/constants.ts

@@ -3,17 +3,9 @@ import type { AssetType } from './schemas.js'
 export const MAX_FILE_SIZE = 100 * 1024 * 1024 // 100MB
 
 export const ALLOWED_EXTENSIONS: Record<AssetType, string[]> = {
-  generic: ['.zip'],
-  model: ['.gltf', '.glb'],
-  hdri: ['.hdr', '.exr'],
-  material: [], // material is submitted as JSON, no file upload
-  music: ['.mp3', '.wav', '.ogg', '.flac'],
+  model: ['.zip'],
 }
 
 export const ASSET_TYPE_LABELS: Record<AssetType, string> = {
-  generic: 'Generic',
-  model: '3D Model',
-  hdri: 'HDRI',
-  material: 'Material',
-  music: 'Audio',
+  model: 'Model',
 }

package/src/contract.ts

@@ -1,38 +1,27 @@
 import { oc } from '@orpc/contract'
 import { z } from 'zod'
 import {
-  assetNameSchema,
-  assetTypeSchema,
-  semverSchema,
+  downloadZipSchema,
+  exactAssetSchema,
+  generateAssetSchema,
   listAssetsSchema,
   updateProfileSchema,
-  uploadGenericSchema,
-  uploadTypedSchema,
-  uploadMaterialSchema,
+  uploadZipSchema,
 } from './schemas.js'
 
-// ─── Output types ─────────────────────────────────────────────────────────────
-// These mirror what the server handlers return (Drizzle query results).
-// We use z.custom<T>() so the contract carries full types for the client
-// without duplicating every DB column as a Zod field.
-
 export interface AssetVersion {
-  id: number
-  assetId: number
+  id: string
+  assetId: string
   version: string
   approved: boolean
   npmDependencies: string
   assetDependencies: string
   sourceKey: string
-  buildOutputKey: string | null
-  thumbnailKey: string | null
-  buildError: string | null
-  readme: string | null
   createdAt: Date
 }
 
 export interface Asset {
-  id: number
+  id: string
   name: string
   type: string
   description: string | null
@@ -41,13 +30,8 @@ export interface Asset {
   updatedAt: Date
 }
 
-export interface AssetWithVersionsAndTags extends Asset {
-  versions: AssetVersion[]
-  tags: string[]
-}
-
-export interface AssetListItem {
-  id: number
+export interface AssetSearchResult {
+  id: string
   name: string
   type: string
   description: string | null
@@ -55,8 +39,9 @@ export interface AssetListItem {
   createdAt: Date
   updatedAt: Date
   latestVersion: string
-  thumbnailKey: string | null
   approved: boolean
+  npmDependencies: string
+  assetDependencies: string
 }
 
 export interface PaginatedList<T> {
@@ -74,95 +59,31 @@ export interface User {
   emailVerified: boolean
   image: string | null
   role: string
+  isAdmin: boolean
   createdAt: Date
   updatedAt: Date
 }
 
-export interface AssetWithVersions extends Asset {
-  versions: AssetVersion[]
-}
-
-export interface UnapprovedItem {
-  versionId: number
-  assetId: number
+export interface GenerateAssetResult {
   assetName: string
-  assetType: string
   version: string
-  buildError: string | null
-  buildOutputKey: string | null
-  thumbnailKey: string | null
-  createdAt: Date
-  ownerName: string
-  ownerEmail: string
-}
-
-export interface TagWithCount {
-  id: number
-  name: string
-  count: number
-}
-
-export interface FileTreeEntry {
-  path: string
-  size: number
-}
-
-export interface GenerateJobStatus {
-  jobId: string
-  state: 'queued' | 'running' | 'done' | 'failed'
-  message: string | null
-  assetName: string | null
-  version: string | null
-  error: string | null
 }
 
-// ─── Contract ─────────────────────────────────────────────────────────────────
-
 export const contract = {
   asset: {
-    getByName: oc
-      .input(z.object({ name: assetNameSchema }))
-      .output(z.custom<AssetWithVersionsAndTags | null>()),
-
-    list: oc.input(listAssetsSchema).output(z.custom<PaginatedList<AssetListItem>>()),
+    search: oc.input(listAssetsSchema).output(z.custom<PaginatedList<AssetSearchResult>>()),
 
-    getVersionTree: oc
-      .input(z.object({ name: z.string(), version: semverSchema }))
-      .output(z.custom<FileTreeEntry[]>()),
+    exact: oc.input(exactAssetSchema).output(z.custom<AssetSearchResult | null>()),
 
-    getRawFile: oc
-      .input(z.object({ name: z.string(), version: semverSchema, path: z.string() }))
-      .output(z.instanceof(Blob)),
-  },
-
-  upload: {
-    generic: oc
-      .input(uploadGenericSchema.extend({ file: z.instanceof(File) }))
+    uploadZip: oc
+      .input(uploadZipSchema.extend({ zip: z.instanceof(File) }))
       .output(z.custom<AssetVersion>()),
 
-    model: oc
-      .input(uploadTypedSchema.extend({ file: z.instanceof(File) }))
-      .output(z.custom<AssetVersion>()),
+    downloadZip: oc.input(downloadZipSchema).output(z.instanceof(Blob)),
 
-    hdri: oc
-      .input(uploadTypedSchema.extend({ file: z.instanceof(File) }))
-      .output(z.custom<AssetVersion>()),
-
-    music: oc
-      .input(uploadTypedSchema.extend({ file: z.instanceof(File) }))
-      .output(z.custom<AssetVersion>()),
+    downloadPreviewImage: oc.input(downloadZipSchema).output(z.instanceof(Blob)),
 
-    material: oc.input(uploadMaterialSchema).output(z.custom<AssetVersion>()),
-  },
-
-  admin: {
-    listUnapproved: oc.output(z.custom<UnapprovedItem[]>()),
-
-    approve: oc
-      .input(z.object({ assetName: z.string(), version: z.string() }))
-      .output(z.object({ success: z.boolean() })),
-
-    backfillEmbeddings: oc.output(z.object({ indexed: z.number() })),
+    generate: oc.input(generateAssetSchema).output(z.custom<GenerateAssetResult>()),
   },
 
   user: {
@@ -170,28 +91,9 @@ export const contract = {
 
     updateProfile: oc.input(updateProfileSchema).output(z.custom<User>()),
 
-    getApiKey: oc.output(z.custom<{ prefix: string; createdAt: Date } | null>()),
-
-    regenerateApiKey: oc.output(z.object({ key: z.string(), prefix: z.string() })),
-
-    myAssets: oc.output(z.custom<AssetWithVersions[]>()),
-  },
-
-  tag: {
-    list: oc.output(z.custom<TagWithCount[]>()),
-  },
+    getAuthToken: oc.output(z.custom<{ prefix: string; createdAt: Date } | null>()),
 
-  generate: {
-    start: oc
-      .input(
-        z.object({
-          description: z.string().min(3).max(1000),
-          type: assetTypeSchema.optional(),
-        }),
-      )
-      .output(z.object({ jobId: z.string() })),
-
-    status: oc.input(z.object({ jobId: z.string() })).output(z.custom<GenerateJobStatus>()),
+    createAuthToken: oc.output(z.object({ token: z.string(), prefix: z.string() })),
   },
 }
 

package/src/generate.ts

@@ -20,8 +20,6 @@ export interface GenerateResult {
 
 export interface GenerateOptions {
   onProgress?: (message: string) => void
-  pollIntervalMs?: number
-  timeoutMs?: number
 }
 
 export async function generateAndWait(
@@ -29,34 +27,12 @@ export async function generateAndWait(
   input: GenerateInput,
   opts: GenerateOptions = {},
 ): Promise<GenerateResult> {
-  const pollIntervalMs = opts.pollIntervalMs ?? 1500
-  const timeoutMs = opts.timeoutMs ?? 60_000
   const report = opts.onProgress ?? (() => {})
 
-  const { jobId } = await client.generate.start(input)
-
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    const status = await client.generate.status({ jobId })
-    if (status.message) report(status.message)
-
-    if (status.state === 'done') {
-      if (!status.assetName || !status.version) {
-        throw new GenerateError('Generation completed without an asset name.')
-      }
-      return { assetName: status.assetName, version: status.version }
-    }
-
-    if (status.state === 'failed') {
-      throw new GenerateError(status.error ?? 'Generation failed.')
-    }
-
-    await sleep(pollIntervalMs)
+  report('Generating asset')
+  const result = await client.asset.generate(input)
+  if (!result.assetName || !result.version) {
+    throw new GenerateError('Generation completed without an asset name.')
   }
-
-  throw new GenerateError(`Generation timed out after ${timeoutMs}ms.`)
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
+  return result
 }

package/src/index.ts

@@ -1,28 +1,36 @@
 // Client
-export { createMarketClient, createInternalClient } from './client.js'
-export type { MarketClient, InternalClient, MarketClientOptions } from './client.js'
+export { createMarketClient } from './client.js'
+export type { MarketClient, MarketClientOptions } from './client.js'
 
 // Contracts
 export { contract } from './contract.js'
 export type { AppContract } from './contract.js'
-export { internalContract } from './internal-contract.js'
-export type { InternalContract } from './internal-contract.js'
 
 // Contract output types
 export type {
   Asset,
   AssetVersion,
-  AssetWithVersionsAndTags,
-  AssetWithVersions,
-  AssetListItem,
+  AssetSearchResult,
   PaginatedList,
   User,
-  UnapprovedItem,
-  TagWithCount,
-  FileTreeEntry,
-  GenerateJobStatus,
+  GenerateAssetResult,
 } from './contract.js'
 
+export type {
+  AssetCatalog,
+  AssetDownloadZipInput,
+  AssetExactInput,
+  AssetGenerateInput,
+  AssetImplementation,
+  AssetImplementationContext,
+  AssetSearchIndex,
+  AssetSearchIndexEntry,
+  AssetSearchInput,
+  AssetUploadZipInput,
+  BlobStore,
+  SaveAssetVersionInput,
+} from './asset-implementation.js'
+
 // Resolve
 export { resolve, ResolutionError } from './resolve.js'
 export type { ResolvedAsset, ResolveResult } from './resolve.js'
@@ -39,9 +47,10 @@ export {
   assetNameSchema,
   npmDependenciesSchema,
   assetDependenciesSchema,
-  uploadGenericSchema,
-  uploadTypedSchema,
-  uploadMaterialSchema,
+  uploadZipSchema,
+  downloadZipSchema,
+  exactAssetSchema,
+  generateAssetSchema,
   updateProfileSchema,
   listAssetsSchema,
 } from './schemas.js'