@drawcall/market 0.1.5 → 0.1.7

package/src/cli.ts

@@ -1,57 +1,69 @@
 #!/usr/bin/env node
 
+import { createRequire } from 'node:module'
 import { Command, Option } from 'commander'
 import chalk from 'chalk'
+import open from 'open'
+import * as oauthClient from 'openid-client'
 import { ASSET_TYPES, type AssetType } from './schemas.js'
 import { installCommand } from './commands/install.js'
 import { searchCommand } from './commands/search.js'
 import { generateCommand } from './commands/generate.js'
-import { login } from './commands/login.js'
+import { previewCommand } from './commands/preview.js'
+import { uploadCommand } from './commands/upload.js'
 import { logout } from './commands/logout.js'
-import { NotLoggedInError } from './cli-client.js'
+import { createMarketClient } from './client.js'
+import { saveConfig, getConfigPath } from './config.js'
+import { errorResult, loginResult } from './output.js'
 
+const packageJson = createRequire(import.meta.url)('../package.json') as { version: string }
 const program = new Command()
 
 const DEFAULT_BASE_URL = 'https://api.market.drawcall.ai'
+const AUTH_ISSUER_URL = 'https://auth.drawcall.ai/api/auth'
+const DEVICE_CLIENT_ID = 'market-cli'
 
-const typeOption = new Option('--type <type>', 'Filter by asset type').choices([...ASSET_TYPES])
-
-const apiOption = new Option('--api <url>', 'API base URL').default(
+const typeOption = new Option('--type <type>', 'Asset type').choices([...ASSET_TYPES])
+const apiOption = new Option('--api <url>', 'API URL').default(
   process.env.MARKET_API_URL,
   'from MARKET_API_URL / config / default',
 )
 
-program.name('market').description('Install assets from the drawcall.ai market').version('0.1.0')
+program.name('market').description('Find and install Drawcall Market assets').version(packageJson.version)
 
 program
   .command('login')
-  .description('Authenticate with the market via your browser')
+  .description('Sign in')
   .addOption(apiOption)
   .action(async (opts: { api?: string }) => {
-    await login({ baseUrl: opts.api ?? DEFAULT_BASE_URL })
+    const baseUrl = opts.api ?? DEFAULT_BASE_URL
+    const token = await runDeviceLogin()
+    const client = createMarketClient({ baseUrl, authToken: token })
+    const profile = await client.user.getProfile()
+    if (!profile) throw new Error('The Market API did not accept the auth token.')
+    await saveConfig({ authToken: token, baseUrl })
+    console.log(loginResult(profile.email, getConfigPath()))
   })
 
 program
   .command('logout')
-  .description('Remove the local API key')
+  .description('Sign out')
   .action(async () => {
     await logout()
   })
 
 program
   .command('install')
-  .description(
-    'Install assets. Each arg is tried as an exact name, then a semantic search, then auto-generated.',
-  )
-  .argument('<assets...>', 'Asset names or natural-language descriptions')
+  .description('Install by name or prompt')
+  .argument('<assets...>', 'Names or prompts')
   .addOption(typeOption)
   .addOption(apiOption)
   .option('--unapproved', 'Include unapproved versions', false)
-  .option('--cwd <dir>', 'Project directory', process.cwd())
+  .option('--cwd <dir>', 'Project directory')
   .action(
     async (
       args: string[],
-      opts: { type?: AssetType; api?: string; unapproved: boolean; cwd: string },
+      opts: { type?: AssetType; api?: string; unapproved: boolean; cwd?: string },
     ) => {
       await installCommand(args, {
         type: opts.type,
@@ -64,22 +76,98 @@ program
 
 program
   .command('search')
-  .description('Search the market. Prints up to 10 ranked results.')
-  .argument('<query>', 'Natural-language query')
+  .description('Find assets')
+  .argument('<query>', 'Search query')
   .addOption(typeOption)
   .addOption(apiOption)
-  .action(async (query: string, opts: { type?: AssetType; api?: string }) => {
-    await searchCommand(query, { type: opts.type, baseUrl: opts.api })
-  })
+  .option('--unapproved', 'Include unapproved versions', false)
+  .option('--limit <n>', 'Max results, 1-5', parseSearchLimit, 5)
+  .option('--verbose', 'Show longer descriptions', false)
+  .action(
+    async (
+      query: string,
+      opts: {
+        type?: AssetType
+        api?: string
+        unapproved: boolean
+        limit: number
+        verbose: boolean
+      },
+    ) => {
+      if (!opts.type) {
+        console.error(
+          errorResult(`Search requires --type. Available types: ${ASSET_TYPES.join(', ')}`),
+        )
+        process.exit(1)
+      }
+      await searchCommand(query, {
+        type: opts.type,
+        baseUrl: opts.api,
+        unapproved: opts.unapproved,
+        limit: opts.limit,
+        verbose: opts.verbose,
+      })
+    },
+  )
+
+program
+  .command('upload')
+  .description('Publish one model')
+  .argument('<name>', 'Asset name')
+  .argument('<file-filter>', '.glb/.gltf path or glob')
+  .argument('<description>', 'Short description')
+  .addOption(typeOption)
+  .addOption(apiOption)
+  .option('--version <version>', 'Explicit semver version')
+  .option('--cwd <dir>', 'Project directory')
+  .action(
+    async (
+      name: string,
+      fileFilter: string,
+      description: string,
+      opts: { type?: AssetType; api?: string; version?: string; cwd?: string },
+    ) => {
+      await uploadCommand(name, fileFilter, description, {
+        type: opts.type,
+        version: opts.version,
+        baseUrl: opts.api,
+        cwd: opts.cwd,
+      })
+    },
+  )
+
+program
+  .command('preview')
+  .description('Save preview image')
+  .argument('<name>', 'Asset name')
+  .argument('[version]', 'Semver version')
+  .addOption(typeOption)
+  .addOption(apiOption)
+  .option('--unapproved', 'Include unapproved versions', false)
+  .option('--out <file>', 'Output PNG path')
+  .action(
+    async (
+      name: string,
+      version: string | undefined,
+      opts: { type?: AssetType; api?: string; unapproved: boolean; out?: string },
+    ) => {
+      await previewCommand(name, version, {
+        type: opts.type,
+        baseUrl: opts.api,
+        unapproved: opts.unapproved,
+        out: opts.out,
+      })
+    },
+  )
 
 program
   .command('generate')
-  .description('Generate a new asset from a description and install it.')
-  .argument('<description>', 'Description of the asset to generate')
+  .description('Generate and install')
+  .argument('<description>', 'Asset prompt')
   .addOption(typeOption)
   .addOption(apiOption)
-  .option('--cwd <dir>', 'Project directory', process.cwd())
-  .action(async (description: string, opts: { type?: AssetType; api?: string; cwd: string }) => {
+  .option('--cwd <dir>', 'Project directory')
+  .action(async (description: string, opts: { type?: AssetType; api?: string; cwd?: string }) => {
     await generateCommand(description, {
       type: opts.type,
       baseUrl: opts.api,
@@ -87,11 +175,40 @@ program
     })
   })
 
+if (process.argv.length <= 2) {
+  program.outputHelp()
+  process.exit(0)
+}
+
 program.parseAsync().catch((err) => {
-  // Commands that own a spinner print the error via spinner.fail() and rethrow,
-  // so we only print here when nothing else did.
-  if (err instanceof NotLoggedInError) {
-    console.error(chalk.red(err.message))
-  }
+  const message = err instanceof Error ? err.message : String(err)
+  console.error(errorResult(message))
   process.exit(1)
 })
+
+function parseSearchLimit(value: string): number {
+  const parsed = Number.parseInt(value, 10)
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error('--limit must be a positive integer')
+  }
+  return Math.min(parsed, 5)
+}
+
+async function runDeviceLogin(): Promise<string> {
+  const config = await oauthClient.discovery(
+    new URL(AUTH_ISSUER_URL),
+    DEVICE_CLIENT_ID,
+    undefined,
+    oauthClient.None(),
+  )
+  const code = await oauthClient.initiateDeviceAuthorization(config, { scope: 'market' })
+  const verificationUri = code.verification_uri_complete ?? code.verification_uri
+
+  console.log(`Open ${chalk.cyan(verificationUri)}`)
+  console.log(`Code: ${chalk.bold(code.user_code)}`)
+  await open(verificationUri).catch(() => undefined)
+
+  const tokens = await oauthClient.pollDeviceAuthorizationGrant(config, code)
+  if (!tokens.access_token) throw new Error('Device login completed without an access token.')
+  return tokens.access_token
+}

package/src/client.ts

@@ -2,39 +2,29 @@ import { createORPCClient } from '@orpc/client'
 import { RPCLink } from '@orpc/client/fetch'
 import type { ContractRouterClient } from '@orpc/contract'
 import type { AppContract } from './contract.js'
-import type { InternalContract } from './internal-contract.js'
 
 export type MarketClient = ContractRouterClient<AppContract>
-export type InternalClient = ContractRouterClient<InternalContract>
 
 const DEFAULT_BASE_URL = 'https://api.market.drawcall.ai'
 
 export interface MarketClientOptions {
   baseUrl?: string
   fetch?: typeof globalThis.fetch
+  authToken?: string
   apiKey?: string
 }
 
-function buildHeaders(apiKey?: string): Record<string, string> | undefined {
-  return apiKey ? { 'x-api-key': apiKey } : undefined
+function buildHeaders(authToken?: string): Record<string, string> | undefined {
+  return authToken ? { authorization: `Bearer ${authToken}` } : undefined
 }
 
 export function createMarketClient(opts: MarketClientOptions = {}): MarketClient {
   const baseUrl = opts.baseUrl || DEFAULT_BASE_URL
+  const authToken = opts.authToken ?? opts.apiKey
   const link = new RPCLink({
     url: new URL('/api/rpc', baseUrl).href,
     fetch: opts.fetch,
-    headers: buildHeaders(opts.apiKey),
+    headers: buildHeaders(authToken),
   })
   return createORPCClient<MarketClient>(link)
 }
-
-export function createInternalClient(opts: MarketClientOptions = {}): InternalClient {
-  const baseUrl = opts.baseUrl || DEFAULT_BASE_URL
-  const link = new RPCLink({
-    url: new URL('/api/internal-rpc', baseUrl).href,
-    fetch: opts.fetch,
-    headers: buildHeaders(opts.apiKey),
-  })
-  return createORPCClient<InternalClient>(link)
-}

package/src/commands/generate.ts

@@ -1,9 +1,9 @@
-import chalk from 'chalk'
 import ora from 'ora'
 import { getCliClient } from '../cli-client.js'
 import { generateAndWait } from '../generate.js'
 import { resolve } from '../resolve.js'
 import { install as runInstall } from '../install.js'
+import { generatedInstallResult } from '../output.js'
 import type { AssetType } from '../schemas.js'
 
 export interface GenerateCommandOptions {
@@ -19,7 +19,11 @@ export async function generateCommand(
 ): Promise<void> {
   const { client } = await getCliClient({ baseUrl: opts.baseUrl, requireAuth: true })
 
-  const spinner = ora(`Generating "${description}"`).start()
+  const spinner = ora({
+    text: `Generating "${description}"`,
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
   try {
     const generated = await generateAndWait(
       client,
@@ -45,11 +49,10 @@ export async function generateCommand(
       },
     })
 
-    spinner.succeed(
-      `Installed ${chalk.cyan(generated.assetName)}${chalk.dim('@' + generated.version)}`,
-    )
+    spinner.stop()
+    console.log(generatedInstallResult(generated.assetName, generated.version))
   } catch (err) {
-    spinner.fail(err instanceof Error ? err.message : String(err))
+    spinner.stop()
     throw err
   }
 }

package/src/commands/install.ts

@@ -1,10 +1,10 @@
-import chalk from 'chalk'
 import ora, { type Ora } from 'ora'
 import { resolve } from '../resolve.js'
 import { install as runInstall } from '../install.js'
 import { generateAndWait } from '../generate.js'
 import { assetNameSchema, type AssetType } from '../schemas.js'
 import { getCliClient } from '../cli-client.js'
+import { compact, generatedInstallResult, installResult } from '../output.js'
 import type { MarketClient } from '../client.js'
 
 export interface InstallCommandOptions {
@@ -20,15 +20,20 @@ interface AssetRequest {
 }
 
 export async function installCommand(args: string[], opts: InstallCommandOptions): Promise<void> {
-  const { client, apiKey } = await getCliClient({ baseUrl: opts.baseUrl })
-  const canGenerate = Boolean(apiKey)
+  const { client, authToken } = await getCliClient({ baseUrl: opts.baseUrl })
+  const canGenerate = Boolean(authToken)
 
-  const spinner = ora().start()
+  const spinner = ora({
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
   try {
     const requests: AssetRequest[] = []
     for (const arg of args) {
       spinner.text = `Resolving "${truncate(arg, 40)}"`
-      requests.push(await resolveArg(client, arg, opts.type, spinner, canGenerate))
+      requests.push(
+        await resolveArg(client, arg, opts.type, spinner, canGenerate, opts.unapproved ?? false),
+      )
     }
 
     spinner.text = 'Resolving dependency tree'
@@ -43,57 +48,57 @@ export async function installCommand(args: string[], opts: InstallCommandOptions
       },
     })
 
-    spinner.succeed(
-      `Installed ${resolution.assets.length} asset(s): ` +
-        resolution.assets.map((a) => chalk.cyan(a.name) + chalk.dim('@' + a.version)).join(', '),
-    )
+    spinner.stop()
+    console.log(installResult(resolution.assets))
   } catch (err) {
-    spinner.fail(err instanceof Error ? err.message : String(err))
+    spinner.stop()
     throw err
   }
 }
 
-/**
- * Fallthrough: exact-name → top-1 search hit → auto-generate (auth only).
- */
 async function resolveArg(
   client: MarketClient,
   arg: string,
   type: AssetType | undefined,
   spinner: Ora,
   canGenerate: boolean,
+  includeUnapproved: boolean,
 ): Promise<AssetRequest> {
-  // 1. Try parsing as asset-name[@range] and looking up exact
   const parsed = parseNameAndRange(arg)
   if (parsed) {
-    const existing = await client.asset.getByName({ name: parsed.name })
+    const existing = await client.asset.exact({
+      name: parsed.name,
+      type,
+      includeUnapproved,
+    })
     if (existing) return parsed
   }
 
-  // 2. Semantic search — top-1
   spinner.text = `Searching "${truncate(arg, 40)}"`
-  const results = await client.asset.list({
-    search: arg,
+  const results = await client.asset.search({
+    query: arg,
     type,
+    includeUnapproved,
     limit: 1,
     page: 1,
     sort: 'relevance',
   })
   if (results.items.length > 0) {
     const hit = results.items[0]
-    spinner.info(`Matched "${chalk.cyan(hit.name)}" ${chalk.dim(`(${hit.type})`)} for "${arg}"`)
-    spinner.start()
+    if (process.stderr.isTTY) {
+      spinner.info(`Matched "${compact(arg, 48)}" to ${hit.name} (${hit.type})`)
+      spinner.start()
+    }
     return { name: hit.name, range: '*' }
   }
 
-  // 3. Auto-generate (requires auth)
   if (!canGenerate) {
     throw new Error(
       `No matches for "${arg}". Run \`market login\` to enable auto-generation of missing assets.`,
     )
   }
 
-  spinner.text = `No matches — generating "${truncate(arg, 40)}"`
+  spinner.text = `No matches; generating "${truncate(arg, 40)}"`
   const generated = await generateAndWait(
     client,
     { description: arg, type },
@@ -103,17 +108,15 @@ async function resolveArg(
       },
     },
   )
-  spinner.info(
-    `Generated ${chalk.cyan(generated.assetName)}${chalk.dim('@' + generated.version)} for "${arg}"`,
-  )
-  spinner.start()
+  if (process.stderr.isTTY) {
+    spinner.info(
+      `${generatedInstallResult(generated.assetName, generated.version)} for "${compact(arg, 48)}"`,
+    )
+    spinner.start()
+  }
   return { name: generated.assetName, range: generated.version }
 }
 
-/**
- * Returns { name, range } if the arg parses as `<asset-name>[@<range>]`.
- * Returns null if the name portion fails the asset-name schema (e.g. has spaces).
- */
 function parseNameAndRange(arg: string): AssetRequest | null {
   const atIdx = arg.indexOf('@')
   const name = atIdx >= 0 ? arg.slice(0, atIdx) : arg
@@ -122,5 +125,5 @@ function parseNameAndRange(arg: string): AssetRequest | null {
 }
 
 function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max - 1) + '…' : s
+  return s.length > max ? s.slice(0, max - 3) + '...' : s
 }

package/src/commands/logout.ts

@@ -1,11 +1,11 @@
-import chalk from 'chalk'
 import { clearConfig, getConfigPath } from '../config.js'
+import { logoutResult } from '../output.js'
 
 export async function logout(): Promise<void> {
   const existed = await clearConfig()
   if (existed) {
-    console.log(chalk.green('Logged out.') + chalk.dim(` (${getConfigPath()} removed)`))
+    console.log(logoutResult(getConfigPath()))
   } else {
-    console.log(chalk.dim('Already logged out.'))
+    console.log(logoutResult())
   }
 }

package/src/commands/preview.ts

@@ -0,0 +1,69 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import ora from 'ora'
+import { getCliClient } from '../cli-client.js'
+import { previewResult } from '../output.js'
+import { assetNameSchema, semverSchema, type AssetType } from '../schemas.js'
+
+export interface PreviewCommandOptions {
+  type?: AssetType
+  unapproved?: boolean
+  out?: string
+  baseUrl?: string
+}
+
+export async function previewCommand(
+  name: string,
+  version: string | undefined,
+  opts: PreviewCommandOptions,
+): Promise<void> {
+  const parsedName = assetNameSchema.parse(name)
+  const parsedVersion = version ? semverSchema.parse(version) : undefined
+  const spinner = ora({
+    text: `Resolving preview for ${parsedName}`,
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
+
+  try {
+    const { client } = await getCliClient({ baseUrl: opts.baseUrl })
+    const resolvedVersion =
+      parsedVersion ??
+      (
+        await client.asset.exact({
+          name: parsedName,
+          type: opts.type ?? 'model',
+          includeUnapproved: opts.unapproved ?? false,
+        })
+      )?.latestVersion
+
+    if (!resolvedVersion) {
+      throw new Error(`Asset "${parsedName}" not found`)
+    }
+
+    spinner.text = `Downloading preview for ${parsedName}@${resolvedVersion}`
+    const preview = await client.asset.downloadPreviewImage({
+      name: parsedName,
+      version: resolvedVersion,
+    })
+    const bytes = new Uint8Array(await preview.arrayBuffer())
+    const out = path.resolve(
+      opts.out ?? `${parsedName}-${resolvedVersion}-preview${previewExtension(preview.type)}`,
+    )
+
+    await fs.mkdir(path.dirname(out), { recursive: true })
+    await fs.writeFile(out, bytes)
+
+    spinner.stop()
+    console.log(previewResult(parsedName, resolvedVersion, out))
+  } catch (err) {
+    spinner.stop()
+    throw err
+  }
+}
+
+function previewExtension(contentType: string): string {
+  if (contentType === 'image/webp') return '.webp'
+  if (contentType === 'image/jpeg') return '.jpg'
+  return '.png'
+}

package/src/commands/search.ts

@@ -1,41 +1,57 @@
-import chalk from 'chalk'
 import ora from 'ora'
 import { getCliClient } from '../cli-client.js'
+import { assetSearchResultLine, searchSummary } from '../output.js'
 import type { AssetType } from '../schemas.js'
 
-const SEARCH_LIMIT = 10
+const SEARCH_LIMIT = 5
 
 export interface SearchCommandOptions {
-  type?: AssetType
+  type: AssetType
+  unapproved?: boolean
   baseUrl?: string
+  limit?: number
+  verbose?: boolean
 }
 
 export async function searchCommand(query: string, opts: SearchCommandOptions): Promise<void> {
   const { client } = await getCliClient({ baseUrl: opts.baseUrl })
 
-  const spinner = ora(`Searching "${query}"`).start()
+  const spinner = ora({
+    text: `Searching "${query}"`,
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
   let results
   try {
-    results = await client.asset.list({
-      search: query,
+    results = await client.asset.search({
+      query,
       type: opts.type,
-      limit: SEARCH_LIMIT,
+      includeUnapproved: opts.unapproved ?? false,
+      limit: opts.limit ?? SEARCH_LIMIT,
       page: 1,
       sort: 'relevance',
     })
   } catch (err) {
-    spinner.fail(err instanceof Error ? err.message : String(err))
+    spinner.stop()
     throw err
   }
   spinner.stop()
 
+  console.log(
+    searchSummary({
+      query,
+      type: opts.type,
+      includeUnapproved: opts.unapproved ?? false,
+      count: results.items.length,
+      total: results.total,
+    }),
+  )
+
   if (results.items.length === 0) {
-    console.log(chalk.dim('No matches.'))
     return
   }
 
   for (const item of results.items) {
-    const desc = item.description ? chalk.dim(` — ${item.description}`) : ''
-    console.log(`  ${chalk.cyan(item.name)} ${chalk.dim(`(${item.type})`)}${desc}`)
+    console.log(assetSearchResultLine(item, { verbose: opts.verbose ?? false }))
   }
 }