@drawcall/market 0.1.3 → 0.1.5

package/src/commands/install.ts

@@ -0,0 +1,126 @@
+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 type { MarketClient } from '../client.js'
+
+export interface InstallCommandOptions {
+  type?: AssetType
+  unapproved?: boolean
+  cwd?: string
+  baseUrl?: string
+}
+
+interface AssetRequest {
+  name: string
+  range: string
+}
+
+export async function installCommand(args: string[], opts: InstallCommandOptions): Promise<void> {
+  const { client, apiKey } = await getCliClient({ baseUrl: opts.baseUrl })
+  const canGenerate = Boolean(apiKey)
+
+  const spinner = ora().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))
+    }
+
+    spinner.text = 'Resolving dependency tree'
+    const resolution = await resolve(client.asset, requests, {
+      includeUnapproved: opts.unapproved ?? false,
+    })
+
+    await runInstall(client, resolution, {
+      cwd: opts.cwd,
+      onProgress: (msg) => {
+        spinner.text = msg
+      },
+    })
+
+    spinner.succeed(
+      `Installed ${resolution.assets.length} asset(s): ` +
+        resolution.assets.map((a) => chalk.cyan(a.name) + chalk.dim('@' + a.version)).join(', '),
+    )
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : String(err))
+    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,
+): 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 })
+    if (existing) return parsed
+  }
+
+  // 2. Semantic search — top-1
+  spinner.text = `Searching "${truncate(arg, 40)}"`
+  const results = await client.asset.list({
+    search: arg,
+    type,
+    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()
+    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)}"`
+  const generated = await generateAndWait(
+    client,
+    { description: arg, type },
+    {
+      onProgress: (msg) => {
+        spinner.text = msg
+      },
+    },
+  )
+  spinner.info(
+    `Generated ${chalk.cyan(generated.assetName)}${chalk.dim('@' + generated.version)} for "${arg}"`,
+  )
+  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
+  const range = atIdx >= 0 ? arg.slice(atIdx + 1) : '*'
+  return assetNameSchema.safeParse(name).success ? { name, range } : null
+}
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max - 1) + '…' : s
+}

package/src/commands/login.ts

@@ -0,0 +1,113 @@
+import * as http from 'http'
+import type { AddressInfo } from 'net'
+import chalk from 'chalk'
+import open from 'open'
+import ora from 'ora'
+import { createMarketClient } from '../client.js'
+import { saveConfig, getConfigPath } from '../config.js'
+
+export interface LoginOptions {
+  baseUrl: string
+  timeoutMs?: number
+}
+
+/**
+ * Spins up a localhost HTTP server, opens the browser to {baseUrl}/cli-auth,
+ * waits for the web app to redirect back with the key, saves it to config.
+ */
+export async function login(opts: LoginOptions): Promise<void> {
+  const timeoutMs = opts.timeoutMs ?? 120_000
+  const state = crypto.randomUUID()
+
+  const { port, waitForKey, close } = await startCallbackServer(state, timeoutMs)
+
+  const authUrl = new URL('/cli-auth', opts.baseUrl)
+  authUrl.searchParams.set('state', state)
+  authUrl.searchParams.set('callback', `http://127.0.0.1:${port}/callback`)
+
+  console.log(chalk.dim(`If your browser doesn't open, visit:\n  ${authUrl.toString()}`))
+  await open(authUrl.toString()).catch(() => {})
+
+  const spinner = ora('Waiting for browser approval…').start()
+  try {
+    const key = await waitForKey
+
+    spinner.text = 'Verifying key…'
+    const verifyClient = createMarketClient({ baseUrl: opts.baseUrl, apiKey: key })
+    const profile = await verifyClient.user.getProfile()
+    if (!profile) {
+      throw new Error('Key was not accepted by the server.')
+    }
+
+    await saveConfig({ apiKey: key, baseUrl: opts.baseUrl })
+    spinner.succeed(`Logged in as ${chalk.cyan(profile.email)}`)
+    console.log(chalk.dim(`  Key saved to ${getConfigPath()}`))
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : String(err))
+    throw err
+  } finally {
+    close()
+  }
+}
+
+async function startCallbackServer(
+  expectedState: string,
+  timeoutMs: number,
+): Promise<{ port: number; waitForKey: Promise<string>; close: () => void }> {
+  let resolveKey!: (k: string) => void
+  let rejectKey!: (e: Error) => void
+  const waitForKey = new Promise<string>((resolve, reject) => {
+    resolveKey = resolve
+    rejectKey = reject
+  })
+
+  const server = http.createServer((req, res) => {
+    if (!req.url) {
+      res.writeHead(400).end()
+      return
+    }
+    const url = new URL(req.url, 'http://localhost')
+    if (url.pathname !== '/callback') {
+      res.writeHead(404).end()
+      return
+    }
+    const receivedState = url.searchParams.get('state')
+    const receivedKey = url.searchParams.get('key')
+
+    if (receivedState !== expectedState) {
+      res.writeHead(400, { 'Content-Type': 'text/html' })
+      res.end('<h1>Invalid state</h1><p>You can close this window.</p>')
+      rejectKey(new Error('Invalid state parameter from callback.'))
+      return
+    }
+    if (!receivedKey) {
+      res.writeHead(400, { 'Content-Type': 'text/html' })
+      res.end('<h1>Missing key</h1><p>You can close this window.</p>')
+      rejectKey(new Error('Callback did not include a key.'))
+      return
+    }
+
+    res.writeHead(200, { 'Content-Type': 'text/html' })
+    res.end('<h1>Logged in!</h1><p>You can close this window.</p>')
+    resolveKey(receivedKey)
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', () => resolve())
+  })
+
+  const address = server.address() as AddressInfo | null
+  if (!address) throw new Error('Failed to bind local callback server.')
+
+  const timer = setTimeout(() => {
+    rejectKey(new Error(`Timed out after ${timeoutMs / 1000}s waiting for browser approval.`))
+  }, timeoutMs)
+
+  const close = () => {
+    clearTimeout(timer)
+    server.close()
+  }
+
+  return { port: address.port, waitForKey, close }
+}

package/src/commands/logout.ts

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

package/src/commands/search.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk'
+import ora from 'ora'
+import { getCliClient } from '../cli-client.js'
+import type { AssetType } from '../schemas.js'
+
+const SEARCH_LIMIT = 10
+
+export interface SearchCommandOptions {
+  type?: AssetType
+  baseUrl?: string
+}
+
+export async function searchCommand(query: string, opts: SearchCommandOptions): Promise<void> {
+  const { client } = await getCliClient({ baseUrl: opts.baseUrl })
+
+  const spinner = ora(`Searching "${query}"`).start()
+  let results
+  try {
+    results = await client.asset.list({
+      search: query,
+      type: opts.type,
+      limit: SEARCH_LIMIT,
+      page: 1,
+      sort: 'relevance',
+    })
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : String(err))
+    throw err
+  }
+  spinner.stop()
+
+  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}`)
+  }
+}

package/src/config.ts

@@ -0,0 +1,53 @@
+import * as fs from 'fs/promises'
+import * as os from 'os'
+import * as path from 'path'
+import { z } from 'zod'
+
+const configSchema = z.object({
+  apiKey: z.string().startsWith('mk_'),
+  baseUrl: z.string().url().optional(),
+})
+
+export type Config = z.infer<typeof configSchema>
+
+function configDir(): string {
+  if (process.platform === 'win32' && process.env.APPDATA) {
+    return path.join(process.env.APPDATA, 'drawcall-market')
+  }
+  const base = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config')
+  return path.join(base, 'drawcall-market')
+}
+
+function configPath(): string {
+  return path.join(configDir(), 'config.json')
+}
+
+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
+  } catch {
+    return null
+  }
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+  const dir = configDir()
+  await fs.mkdir(dir, { recursive: true })
+  const file = configPath()
+  await fs.writeFile(file, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 })
+}
+
+export async function clearConfig(): Promise<boolean> {
+  try {
+    await fs.unlink(configPath())
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function getConfigPath(): string {
+  return configPath()
+}

package/src/contract.ts

@@ -2,6 +2,7 @@ import { oc } from '@orpc/contract'
 import { z } from 'zod'
 import {
   assetNameSchema,
+  assetTypeSchema,
   semverSchema,
   listAssetsSchema,
   updateProfileSchema,
@@ -106,6 +107,15 @@ export interface FileTreeEntry {
   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 = {
@@ -114,9 +124,7 @@ export const contract = {
       .input(z.object({ name: assetNameSchema }))
       .output(z.custom<AssetWithVersionsAndTags | null>()),
 
-    list: oc
-      .input(listAssetsSchema)
-      .output(z.custom<PaginatedList<AssetListItem>>()),
+    list: oc.input(listAssetsSchema).output(z.custom<PaginatedList<AssetListItem>>()),
 
     getVersionTree: oc
       .input(z.object({ name: z.string(), version: semverSchema }))
@@ -144,44 +152,46 @@ export const contract = {
       .input(uploadTypedSchema.extend({ file: z.instanceof(File) }))
       .output(z.custom<AssetVersion>()),
 
-    material: oc
-      .input(uploadMaterialSchema)
-      .output(z.custom<AssetVersion>()),
+    material: oc.input(uploadMaterialSchema).output(z.custom<AssetVersion>()),
   },
 
   admin: {
-    listUnapproved: oc
-      .output(z.custom<UnapprovedItem[]>()),
+    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() })),
+    backfillEmbeddings: oc.output(z.object({ indexed: z.number() })),
   },
 
   user: {
-    getProfile: oc
-      .output(z.custom<User | null>()),
+    getProfile: oc.output(z.custom<User | null>()),
 
-    updateProfile: oc
-      .input(updateProfileSchema)
-      .output(z.custom<User>()),
+    updateProfile: oc.input(updateProfileSchema).output(z.custom<User>()),
 
-    getApiKey: oc
-      .output(z.custom<{ prefix: string; createdAt: Date } | null>()),
+    getApiKey: oc.output(z.custom<{ prefix: string; createdAt: Date } | null>()),
 
-    regenerateApiKey: oc
-      .output(z.object({ key: z.string(), prefix: z.string() })),
+    regenerateApiKey: oc.output(z.object({ key: z.string(), prefix: z.string() })),
 
-    myAssets: oc
-      .output(z.custom<AssetWithVersions[]>()),
+    myAssets: oc.output(z.custom<AssetWithVersions[]>()),
   },
 
   tag: {
-    list: oc
-      .output(z.custom<TagWithCount[]>()),
+    list: oc.output(z.custom<TagWithCount[]>()),
+  },
+
+  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>()),
   },
 }
 

package/src/generate.ts

@@ -0,0 +1,62 @@
+import type { MarketClient } from './client.js'
+import type { AssetType } from './schemas.js'
+
+export class GenerateError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'GenerateError'
+  }
+}
+
+export interface GenerateInput {
+  description: string
+  type?: AssetType
+}
+
+export interface GenerateResult {
+  assetName: string
+  version: string
+}
+
+export interface GenerateOptions {
+  onProgress?: (message: string) => void
+  pollIntervalMs?: number
+  timeoutMs?: number
+}
+
+export async function generateAndWait(
+  client: MarketClient,
+  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)
+  }
+
+  throw new GenerateError(`Generation timed out after ${timeoutMs}ms.`)
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/index.ts

@@ -20,12 +20,17 @@ export type {
   UnapprovedItem,
   TagWithCount,
   FileTreeEntry,
+  GenerateJobStatus,
 } from './contract.js'
 
 // Resolve
 export { resolve, ResolutionError } from './resolve.js'
 export type { ResolvedAsset, ResolveResult } from './resolve.js'
 
+// Generate
+export { generateAndWait, GenerateError } from './generate.js'
+export type { GenerateInput, GenerateResult, GenerateOptions } from './generate.js'
+
 // Schemas
 export {
   ASSET_TYPES,