@drawcall/market 0.9.3 → 0.10.0

package/skills/market/SKILL.md

@@ -7,21 +7,21 @@ description: Find, inspect, generate, and use Drawcall Market assets from a codi
 
 ## CLI transport
 
-Run commands as `npx @drawcall/market <command>`; do not assume a global `market` binary or switch to MCP after a CLI failure. Use `npx @drawcall/market skill` when these instructions are not already available.
+Run commands as `npx drawcall market <command>`; do not assume a global `market` binary or switch to MCP after a CLI failure. Use `npx drawcall market skill` when these instructions are not already available.
 
 Discover the current vocabulary and choose an asset:
 
 ```sh
-npx @drawcall/market types
-npx @drawcall/market search "<query>" --type <type> --limit 3
-npx @drawcall/market preview <name@version> --out /tmp/<name>.png
-npx @drawcall/market urls <name@version>
+npx drawcall market types
+npx drawcall market search "<query>" --type <type> --limit 3
+npx drawcall market preview <name@version> --out /tmp/<name>.png
+npx drawcall market urls <name@version>
 ```
 
 `urls` prints one base URL, file subpaths, and a preview URL without changing the project. Install exact refs together when the project needs local files:
 
 ```sh
-npx @drawcall/market install <name@range...> --cwd "$PWD"
+npx drawcall market install <name@range...> --cwd "$PWD"
 ```
 
 Install records `assetDependencies` in the nearest `package.json`. `list --cwd "$PWD"` reads that inventory without network access. Run `sync --cwd "$PWD"` after moving installed files so aliases continue to resolve. Use `--force` only with permission to overwrite changed files.
@@ -29,16 +29,16 @@ Install records `assetDependencies` in the nearest `package.json`. `list --cwd "
 Generate and install one asset with:
 
 ```sh
-npx @drawcall/market generate --type <type> "<description>"
+npx drawcall market generate --type <type> "<description>"
 ```
 
 If it returns a continuation, run the printed `generate install <jobId>` command. The Market agent can source a coherent set of assets from a broader goal:
 
 ```sh
-npx @drawcall/market agent "<goal>"
+npx drawcall market agent "<goal>"
 ```
 
-Publish only when asked. `pack <source> --out <zip>` creates a Market archive and `upload <name> <source> "<description>" --type <type>` publishes it. Use command help for dependency and visibility options. If authentication is required, ask before running `npx @drawcall/market login`.
+Publish only when asked. `pack <source> --out <zip>` creates a Market archive and `upload <name> <source> "<description>" --type <type>` publishes it. Use command help for dependency and visibility options. If authentication is required, ask before running `npx drawcall auth login`.
 
 ## Choose assets
 
@@ -56,7 +56,7 @@ Reference images must be direct fetchable image URLs or image data, never webpag
 
 A generated humanoid model is one expressive, animation-ready biped: one head, two arms, two legs, open empty hands, and no companions or scene. Describe identity, theme, silhouette, clothing, colors, and materials. Express topology outside the shared skeleton as costume or body-surface design so the result remains riggable.
 
-Request public or private access only when visibility matters. Private generation requires the account's `market:private` entitlement.
+Treat visibility as a publication decision. Choose public only when the user explicitly approves publication; choose private when the asset should remain owner-only. Private generation requires the account's `market:private` entitlement.
 
 ## Failures
 

package/src/auth.ts

@@ -9,6 +9,7 @@ import { logout } from './commands/logout.js'
 import { clearConfig, saveConfig } from './config.js'
 import { loginResult } from './output.js'
 import { createClient } from './v1/client.js'
+import { getCliSource } from './installation-id.js'
 
 const DEFAULT_BASE_URL = 'https://market.drawcall.ai'
 
@@ -24,7 +25,7 @@ export function createLoginCommand(): Command {
     .action(async (options: { api?: string }) => {
       const baseUrl = options.api ?? DEFAULT_BASE_URL
       const token = await runDeviceLogin()
-      const client = createClient({ baseUrl, authToken: token })
+      const client = createClient({ baseUrl, authToken: token, source: await getCliSource() })
       const profile = await client.user.getProfile()
       if (!profile) throw new Error('The Market API did not accept the auth token.')
 

package/src/cli-client.ts

@@ -2,12 +2,13 @@ import type { MarketClient } from './client.js'
 import { getAuthToken } from '@drawcall/auth'
 import { createClient as createV1Client } from './v1/client.js'
 import { loadConfig } from './config.js'
+import { getCliSource } from './installation-id.js'
 
 const DEFAULT_BASE_URL = 'https://market.drawcall.ai'
 
 export class NotLoggedInError extends Error {
   constructor() {
-    super('Not logged in. Run `market login` first.')
+    super('Not logged in. Run `npx drawcall auth login` first.')
     this.name = 'NotLoggedInError'
   }
 }
@@ -25,6 +26,14 @@ export interface CliClient {
   authToken: string | undefined
 }
 
+export interface AuthenticatedCliClient extends CliClient {
+  authToken: string
+}
+
+export function getCliClient(
+  opts: CliClientOptions & { requireAuth: true },
+): Promise<AuthenticatedCliClient>
+export function getCliClient(opts?: CliClientOptions): Promise<CliClient>
 export async function getCliClient(opts: CliClientOptions = {}): Promise<CliClient> {
   const authToken = await getAuthToken()
   const config = await loadConfig()
@@ -37,7 +46,11 @@ export async function getCliClient(opts: CliClientOptions = {}): Promise<CliClie
   return {
     // The v1 client has the same call shapes as the legacy `MarketClient`, so every CLI command
     // and library consumer of `getCliClient` speaks /api/v1 without a signature change.
-    client: createV1Client({ baseUrl, authToken }),
+    client: createV1Client({
+      baseUrl,
+      authToken,
+      source: await getCliSource(),
+    }),
     baseUrl,
     authToken,
   }

package/src/commands/agent.ts

@@ -43,7 +43,9 @@ function printResult(result: AgentResult, asJson: boolean): void {
       const note = asset.notes ? ` — ${asset.notes}` : ''
       console.log(`- ${assetVersionRef(asset.name, asset.version)}${note}`)
     }
-    console.log(`Install: market install ${assets.map((asset) => asset.name).join(' ')}`)
+    console.log(
+      `Install: npx drawcall market install ${assets.map((asset) => asset.name).join(' ')}`,
+    )
   }
   if (notes) {
     console.log(`Notes: ${notes}`)

package/src/commands/install.ts

@@ -2,7 +2,12 @@ import * as fs from 'fs/promises'
 import * as path from 'path'
 import ora from 'ora'
 import { resolve } from '../resolve.js'
-import { findInstallRoot, install as runInstall, type InstallRootRequest } from '../install.js'
+import {
+  findInstallRoot,
+  install as runInstall,
+  type InstallResult,
+  type InstallRootRequest,
+} from '../install.js'
 import { packageJsonAssetDependencies } from '../package-json.js'
 import { assetDependencyRange, assetNameSchema, type AssetDependencies } from '../schemas.js'
 import { getCliClient } from '../cli-client.js'
@@ -57,18 +62,41 @@ export async function installCommand(args: string[], opts: InstallCommandOptions
 
     spinner.stop()
     console.log(installResult(result, metadata))
+    await reportCompletedInstall(client, result)
   } catch (err) {
     spinner.stop()
     throw err
   }
 }
 
+async function reportCompletedInstall(client: MarketClient, result: InstallResult): Promise<void> {
+  try {
+    await client.installation.complete({
+      assetCount: result.assets.length,
+      assetTypes: [...new Set(result.assets.map((asset) => asset.type))],
+      fileCount: result.assets.reduce((count, asset) => count + asset.files.length, 0),
+      npmDependencyCount: Object.keys(result.npmDependencies).length,
+      redirectedFileCount: result.assets.reduce(
+        (count, asset) => count + asset.redirectedFiles.length,
+        0,
+      ),
+      skillDependencyCount: Object.keys(result.skillDependencies).length,
+      warningCount: result.warnings.length,
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.warn(
+      `Assets installed, but the Market could not record the completed install: ${message}`,
+    )
+  }
+}
+
 /**
  * Resolve a single `name` or `name@range` argument to an exact asset request.
  * Asset names are globally unique, so the name fully determines the asset — no
  * `--type` is needed. install never fuzzy-searches or generates: it points the
- * caller at `market search` / `market generate` instead, which keeps behavior
- * predictable for agents.
+ * caller at `npx drawcall market search` / `npx drawcall market generate`
+ * instead, which keeps behavior predictable for agents.
  */
 export async function resolveArg(
   client: MarketClient,
@@ -79,7 +107,7 @@ export async function resolveArg(
   const parsed = parseNameAndRange(arg)
   if (!parsed) {
     throw new Error(
-      `Invalid asset name "${arg}". Use \`market search --type <type> <query>\` to find assets.`,
+      `Invalid asset name "${arg}". Use \`npx drawcall market search --type <type> <query>\` to find assets.`,
     )
   }
 
@@ -108,8 +136,8 @@ export async function resolveArg(
   }
 
   throw new Error(
-    `Asset "${parsed.name}" not found. Use \`market search\` to find assets or ` +
-      `\`market generate --type <type>\` to create one.`,
+    `Asset "${parsed.name}" not found. Use \`npx drawcall market search\` to find assets or ` +
+      `\`npx drawcall market generate --type <type>\` to create one.`,
   )
 }
 

package/src/commands/reference-images.ts

@@ -1,3 +1,4 @@
+import { Buffer } from 'node:buffer'
 import { readFile } from 'node:fs/promises'
 import { extname } from 'node:path'
 
@@ -12,7 +13,7 @@ export function loadReferenceImages(refs: string[]): Promise<string[]> {
 async function loadReferenceImage(ref: string): Promise<string> {
   if (ref.startsWith('http://') || ref.startsWith('https://')) return ref
   const data = await readFile(ref)
-  return `data:${mimeFor(ref)};base64,${data.toString('base64')}`
+  return `data:${mimeFor(ref)};base64,${Buffer.from(data).toString('base64')}`
 }
 
 function mimeFor(path: string): string {

package/src/commands/upload.ts

@@ -74,7 +74,7 @@ export async function uploadCommand(
     for (const line of packWarnings(packed)) console.warn(line)
     const profile = await client.user.getProfile()
     if (!profile) {
-      throw new Error('Not logged in. Run `market login` first.')
+      throw new Error('Not logged in. Run `npx drawcall auth login` first.')
     }
     const [existing] = await lookupAssets(client.asset, [{ name: parsedName }], {
       includeUnapproved: true,

package/src/config.ts

@@ -13,7 +13,7 @@ export interface Config {
   baseUrl?: string
 }
 
-function configDir(): string {
+export function getConfigDir(): string {
   if (process.platform === 'win32' && process.env.APPDATA) {
     return path.join(process.env.APPDATA, 'drawcall-market')
   }
@@ -22,7 +22,7 @@ function configDir(): string {
 }
 
 function configPath(): string {
-  return path.join(configDir(), 'config.json')
+  return path.join(getConfigDir(), 'config.json')
 }
 
 export async function loadConfig(): Promise<Config | null> {
@@ -35,7 +35,7 @@ export async function loadConfig(): Promise<Config | null> {
 }
 
 export async function saveConfig(config: Config): Promise<void> {
-  const dir = configDir()
+  const dir = getConfigDir()
   await fs.mkdir(dir, { recursive: true })
   // `mode` on writeFile/mkdir only applies when the path is created, so chmod
   // explicitly to protect a pre-existing (possibly world-readable) token file

package/src/install-entry.ts

@@ -1,6 +1,6 @@
 export type { MarketClient, MarketClientOptions } from './client.js'
 export { getCliClient, NotLoggedInError } from './cli-client.js'
-export type { CliClient, CliClientOptions } from './cli-client.js'
+export type { AuthenticatedCliClient, CliClient, CliClientOptions } from './cli-client.js'
 
 export { resolve, ResolutionError } from './resolve.js'
 export type { ResolvedAsset, ResolveResult } from './resolve.js'

package/src/install.ts

@@ -40,7 +40,7 @@ export interface InstallOptions {
   rootRequests?: InstallRootRequest[]
   /** Asset-type install policy from the Market API. */
   installMetadata?: Record<string, AssetInstallMetadata>
-  /** Capability key of a shared private asset (`market install <asset> --key <key>`). */
+  /** Capability key of a shared private asset (`npx drawcall market install <asset> --key <key>`). */
   key?: string
   /** Log progress */
   onProgress?: (message: string) => void

package/src/installation-id.ts

@@ -0,0 +1,44 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { z } from 'zod'
+import { getConfigDir } from './config.js'
+import type { MarketV1ClientOptions } from './v1/client.js'
+
+const installationIdSchema = z.string().uuid()
+
+function installationIdPath(): string {
+  return path.join(getConfigDir(), 'installation-id')
+}
+
+export async function getInstallationId(): Promise<string> {
+  try {
+    return installationIdSchema.parse((await fs.readFile(installationIdPath(), 'utf-8')).trim())
+  } catch (error) {
+    if (!isMissingFile(error)) throw error
+  }
+
+  const dir = getConfigDir()
+  const installationId = crypto.randomUUID()
+  await fs.mkdir(dir, { recursive: true })
+  await fs.chmod(dir, 0o700)
+  await fs.writeFile(installationIdPath(), `${installationId}\n`, {
+    encoding: 'utf-8',
+    flag: 'wx',
+    mode: 0o600,
+  })
+  return installationId
+}
+
+export async function getCliSource(): Promise<NonNullable<MarketV1ClientOptions['source']>> {
+  const analyticsDisabled =
+    process.env.DO_NOT_TRACK === '1' || process.env.MARKET_TELEMETRY_DISABLED === '1'
+  return {
+    surface: 'cli',
+    distinctId: analyticsDisabled ? undefined : await getInstallationId(),
+    analyticsDisabled,
+  }
+}
+
+function isMissingFile(error: unknown): boolean {
+  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
+}

package/src/mcp/agent.ts

@@ -1,31 +1,15 @@
-import { agentStartSchema, agentStatusSchema } from '../schemas.js'
+import { agentStatusSchema } from '../schemas.js'
 import type { MarketV1Client } from '../v1/client.js'
 import { result } from './result.js'
 import type { MarketMcpServer } from './types.js'
 
 export function registerAgentTools(server: MarketMcpServer, client: MarketV1Client): void {
-  server.registerTool(
-    'start_market_agent_run',
-    {
-      title: 'Start Market agent run',
-      description:
-        'Start a Market agent run that plans, finds, judges, and generates a coherent set of assets for a goal.',
-      inputSchema: agentStartSchema,
-      annotations: {
-        readOnlyHint: false,
-        destructiveHint: false,
-        openWorldHint: true,
-        idempotentHint: false,
-      },
-    },
-    async (input) => result({ run: await client.asset.agent.start(input) }),
-  )
-
   server.registerTool(
     'get_market_agent_run',
     {
       title: 'Get Market agent run',
-      description: 'Get the current state and result of a Market agent run.',
+      description:
+        'Get the current state and result of an existing Market agent run. MCP cannot start agent runs until the Market API supports explicit output visibility.',
       inputSchema: agentStatusSchema,
       annotations: {
         readOnlyHint: true,

package/src/mcp/asset.ts

@@ -2,15 +2,23 @@ import { z } from 'zod'
 import { resolveAsset } from '../refs.js'
 import { assetTypeSchema } from '../schemas.js'
 import type { MarketV1Client } from '../v1/client.js'
+import type { AssetRefEntry } from '../v1/index.js'
 import { base64, result } from './result.js'
 import type { MarketMcpServer } from './types.js'
 
+const includeUnapprovedSchema = z
+  .boolean()
+  .default(false)
+  .describe(
+    'Include unapproved assets only when the user explicitly asks to inspect unmoderated content and accepts that it has not passed Market review.',
+  )
+
 const searchMarketSchema = z
   .object({
     query: z.string().min(1).max(200),
     type: assetTypeSchema,
     limit: z.coerce.number().int().min(1).max(5).default(3),
-    includeUnapproved: z.boolean().default(false),
+    includeUnapproved: includeUnapprovedSchema,
   })
   .strict()
 
@@ -18,8 +26,7 @@ const assetRefSchema = z.string().min(1).describe('Asset name or exact name@vers
 const assetInput = z
   .object({
     asset: assetRefSchema,
-    includeUnapproved: z.boolean().default(false),
-    key: z.string().min(1).max(128).optional(),
+    includeUnapproved: includeUnapprovedSchema,
   })
   .strict()
 
@@ -70,16 +77,20 @@ export function registerAssetTools(
         throw new Error('Market search unexpectedly returned an exact asset result')
       }
       return result({
-        assets: response.items.map((asset) => ({
-          asset: `${asset.name}@${asset.latestVersion}`,
-          name: asset.name,
-          version: asset.latestVersion,
-          type: asset.type,
-          description: asset.description,
-          approved: asset.approved,
-          access: asset.access,
-          previewUrl: asset.previewUrl,
-        })),
+        assets: response.items.map((asset) => {
+          const previewUrl = safePublicUrl(asset.previewUrl, asset)
+          return {
+            asset: `${asset.name}@${asset.latestVersion}`,
+            name: asset.name,
+            version: asset.latestVersion,
+            type: asset.type,
+            description: asset.description,
+            approved: asset.approved,
+            access: asset.access,
+            hasPreview: Boolean(asset.previewUrl),
+            ...(previewUrl ? { previewUrl } : {}),
+          }
+        }),
         total: response.total,
       })
     },
@@ -90,7 +101,7 @@ export function registerAssetTools(
     {
       title: 'Get Market asset',
       description:
-        'Get one exact Drawcall Market asset manifest with its version history, dependencies, files, preview URL, and zip URL.',
+        'Get one exact Drawcall Market asset manifest with its version history, dependencies, and file metadata. Capability-bearing URLs and owner identifiers are never returned.',
       inputSchema: assetInput,
       annotations: {
         readOnlyHint: true,
@@ -99,12 +110,9 @@ export function registerAssetTools(
         idempotentHint: true,
       },
     },
-    async ({ asset, includeUnapproved, key }) =>
+    async ({ asset, includeUnapproved }) =>
       result({
-        asset: await resolveAsset(client.asset, asset, {
-          includeUnapproved,
-          ...(key ? { key } : {}),
-        }),
+        asset: mcpAsset(await resolveAsset(client.asset, asset, { includeUnapproved })),
       }),
   )
 
@@ -112,7 +120,8 @@ export function registerAssetTools(
     'get_market_asset_preview',
     {
       title: 'Get Market asset preview',
-      description: 'Return the preview image for one exact Drawcall Market asset.',
+      description:
+        'Return the preview image for one exact Drawcall Market asset. The server fetches restricted previews without returning their capability-bearing URL.',
       inputSchema: assetInput,
       annotations: {
         readOnlyHint: true,
@@ -121,22 +130,17 @@ export function registerAssetTools(
         idempotentHint: true,
       },
     },
-    async ({ asset: ref, includeUnapproved, key }) => {
-      const asset = await resolveAsset(client.asset, ref, {
-        includeUnapproved,
-        ...(key ? { key } : {}),
-      })
+    async ({ asset: ref, includeUnapproved }) => {
+      const asset = await resolveAsset(client.asset, ref, { includeUnapproved })
       if (!asset.previewUrl) throw new Error(`Asset "${ref}" has no preview image`)
 
-      const response = await fetcher(asset.previewUrl)
+      const response = await fetchPreview(fetcher, asset.previewUrl, ref)
       if (!response.ok) {
-        throw new Error(
-          `Could not read preview ${asset.previewUrl}: ${response.status} ${response.statusText}`,
-        )
+        throw new Error(`Could not read preview for "${ref}": ${response.status}`)
       }
       const mimeType = response.headers.get('content-type')?.split(';', 1)[0]
       if (!mimeType?.startsWith('image/')) {
-        throw new Error(`Preview ${asset.previewUrl} returned ${mimeType ?? 'no media type'}`)
+        throw new Error(`Preview for "${ref}" returned ${mimeType ?? 'no media type'}`)
       }
 
       return {
@@ -149,10 +153,61 @@ export function registerAssetTools(
         ],
         structuredContent: {
           asset: `${asset.name}@${asset.version}`,
-          url: asset.previewUrl,
           mediaType: mimeType,
         },
       }
     },
   )
 }
+
+function mcpAsset(asset: AssetRefEntry): Record<string, unknown> {
+  const publicAsset = asset.access === 'public' && asset.approved
+  const previewUrl = safePublicUrl(asset.previewUrl, asset)
+  const zipUrl = safePublicUrl(asset.zipUrl, asset)
+
+  return {
+    name: asset.name,
+    type: asset.type,
+    version: asset.version,
+    description: asset.description,
+    approved: asset.approved,
+    access: asset.access,
+    npmDependencies: asset.npmDependencies,
+    assetDependencies: asset.assetDependencies,
+    skillDependencies: asset.skillDependencies,
+    files: asset.files.map(({ url, ...file }) => {
+      const publicUrl = safePublicUrl(url, asset)
+      return publicUrl ? { ...file, url: publicUrl } : file
+    }),
+    hasPreview: Boolean(asset.previewUrl),
+    versions: asset.versions,
+    ...(previewUrl ? { previewUrl } : {}),
+    ...(zipUrl ? { zipUrl } : {}),
+    ...(!publicAsset ? { restrictedUrlsOmitted: true } : {}),
+  }
+}
+
+async function fetchPreview(
+  fetcher: typeof globalThis.fetch,
+  url: string,
+  ref: string,
+): Promise<Response> {
+  try {
+    return await fetcher(url)
+  } catch {
+    throw new Error(`Could not read preview for "${ref}"`)
+  }
+}
+
+function safePublicUrl(
+  url: string | null,
+  asset: Pick<AssetRefEntry, 'access' | 'approved'>,
+): string | undefined {
+  if (!url || asset.access !== 'public' || !asset.approved) return undefined
+  try {
+    const parsed = new URL(url)
+    return parsed.searchParams.has('key') ? undefined : parsed.href
+  } catch {
+    return undefined
+  }
+}

package/src/mcp/generation.ts

@@ -1,9 +1,32 @@
+import { z } from 'zod'
 import { assetTypeSchema, generateAssetSchema, generateStatusInputSchema } from '../schemas.js'
 import type { MarketV1Client } from '../v1/client.js'
 import { result } from './result.js'
 import type { MarketMcpServer } from './types.js'
 
-const generateMarketAssetSchema = generateAssetSchema.extend({ type: assetTypeSchema }).strict()
+const generationBaseSchema = generateAssetSchema
+  .omit({ access: true, type: true })
+  .extend({ type: assetTypeSchema })
+
+const generateMarketAssetSchema = z.discriminatedUnion('access', [
+  generationBaseSchema
+    .extend({
+      access: z
+        .literal('public')
+        .describe('Publish the generated asset to the public Market after its approval flow.'),
+      confirmPublicPublication: z
+        .literal(true)
+        .describe('Must be true only after the user explicitly approves public publication.'),
+    })
+    .strict(),
+  generationBaseSchema
+    .extend({
+      access: z
+        .literal('private')
+        .describe('Keep the generated asset private to the authenticated owner.'),
+    })
+    .strict(),
+])
 
 export function registerGenerationTools(server: MarketMcpServer, client: MarketV1Client): void {
   server.registerTool(
@@ -11,7 +34,7 @@ export function registerGenerationTools(server: MarketMcpServer, client: MarketV
     {
       title: 'Generate Market asset',
       description:
-        'Generate one Drawcall Market asset. A slow provider returns a jobId to pass to get_market_asset_generation.',
+        'Create one external Drawcall Market asset. Visibility is required; public publication is allowed only after explicit user consent. A slow provider returns a jobId to pass to get_market_asset_generation.',
       inputSchema: generateMarketAssetSchema,
       annotations: {
         readOnlyHint: false,
@@ -20,7 +43,13 @@ export function registerGenerationTools(server: MarketMcpServer, client: MarketV
         idempotentHint: false,
       },
     },
-    async (input) => result({ generation: await client.asset.generate(input) }),
+    async (input) => {
+      if (input.access === 'public') {
+        const { confirmPublicPublication: _confirmed, ...generation } = input
+        return result({ generation: await client.asset.generate(generation) })
+      }
+      return result({ generation: await client.asset.generate(input) })
+    },
   )
 
   server.registerTool(

package/src/output.ts

@@ -189,7 +189,7 @@ export function generationRunningResult(jobId: string): string {
 }
 
 function generationInstallCommand(jobId: string): string {
-  return `npx @drawcall/market@latest generate install ${jobId} --cwd "$PWD"`
+  return `npx drawcall market generate install ${jobId} --cwd "$PWD"`
 }
 
 export function uploadResult(name: string, version: string): string {

package/src/pack.ts

@@ -616,7 +616,7 @@ export interface AssetDependencySync {
 
 /**
  * Update the aliases in package.json `assetDependencies` to match where each dependency's files
- * currently live — the standalone form of what pack does before omitting (`market sync`). Renamed
+ * currently live — the standalone form of what pack does before omitting (`npx drawcall market sync`). Renamed
  * files gain an alias, files back at their canonical path lose theirs, and dependencies whose
  * manifest cannot be fetched are reported as skipped rather than blindly rewritten.
  */