@wji.ai/cli 0.7.0 → 0.7.1

package/dist/core/client.js

@@ -1,269 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { DEFAULT_ENDPOINT, acquireLock, getProfile, refreshLockPath, releaseLock, updateProfile, } from './config.js';
-/** Server cap on `ids` for `/assets/check-status`, `/assets/summary/batch` and friends. */
-export const ASSET_BATCH_MAX_IDS = 100;
-/**
- * Content types for multipart uploads. Some endpoints (Backreel private files)
- * accept a file by its declared type alone, and a bare Blob is sent as
- * application/octet-stream — which they reject as an unsupported type.
- */
-const MIME_TYPES = {
-    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif', avif: 'image/avif',
-    mp4: 'video/mp4', mov: 'video/quicktime', m4v: 'video/x-m4v', webm: 'video/webm',
-    mp3: 'audio/mpeg', wav: 'audio/wav', m4a: 'audio/mp4',
-    pdf: 'application/pdf', csv: 'text/csv', txt: 'text/plain', md: 'text/markdown', json: 'application/json', zip: 'application/zip',
-    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-};
-export const mimeTypeOf = (filename) => MIME_TYPES[filename.split('.').pop()?.toLowerCase() || ''] || 'application/octet-stream';
-export const isObjectId = (value) => /^[a-f0-9]{24}$/i.test(value);
-export class ApiError extends Error {
-    status;
-    path;
-    body;
-    constructor(message, status, path, body) {
-        super(message);
-        this.status = status;
-        this.path = path;
-        this.body = body;
-        this.name = 'ApiError';
-    }
-}
-/**
- * Mirrors the backend's `qs` parser (allowDots + bracket arrays), so nested
- * search filters like `sort.createdAt=-1` survive the round trip.
- */
-export function serializeQuery(params, prefix = '') {
-    const out = [];
-    for (const [rawKey, value] of Object.entries(params)) {
-        if (value === undefined || value === null)
-            continue;
-        const key = prefix ? `${prefix}.${rawKey}` : rawKey;
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item === undefined || item === null)
-                    continue;
-                out.push(`${encodeURIComponent(key + '[]')}=${encodeURIComponent(String(item))}`);
-            }
-        }
-        else if (typeof value === 'object') {
-            out.push(...serializeQuery(value, key));
-        }
-        else {
-            out.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
-        }
-    }
-    return out;
-}
-export class WjiClient {
-    globals;
-    profileName;
-    profile;
-    constructor(globals = {}) {
-        this.globals = globals;
-        const { name, profile } = getProfile(globals.profile);
-        this.profileName = name;
-        this.profile = profile;
-    }
-    get endpoint() {
-        const raw = this.globals.endpoint ||
-            process.env.WJI_ENDPOINT ||
-            this.profile.endpoint ||
-            DEFAULT_ENDPOINT;
-        return raw.replace(/\/+$/, '');
-    }
-    get orgId() {
-        if (this.globals.personal)
-            return undefined;
-        return this.globals.org || process.env.WJI_ORG_ID || this.profile.orgId || undefined;
-    }
-    get token() {
-        return (this.globals.token ||
-            process.env.WJI_TOKEN ||
-            process.env.WJI_API_KEY ||
-            this.profile.apiKey ||
-            this.profile.accessToken);
-    }
-    /** True when the active credential is a long-lived `sk_` key (never refreshed). */
-    get usingApiKey() {
-        return !!this.token?.startsWith('sk_');
-    }
-    requireToken() {
-        const token = this.token;
-        if (!token) {
-            throw new Error('Not authenticated. Run `wji auth login` or set WJI_TOKEN.');
-        }
-        return token;
-    }
-    headers(opts) {
-        const headers = {
-            Accept: 'application/json',
-            'X-Locale': this.globals.locale || process.env.WJI_LOCALE || this.profile.locale || 'cht',
-        };
-        if (!opts.anonymous)
-            headers.Authorization = `Bearer ${this.requireToken()}`;
-        const org = this.orgId;
-        if (org)
-            headers['X-Org-Id'] = org;
-        if (this.globals.app)
-            headers['X-App'] = this.globals.app;
-        return headers;
-    }
-    async request(method, path, opts = {}) {
-        const query = opts.query ? serializeQuery(opts.query) : [];
-        const url = `${this.endpoint}${path.startsWith('/') ? path : `/${path}`}${query.length ? `?${query.join('&')}` : ''}`;
-        const headers = this.headers(opts);
-        let payload;
-        if (opts.form) {
-            payload = opts.form;
-        }
-        else if (opts.body !== undefined) {
-            headers['Content-Type'] = 'application/json';
-            payload = JSON.stringify(opts.body);
-        }
-        const res = await fetch(url, { method, headers, body: payload });
-        if (res.status === 401 && !opts.noRetry && !opts.anonymous && !this.usingApiKey) {
-            if (await this.tryRefresh()) {
-                return this.request(method, path, { ...opts, noRetry: true });
-            }
-        }
-        const text = await res.text();
-        let parsed = undefined;
-        let isJson = false;
-        if (text) {
-            try {
-                parsed = JSON.parse(text);
-                isJson = true;
-            }
-            catch {
-                parsed = text;
-            }
-        }
-        // A non-JSON 200 almost always means the endpoint points at something that
-        // is not the API (the Nuxt frontend, a proxy, a captive portal).
-        if (res.ok && text && !isJson) {
-            throw new ApiError(`Expected JSON from ${this.endpoint} but got ${res.headers.get('content-type') || 'an unknown content type'}. Is --endpoint pointing at the API and not the web app?`, res.status, path, typeof parsed === 'string' ? parsed.slice(0, 200) : parsed);
-        }
-        if (!res.ok) {
-            const body = parsed;
-            let message = typeof body === 'string'
-                ? body
-                : Array.isArray(body?.message)
-                    ? String(body?.message[0])
-                    : typeof body?.message === 'string'
-                        ? body.message
-                        : res.statusText;
-            if (res.status === 401)
-                message = `${message} (token expired or invalid — run \`wji auth login\`)`;
-            throw new ApiError(message, res.status, path, parsed);
-        }
-        return parsed;
-    }
-    get(path, query) {
-        return this.request('GET', path, { query });
-    }
-    /**
-     * Several GETs are wrapped in a 10s server-side cache keyed on the full URL,
-     * so a read taken right after a write can be stale. Use this whenever a
-     * subsequent write depends on what comes back.
-     */
-    getFresh(path, query) {
-        return this.request('GET', path, { query: { ...query, _: Date.now() } });
-    }
-    post(path, body, query) {
-        return this.request('POST', path, { body, query });
-    }
-    put(path, body) {
-        return this.request('PUT', path, { body });
-    }
-    patch(path, body) {
-        return this.request('PATCH', path, { body });
-    }
-    delete(path, query) {
-        return this.request('DELETE', path, { query });
-    }
-    /** Multipart upload of a local file — Node's built-in FormData/Blob, no extra dependency. */
-    async upload(path, file, fields) {
-        const buffer = await readFile(file);
-        return this.uploadBuffer(path, buffer, basename(file), fields);
-    }
-    /** Multipart upload of an in-memory buffer (e.g. a zip built on the fly). */
-    async uploadBuffer(path, buffer, filename, fields = {}, field = 'file') {
-        const form = new FormData();
-        form.append(field, new Blob([new Uint8Array(buffer)], { type: mimeTypeOf(filename) }), filename);
-        for (const [key, value] of Object.entries(fields)) {
-            if (value !== undefined && value !== null && value !== '')
-                form.append(key, value);
-        }
-        return this.request('POST', path, { form });
-    }
-    /** `POST /assets/check-status` accepts at most 100 ids, so larger lists are batched. */
-    async checkAssetStatus(ids) {
-        const out = [];
-        for (let i = 0; i < ids.length; i += ASSET_BATCH_MAX_IDS) {
-            const rows = await this.post('/assets/check-status', {
-                ids: ids.slice(i, i + ASSET_BATCH_MAX_IDS),
-            });
-            if (Array.isArray(rows))
-                out.push(...rows);
-        }
-        return out;
-    }
-    /**
-     * Rotate the stored JWT pair.
-     *
-     * The backend treats a refresh token presented twice as stolen and revokes
-     * every session of that user. Parallel `wji` processes (an agent running
-     * several commands) can all hit a 401 at the same moment, so refreshes are
-     * serialized with a lock file and each process re-reads the config under the
-     * lock: if another process already rotated the pair, it adopts that pair
-     * instead of replaying the now-dead refresh token.
-     */
-    async refreshSession() {
-        const stale = this.profile.accessToken;
-        const lock = refreshLockPath(this.profileName);
-        const locked = await acquireLock(lock);
-        try {
-            const latest = getProfile(this.globals.profile).profile;
-            if (latest.accessToken && latest.accessToken !== stale) {
-                this.profile = latest;
-                return latest;
-            }
-            if (!latest.refreshToken) {
-                throw new Error('No refresh token stored. Run `wji auth login`.');
-            }
-            const result = await this.request('POST', '/auth/refresh', { body: { refreshToken: latest.refreshToken }, anonymous: true, noRetry: true });
-            this.profile = updateProfile(this.globals.profile, {
-                accessToken: result.tokens.accessToken,
-                refreshToken: result.tokens.refreshToken || latest.refreshToken,
-            });
-            return this.profile;
-        }
-        finally {
-            if (locked)
-                releaseLock(lock);
-        }
-    }
-    async tryRefresh() {
-        try {
-            await this.refreshSession();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Resolve `--workspace` with a fallback to the profile default. */
-    workspace(explicit) {
-        return explicit || process.env.WJI_WORKSPACE || this.profile.workspace || undefined;
-    }
-    requireWorkspace(explicit) {
-        const id = this.workspace(explicit);
-        if (!id) {
-            throw new Error('No workspace. Pass --workspace <id> or set a default with `wji ws use <id>`.');
-        }
-        return id;
-    }
-}

package/dist/core/config.js

@@ -1,95 +0,0 @@
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-export const DEFAULT_ENDPOINT = 'https://api.wji.ai';
-const EMPTY = { current: 'default', profiles: { default: {} } };
-export function configDir() {
-    return process.env.WJI_CONFIG_DIR || join(homedir(), '.wji');
-}
-export function configPath() {
-    return process.env.WJI_CONFIG_FILE || join(configDir(), 'config.json');
-}
-export function readConfig() {
-    const path = configPath();
-    if (!existsSync(path))
-        return structuredClone(EMPTY);
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        if (!parsed.profiles)
-            parsed.profiles = {};
-        if (!parsed.current)
-            parsed.current = 'default';
-        if (!parsed.profiles[parsed.current])
-            parsed.profiles[parsed.current] = {};
-        return parsed;
-    }
-    catch {
-        throw new Error(`Config file is not valid JSON: ${path}`);
-    }
-}
-export function writeConfig(config) {
-    const path = configPath();
-    mkdirSync(dirname(path), { recursive: true });
-    // Write-then-rename so a concurrent reader never sees a half-written file:
-    // several wji processes can rotate tokens at the same moment.
-    const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
-    // The file holds bearer tokens — keep it owner-only even if it pre-existed.
-    chmodSync(tmp, 0o600);
-    renameSync(tmp, path);
-}
-export function getProfile(name) {
-    const config = readConfig();
-    const key = name || process.env.WJI_PROFILE || config.current || 'default';
-    return { name: key, profile: config.profiles[key] || {} };
-}
-export function updateProfile(name, patch) {
-    const config = readConfig();
-    const key = name || process.env.WJI_PROFILE || config.current || 'default';
-    config.profiles[key] = { ...(config.profiles[key] || {}), ...patch };
-    for (const [k, v] of Object.entries(patch)) {
-        if (v === undefined)
-            delete config.profiles[key][k];
-    }
-    writeConfig(config);
-    return config.profiles[key];
-}
-/** A lock older than this belongs to a process that died mid-refresh. */
-const LOCK_STALE_MS = 30_000;
-export function refreshLockPath(profile) {
-    return join(dirname(configPath()), `.refresh-${profile.replace(/[^\w.-]/g, '_')}.lock`);
-}
-/**
- * Take an exclusive lock file (`O_EXCL`). Waits for a live holder and breaks a
- * stale one. Returns false only if the lock could not be taken in time, in
- * which case the caller proceeds unlocked rather than failing the command.
- */
-export async function acquireLock(path, timeoutMs = LOCK_STALE_MS + 5_000) {
-    mkdirSync(dirname(path), { recursive: true });
-    const deadline = Date.now() + timeoutMs;
-    for (;;) {
-        try {
-            closeSync(openSync(path, 'wx', 0o600));
-            return true;
-        }
-        catch (err) {
-            if (err.code !== 'EEXIST')
-                return false;
-        }
-        try {
-            if (Date.now() - statSync(path).mtimeMs > LOCK_STALE_MS) {
-                rmSync(path, { force: true });
-                continue;
-            }
-        }
-        catch {
-            continue; // released between our open and stat
-        }
-        if (Date.now() > deadline)
-            return false;
-        await new Promise((r) => setTimeout(r, 100));
-    }
-}
-export function releaseLock(path) {
-    rmSync(path, { force: true });
-}