@drawcall/market 0.8.25 → 0.8.26

package/src/cli.ts

@@ -1,443 +1,17 @@
 #!/usr/bin/env node
 
-import { createRequire } from 'node:module'
-import { Command, Option } from 'commander'
-import { ASSET_TYPES, type AssetAccess, type AssetType } from './schemas.js'
-import { installCommand } from './commands/install.js'
-import { searchCommand } from './commands/search.js'
-import { agentCommand } from './commands/agent.js'
-import { generateCommand } from './commands/generate.js'
-import { generateInstallCommand } from './commands/generate-install.js'
-import { listCommand } from './commands/list.js'
-import { packCommand } from './commands/pack.js'
-import { syncCommand } from './commands/sync.js'
-import { previewCommand } from './commands/preview.js'
-import { urlsCommand } from './commands/urls.js'
-import { uploadCommand } from './commands/upload.js'
-import { typesCommand } from './commands/types.js'
-import { logout } from './commands/logout.js'
-import { v1 } from './index.js'
-import { saveConfig, getConfigPath } from './config.js'
-import { errorResult, loginResult } from './output.js'
-import { marketSkill } from './skill.js'
+import { createMarketCommand } from './command.js'
+import { errorResult } from './output.js'
 
-const packageVersion = readPackageVersion()
-const program = new Command()
-
-const DEFAULT_BASE_URL = 'https://market.drawcall.ai'
-const AUTH_ISSUER_URL = 'https://auth.drawcall.ai/api/auth'
-const DEVICE_CLIENT_ID = 'market-cli'
-
-/** Accumulate a repeatable option into an array. */
-const collect = (value: string, previous: string[]): string[] => previous.concat(value)
-
-const typeOption = new Option('--type <type>', 'Asset type').choices([...ASSET_TYPES])
-const referenceImageOption = new Option(
-  '--reference-image <file-or-url>',
-  'Reference image the result should match: file path or http(s) URL (repeatable)',
-)
-  .argParser(collect)
-  .default([])
-// Omitted → the server picks the default from your entitlement (private if you hold market:private,
-// else public). `--access private` requires that entitlement.
-const accessOption = new Option('--access <access>', 'Asset visibility').choices([
-  'public',
-  'private',
-])
-const apiOption = new Option('--api <url>', 'API URL').default(
-  process.env.MARKET_API_URL,
-  'from MARKET_API_URL / config / default',
-)
-
-program
-  .name('market')
-  .description('Find and use Drawcall Market assets')
-  .version(packageVersion)
-  .enablePositionalOptions()
-  .addHelpText(
-    'after',
-    '\nAI agents that have not already seen the Market skill should run `market skill` before using this CLI.',
-  )
-
-program
-  .command('skill')
-  .description('Print the Market agent skill')
-  .action(() => {
-    process.stdout.write(marketSkill)
-  })
-
-program
-  .command('types')
-  .description('List current asset types, generation support, and search guidance')
-  .addOption(apiOption)
-  .action(async (opts: { api?: string }) => {
-    await typesCommand(opts.api)
-  })
-
-program
-  .command('login')
-  .description('Sign in')
-  .addOption(apiOption)
-  .action(async (opts: { api?: string }) => {
-    const baseUrl = opts.api ?? DEFAULT_BASE_URL
-    const token = await runDeviceLogin()
-    const client = v1.createClient({ baseUrl, authToken: token })
-    const profile = await client.user.getProfile()
-    if (!profile) throw new Error('The Market API did not accept the auth token.')
-    // Only pin baseUrl in config when the user explicitly chose one. Persisting
-    // the default would freeze logged-in users to a host the CLI can no longer
-    // change in a future release.
-    await saveConfig(opts.api ? { authToken: token, baseUrl: opts.api } : { authToken: token })
-    console.log(loginResult(profile.email, getConfigPath()))
-  })
-
-program
-  .command('logout')
-  .description('Sign out')
-  .action(async () => {
-    await logout()
-  })
-
-program
-  .command('install')
-  .description('Install assets by name, or package.json assetDependencies when no names are given')
-  .argument('[assets...]', 'Asset names, optionally with @range')
-  .addOption(apiOption)
-  .option('--unapproved', 'Include unapproved versions', false)
-  .option('--force', 'Overwrite existing files', false)
-  .option('--key <key>', 'Access key of a shared private asset (no account needed)')
-  .option('--cwd <dir>', 'Project directory')
-  .option(
-    '--redirect <folder>',
-    'Do not download asset files destined for this static root (e.g. public); write <folder>/_redirects rules to their canonical URLs instead. Repeatable.',
-    collect,
-    [],
-  )
-  .action(
-    async (
-      args: string[],
-      opts: {
-        api?: string
-        unapproved: boolean
-        force: boolean
-        key?: string
-        cwd?: string
-        redirect: string[]
-      },
-    ) => {
-      await installCommand(args, {
-        baseUrl: opts.api,
-        unapproved: opts.unapproved,
-        force: opts.force,
-        key: opts.key,
-        cwd: opts.cwd,
-        redirect: opts.redirect,
-      })
-    },
-  )
-
-program
-  .command('list')
-  .description('List asset dependencies declared in package.json, including file aliases')
-  .option('--cwd <dir>', 'Project directory')
-  .action(async (opts: { cwd?: string }) => {
-    await listCommand({
-      cwd: opts.cwd,
-    })
-  })
-
-program
-  .command('sync')
-  .description(
-    'Update package.json assetDependencies aliases to match where installed files live now',
-  )
-  .addOption(apiOption)
-  .option('--cwd <dir>', 'Project directory')
-  .action(async (opts: { api?: string; cwd?: string }) => {
-    await syncCommand({
-      baseUrl: opts.api,
-      cwd: opts.cwd,
-    })
-  })
-
-program
-  .command('pack')
-  .description('Create a Market asset zip using the same packaging step as upload')
-  .argument('<source>', 'project directory, .zip path, or glob')
-  .addOption(typeOption)
-  .option('--out <file>', 'Output zip path')
-  .option('--cwd <dir>', 'Project directory')
-  .option('--npm <dep>', 'npm dependency name@range (repeatable)', collect, [])
-  .option('--asset <dep>', 'asset dependency name@range (repeatable)', collect, [])
-  .option('--skill <dep>', 'skill dependency label=source (repeatable)', collect, [])
-  .action(
-    async (
-      zipFilter: string,
-      opts: {
-        type?: AssetType
-        out?: string
-        cwd?: string
-        npm: string[]
-        asset: string[]
-        skill: string[]
-      },
-    ) => {
-      await packCommand(zipFilter, {
-        type: opts.type,
-        out: opts.out,
-        cwd: opts.cwd,
-        npm: opts.npm,
-        asset: opts.asset,
-        skill: opts.skill,
-      })
-    },
-  )
-
-program
-  .command('search')
-  .description('Find assets')
-  .argument('<query>', 'Search query')
-  .addOption(typeOption)
-  .addOption(apiOption)
-  .option('--unapproved', 'Include unapproved versions', false)
-  .option('--limit <n>', 'Max results, 1-5', parseSearchLimit, 5)
-  .option('--json', 'Emit a machine-readable JSON array instead of the summary lines', false)
-  .action(
-    async (
-      query: string,
-      opts: {
-        type?: AssetType
-        api?: string
-        unapproved: boolean
-        limit: number
-        json: boolean
-      },
-    ) => {
-      requireType(opts.type, 'Search')
-      await searchCommand(query, {
-        type: opts.type,
-        baseUrl: opts.api,
-        unapproved: opts.unapproved,
-        limit: opts.limit,
-        json: opts.json,
-      })
-    },
-  )
-
-const agent = program
-  .command('agent')
-  .description('Plan, find, judge and generate a set of assets from a goal')
-  .argument('[goal]', 'What you need, in plain language')
-  .addOption(apiOption)
-  .addOption(referenceImageOption)
-  .option('--json', 'Output JSON', false)
-  .action(
-    async (
-      goal: string | undefined,
-      opts: { api?: string; referenceImage: string[]; json: boolean },
-    ) => {
-      if (!goal) {
-        agent.help({ error: true })
-        return
-      }
-      await agentCommand(goal, {
-        baseUrl: opts.api,
-        referenceImages: opts.referenceImage,
-        json: opts.json,
-      })
-    },
-  )
-
-program
-  .command('upload')
-  .description('Publish one asset')
-  .argument('<name>', 'Asset name')
-  .argument('<zip-filter>', '.zip path or glob')
-  .argument('<description>', 'Short description')
-  .addOption(typeOption)
-  .addOption(apiOption)
-  .option('--version <version>', 'Explicit semver version')
-  .option('--cwd <dir>', 'Project directory')
-  .option('--npm <dep>', 'npm dependency name@range (repeatable)', collect, [])
-  .option('--asset <dep>', 'asset dependency name@range (repeatable)', collect, [])
-  .option('--skill <dep>', 'skill dependency label=source (repeatable)', collect, [])
-  .addOption(accessOption)
-  .action(
-    async (
-      name: string,
-      zipFilter: string,
-      description: string,
-      opts: {
-        type?: AssetType
-        api?: string
-        version?: string
-        cwd?: string
-        npm: string[]
-        asset: string[]
-        skill: string[]
-        access?: AssetAccess
-      },
-    ) => {
-      requireType(opts.type, 'Upload')
-      await uploadCommand(name, zipFilter, description, {
-        type: opts.type,
-        version: opts.version,
-        baseUrl: opts.api,
-        cwd: opts.cwd,
-        npm: opts.npm,
-        asset: opts.asset,
-        skill: opts.skill,
-        access: opts.access,
-      })
-    },
-  )
-
-program
-  .command('preview')
-  .description("Save an asset's preview image")
-  .argument('<asset>', 'Asset name, optionally with @version')
-  .addOption(apiOption)
-  .option('--unapproved', 'Include unapproved versions', false)
-  .option('--out <file>', 'Output image path')
-  .action(async (name: string, opts: { api?: string; unapproved: boolean; out?: string }) => {
-    await previewCommand(name, {
-      baseUrl: opts.api,
-      unapproved: opts.unapproved,
-      out: opts.out,
-    })
-  })
-
-program
-  .command('urls')
-  .description("Print an asset's remote file base URL, subpaths, and preview URL")
-  .argument('<asset>', 'Asset name, optionally with @version')
-  .addOption(apiOption)
-  .option('--unapproved', 'Include unapproved versions', false)
-  .option('--key <key>', 'Access key of a shared private asset (no account needed)')
-  .action(async (ref: string, opts: { api?: string; unapproved: boolean; key?: string }) => {
-    await urlsCommand(ref, {
-      baseUrl: opts.api,
-      unapproved: opts.unapproved,
-      key: opts.key,
-    })
-  })
-
-const generate = program
-  .command('generate')
-  .description('Generate and install an asset, or check a generation job')
-  .argument('[description]', 'Asset prompt (omit when using a subcommand)')
-  .addOption(typeOption)
-  .addOption(apiOption)
-  .addOption(referenceImageOption)
-  .option('--cwd <dir>', 'Project directory')
-  .addOption(accessOption)
-  .action(
-    async (
-      description: string | undefined,
-      opts: {
-        type?: AssetType
-        api?: string
-        referenceImage: string[]
-        cwd?: string
-        access?: AssetAccess
-      },
-    ) => {
-      if (!description) {
-        generate.help({ error: true })
-        return
-      }
-      requireType(opts.type, 'Generate')
-      await generateCommand(description, {
-        type: opts.type,
-        baseUrl: opts.api,
-        referenceImages: opts.referenceImage,
-        cwd: opts.cwd,
-        access: opts.access,
-      })
-    },
-  )
-
-// `generate install <jobId>` finishes a slow (job-based) generation: it checks the job once and, when
-// it has completed, installs the produced asset into the project. Still running → prints a note and
-// exits 0 (run again later); failed → exits 1. Fast asset types never need this — `generate` installs
-// them inline. ("install" over "status": the command's job is to integrate the asset, not just report.)
-generate
-  .command('install')
-  .description('Install the asset from a generation job once it has completed')
-  .argument('<jobId>', 'Job id printed by `market generate`')
-  .addOption(apiOption)
-  .option('--cwd <dir>', 'Project directory')
-  // Read merged options: `--cwd`/`--api` after `generate install` are otherwise captured by the
-  // parent `generate` command (which declares the same options), leaving this subcommand's own opts
-  // undefined. `optsWithGlobals()` surfaces whichever level parsed them.
-  .action(async (jobId: string, _options, command: Command) => {
-    const { api, cwd } = command.optsWithGlobals()
-    await generateInstallCommand(jobId, { baseUrl: api, cwd })
-  })
+const program = createMarketCommand()
 
 if (process.argv.length <= 2) {
   program.outputHelp()
   process.exit(0)
 }
 
-program.parseAsync().catch((err) => {
-  const message = err instanceof Error ? err.message : String(err)
+program.parseAsync().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : String(error)
   console.error(errorResult(message))
   process.exit(1)
 })
-
-function requireType(type: AssetType | undefined, command: string): asserts type is AssetType {
-  if (!type) {
-    console.error(
-      errorResult(`${command} requires --type. Available types: ${ASSET_TYPES.join(', ')}`),
-    )
-    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)
-}
-
-function readPackageVersion(): string {
-  const value: unknown = createRequire(import.meta.url)('../package.json')
-  if (
-    !value ||
-    typeof value !== 'object' ||
-    Array.isArray(value) ||
-    !('version' in value) ||
-    typeof value.version !== 'string'
-  ) {
-    throw new Error('Market package.json is missing a valid version')
-  }
-  return value.version
-}
-
-async function runDeviceLogin(): Promise<string> {
-  // Login-only dependencies load lazily: every other command skips their startup cost.
-  const [{ default: chalk }, { default: open }, oauthClient] = await Promise.all([
-    import('chalk'),
-    import('open'),
-    import('openid-client'),
-  ])
-  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/command-entry.ts

@@ -0,0 +1 @@
+export { createMarketCommand, type MarketCommandOptions } from './command.js'