@wji.ai/cli 0.1.0

package/dist/commands/asset.js

@@ -0,0 +1,241 @@
+import { createWriteStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { Command } from 'commander';
+import { ASSET_BATCH_MAX_IDS, WjiClient, isObjectId } from '../core/client.js';
+import { confirm } from '../core/prompt.js';
+import { color, detail, info, isJsonMode, printJson, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
+const STATE = { 0: 'pending', 1: 'ready', [-1]: 'cancelled' };
+/** The server rejects the whole batch if any id is malformed — fail fast and say which. */
+function assertAssetIds(ids) {
+    const bad = ids.filter((id) => !isObjectId(id));
+    if (bad.length)
+        throw new Error(`Not asset ids (expected 24-char ObjectIds): ${bad.join(', ')}`);
+}
+function humanSize(bytes) {
+    if (bytes == null)
+        return null;
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value.toFixed(unit === 0 ? 0 : 1)}${units[unit]}`;
+}
+export function assetCommand(globals) {
+    const asset = new Command('asset').description('Upload and manage assets');
+    asset
+        .command('upload <file...>')
+        .description('Upload one or more local files')
+        .option('-w, --workspace <id>', 'attach to a workspace')
+        .option('--store <id>', 'vector store id')
+        .option('--vectorize', 'index the file for retrieval')
+        .option('--width <n>', 'source width hint')
+        .option('--height <n>', 'source height hint')
+        .option('--duration <n>', 'media duration hint in seconds')
+        .action(async (files, opts) => {
+        const client = new WjiClient(globals());
+        const workspace = client.workspace(opts.workspace);
+        const uploaded = [];
+        for (const file of files) {
+            const size = (await stat(file)).size;
+            info(color.dim(`Uploading ${basename(file)} (${humanSize(size)})…`));
+            const result = await client.upload('/assets/v2/upload', file, {
+                workspace,
+                store: opts.store,
+                vectorize: opts.vectorize ? 'true' : undefined,
+                width: opts.width,
+                height: opts.height,
+                duration: opts.duration,
+            });
+            uploaded.push(result);
+            if (!isJsonMode())
+                success(`${basename(file)} → ${result.id}`);
+        }
+        if (isJsonMode())
+            render(files.length === 1 ? uploaded[0] : uploaded, () => { });
+    });
+    asset
+        .command('import <url>')
+        .description('Import an asset from a URL')
+        .option('-w, --workspace <id>', 'attach to a workspace')
+        .option('-n, --name <name>', 'asset name')
+        .option('--type <type>', 'asset type override')
+        .option('--raw', 'use /assets/import-from-url instead of create-from-url')
+        .action(async (url, opts) => {
+        const client = new WjiClient(globals());
+        const created = opts.raw
+            ? await client.post('/assets/import-from-url', { url })
+            : await client.post('/assets/create-from-url', {
+                url,
+                workspace: client.workspace(opts.workspace),
+                name: opts.name,
+                type: opts.type,
+            });
+        render(created, (a) => success(`Imported ${a.id}`));
+    });
+    asset
+        .command('list')
+        .description('Search your assets')
+        .option('--store <id>', 'filter by vector store')
+        .option('--page <n>', 'page number', '1')
+        .option('--limit <n>', 'page size', '20')
+        .action(async (opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.get('/assets/search', {
+            store: opts.store,
+            page: Number(opts.page),
+            limit: Number(opts.limit),
+        });
+        render(result, (r) => {
+            table(r.data || [], [
+                { header: 'id', value: (a) => a.id },
+                { header: 'type', value: (a) => a.type },
+                { header: 'name', value: (a) => truncate(a.name, 30) },
+                { header: 'size', value: (a) => humanSize(a.size) },
+                { header: 'state', value: (a) => STATE[a.status] ?? a.status },
+                { header: 'created', value: (a) => relativeTime(a.createdAt) },
+            ]);
+            info(color.dim(`${r.pagination?.total ?? 0} total`));
+        });
+    });
+    asset
+        .command('get <id>')
+        .description('Show one asset')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const a = await client.get(`/assets/list/${id}`);
+        render(a, () => printAsset(a));
+    });
+    asset
+        .command('status <ids...>')
+        .description(`Check processing state of several assets (sent ${ASSET_BATCH_MAX_IDS} per request)`)
+        .action(async (ids) => {
+        assertAssetIds(ids);
+        const unique = [...new Set(ids)];
+        const client = new WjiClient(globals());
+        const rows = await client.checkAssetStatus(unique);
+        render(rows, (list) => {
+            table(list || [], [
+                { header: 'id', value: (a) => a.id },
+                { header: 'state', value: (a) => STATE[a.status] ?? a.status },
+                { header: 'error', value: (a) => truncate(a.error?.message || a.error, 40) },
+                { header: 'url', value: (a) => truncate(a.url, 50) },
+            ]);
+            // The server silently drops ids you may not read instead of erroring.
+            const missing = unique.length - (list?.length ?? 0);
+            if (missing > 0) {
+                warn(`${missing} id(s) not returned: not found, or neither yours nor in a workspace you belong to`);
+            }
+        });
+    });
+    asset
+        .command('update <id>')
+        .description('Rename or retag an asset')
+        .option('-n, --name <name>', 'new name')
+        .option('--tags <tag...>', 'replace tags')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const updated = await client.patch(`/assets/list/${id}`, {
+            name: opts.name,
+            tags: opts.tags,
+        });
+        render(updated, () => success(`Updated ${id}`));
+    });
+    asset
+        .command('rm <id>')
+        .description('Delete an asset')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        if (!(await confirm(`Delete asset ${id}?`, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.delete(`/assets/list/${id}`);
+        render(result, () => success(`Deleted ${id}`));
+    });
+    asset
+        .command('download <ids...>')
+        .description('Download assets to disk (a directory keeps each asset name plus its file extension)')
+        .option('-o, --out <path>', 'output file (one id) or directory', '.')
+        .action(async (ids, opts) => {
+        const client = new WjiClient(globals());
+        const isDir = await stat(opts.out).then((s) => s.isDirectory()).catch(() => false);
+        if (ids.length > 1 && !isDir)
+            throw new Error('With several ids, --out must be an existing directory');
+        const saved = [];
+        for (const id of ids) {
+            const a = await client.get(`/assets/list/${id}`);
+            if (!a?.url)
+                throw new Error(`Asset ${id} has no URL yet (state: ${STATE[a?.status] ?? a?.status})`);
+            const res = await fetch(a.url);
+            if (!res.ok || !res.body)
+                throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+            let target = opts.out;
+            if (isDir) {
+                // Asset names are titles ("boat"), not file names: keep the extension so
+                // image viewers and agents can open the file.
+                const base = String(a.name || id).replace(/[\\/]/g, '_');
+                target = join(opts.out, /\.[a-z0-9]{2,5}$/i.test(base) ? base : `${base}${extensionOf(a.url)}`);
+            }
+            await pipeline(Readable.fromWeb(res.body), createWriteStream(target));
+            saved.push({ id, path: target });
+            if (!isJsonMode())
+                success(`Saved ${target}`);
+        }
+        if (isJsonMode())
+            printJson(ids.length === 1 ? saved[0] : saved);
+    });
+    asset
+        .command('resolve <url>')
+        .description('Find an existing asset by its URL')
+        .option('-w, --workspace <id>', 'workspace scope')
+        .action(async (url, opts) => {
+        const client = new WjiClient(globals());
+        const a = await client.get('/assets/resolve-by-url', {
+            url,
+            workspace: client.workspace(opts.workspace),
+        });
+        render(a, (found) => (found ? printAsset(found) : info('No matching asset')));
+    });
+    asset
+        .command('summary <id...>')
+        .description(`Generate AI summaries for your own assets (at most ${ASSET_BATCH_MAX_IDS} per call)`)
+        .action(async (ids) => {
+        assertAssetIds(ids);
+        // Not batched automatically: every id is a separate vectorize + LLM job.
+        if (ids.length > ASSET_BATCH_MAX_IDS) {
+            throw new Error(`asset summary takes at most ${ASSET_BATCH_MAX_IDS} ids per call`);
+        }
+        const client = new WjiClient(globals());
+        const result = ids.length === 1
+            ? await client.post(`/assets/list/${ids[0]}/summary`)
+            : await client.post('/assets/summary/batch', { ids });
+        render(result, (r) => detail(Object.entries(r || {})));
+    });
+    return asset;
+}
+function extensionOf(url) {
+    const match = /\.([a-z0-9]{2,5})(?:\?|$)/i.exec(url);
+    return match ? `.${match[1]}` : '';
+}
+function printAsset(a) {
+    detail([
+        ['id', a.id],
+        ['name', a.name],
+        ['type', a.type],
+        ['mimetype', a.mimetype],
+        ['state', STATE[a.status] ?? a.status],
+        ['size', humanSize(a.size)],
+        ['aspectRatio', a.aspectRatio],
+        ['duration', a.duration],
+        ['url', a.url],
+        ['thumbnail', a.thumbnail],
+        ['tags', (a.tags || []).join(', ')],
+        ['error', a.error?.message || a.error],
+        ['createdAt', a.createdAt],
+    ]);
+}

package/dist/commands/auth.js

@@ -0,0 +1,216 @@
+import { Command } from 'commander';
+import { ApiError, WjiClient } from '../core/client.js';
+import { getProfile, updateProfile } from '../core/config.js';
+import { askSecret, ask, confirm } from '../core/prompt.js';
+import { color, detail, info, isJsonMode, printJson, relativeTime, render, success, table, warn } from '../core/output.js';
+export function authCommand(globals) {
+    const auth = new Command('auth').description('Sign in and manage credentials');
+    auth
+        .command('login')
+        .description('Sign in with email + password and store the tokens')
+        .option('-e, --email <email>', 'account email')
+        .option('-p, --password <password>', 'account password (prompted when omitted)')
+        .action(async (opts) => {
+        const g = globals();
+        const client = new WjiClient(g);
+        const email = opts.email || (await ask('Email: '));
+        const password = opts.password || (await askSecret('Password: '));
+        const result = await client.request('POST', '/auth/signin', {
+            body: { email, password },
+            anonymous: true,
+        });
+        updateProfile(g.profile, {
+            endpoint: client.endpoint,
+            accessToken: result.tokens.accessToken,
+            refreshToken: result.tokens.refreshToken,
+            userId: result.user.id,
+            email: result.user.email,
+            name: result.user.name,
+        });
+        if (isJsonMode())
+            return printJson(result);
+        success(`Signed in as ${result.user.name || result.user.email} (profile: ${client.profileName})`);
+        info(color.dim(`Endpoint ${client.endpoint} · balance ${result.user.balance ?? '-'}`));
+    });
+    auth
+        .command('signup')
+        .description('Register a new account (needs an email verification code)')
+        .requiredOption('-e, --email <email>', 'account email')
+        .requiredOption('-n, --name <name>', 'display name')
+        .requiredOption('-c, --code <code>', 'email verification code')
+        .option('-p, --password <password>', 'password (prompted when omitted)')
+        .action(async (opts) => {
+        const g = globals();
+        const client = new WjiClient(g);
+        const password = opts.password || (await askSecret('Password: '));
+        const result = await client.request('POST', '/auth/signup', {
+            body: { email: opts.email, name: opts.name, code: opts.code, password },
+            anonymous: true,
+        });
+        updateProfile(g.profile, {
+            endpoint: client.endpoint,
+            accessToken: result.tokens.accessToken,
+            refreshToken: result.tokens.refreshToken,
+            userId: result.user.id,
+            email: result.user.email,
+            name: result.user.name,
+        });
+        render(result, () => success(`Registered and signed in as ${result.user.email}`));
+    });
+    auth
+        .command('token')
+        .description('Print the active bearer token (use for scripting)')
+        .action(() => {
+        const client = new WjiClient(globals());
+        process.stdout.write(client.requireToken() + '\n');
+    });
+    auth
+        .command('whoami')
+        .description('Show the signed-in account')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        const me = await client.get('/user/me');
+        render(me, (u) => detail([
+            ['id', u.id],
+            ['name', u.name],
+            ['email', u.email],
+            ['balance', u.balance],
+            ['vip', u.vip?.level],
+            ['endpoint', client.endpoint],
+            ['org', client.orgId || 'personal'],
+            ['profile', client.profileName],
+            ['credential', client.usingApiKey ? 'api key' : 'jwt'],
+        ]));
+    });
+    auth
+        .command('refresh')
+        .description('Exchange the stored refresh token for a fresh access token')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        // Goes through the same locked path as the automatic refresh, so a manual
+        // refresh can't race a parallel command into replaying the old token.
+        const profile = await client.refreshSession();
+        render({ accessToken: profile.accessToken, refreshToken: profile.refreshToken }, () => success('Access token refreshed'));
+    });
+    auth
+        .command('logout')
+        .description('Clear stored credentials for the current profile')
+        .action(async () => {
+        const g = globals();
+        const { profile } = getProfile(g.profile);
+        if (profile.refreshToken && profile.accessToken) {
+            // POST with the token in the body — `GET /auth/signout?rt=` is deprecated
+            // and put the refresh token into access logs.
+            const client = new WjiClient(g);
+            const signout = (refreshToken) => client.request('POST', '/auth/signout', { body: { refreshToken }, noRetry: true });
+            try {
+                try {
+                    await signout(profile.refreshToken);
+                }
+                catch (err) {
+                    // An expired access token: refreshing rotates the refresh token, so the
+                    // one to revoke is the new one — revoking the old one would be a no-op.
+                    if (!(err instanceof ApiError && err.status === 401))
+                        throw err;
+                    const rotated = await client.refreshSession();
+                    if (rotated.refreshToken)
+                        await signout(rotated.refreshToken);
+                }
+            }
+            catch {
+                // Server-side signout is best effort; local credentials still go.
+            }
+        }
+        updateProfile(g.profile, {
+            accessToken: undefined,
+            refreshToken: undefined,
+            apiKey: undefined,
+            userId: undefined,
+            email: undefined,
+            name: undefined,
+        });
+        success('Signed out');
+    });
+    // ── API keys ───────────────────────────────────────────────────────────────
+    const key = auth.command('key').description('Manage long-lived sk_ API keys');
+    key
+        .command('list')
+        .description('List your API keys')
+        .option('--limit <n>', 'page size', '20')
+        .action(async (opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.get('/api-key/search', { limit: Number(opts.limit) });
+        render(result, (r) => table(r.data || [], [
+            { header: 'id', value: (k) => k.id },
+            { header: 'name', value: (k) => k.name },
+            { header: 'prefix', value: (k) => k.keyPrefix },
+            { header: 'revoked', value: (k) => (k.revokedAt ? 'yes' : '') },
+            { header: 'last used', value: (k) => relativeTime(k.lastUsedAt) },
+            { header: 'created', value: (k) => relativeTime(k.createdAt) },
+        ]));
+    });
+    key
+        .command('create <name>')
+        .description('Create an API key; the secret is shown once')
+        .option('--expires <iso>', 'expiry date, e.g. 2027-01-01')
+        .option('--save', 'store the new key in this profile and use it for future calls')
+        .action(async (name, opts) => {
+        const g = globals();
+        const client = new WjiClient(g);
+        // The endpoint answers { apiKey, secret }; the plaintext secret is only ever
+        // returned here.
+        const created = await client.post('/api-key/create', {
+            name,
+            expiresAt: opts.expires ? new Date(opts.expires).toISOString() : undefined,
+        });
+        const secret = created.secret;
+        if (opts.save && secret)
+            updateProfile(g.profile, { apiKey: secret });
+        if (isJsonMode())
+            return printJson(created);
+        success(`Created API key "${name}" (${created.apiKey?.id ?? ''})`);
+        if (secret) {
+            process.stdout.write(secret + '\n');
+            info(color.dim('Store this now — it is not retrievable later.'));
+        }
+        else {
+            warn('The server did not return a secret.');
+        }
+        if (opts.save)
+            info(color.dim(`Saved to profile ${client.profileName}`));
+    });
+    key
+        .command('revoke <id>')
+        .description('Revoke an API key')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        const prompt = `Revoke API key ${id}? Anything still using it stops working immediately.`;
+        if (!(await confirm(prompt, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.post(`/api-key/list/${id}/revoke`);
+        render(result, () => success(`Revoked ${id}`));
+    });
+    key
+        .command('rm <id>')
+        .description('Delete an API key')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        if (!(await confirm(`Delete API key ${id}?`, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.delete(`/api-key/list/${id}`);
+        render(result, () => success(`Deleted ${id}`));
+    });
+    key
+        .command('use <secret>')
+        .description('Store an existing sk_ key in this profile')
+        .action((secret) => {
+        const g = globals();
+        if (!secret.startsWith('sk_'))
+            throw new Error('An API key must start with sk_');
+        updateProfile(g.profile, { apiKey: secret });
+        success('API key saved');
+    });
+    return auth;
+}