@wji.ai/cli 0.1.0

package/dist/commands/workspace.js

@@ -0,0 +1,305 @@
+import { Command } from 'commander';
+import { WjiClient } from '../core/client.js';
+import { updateProfile } from '../core/config.js';
+import { confirm, parseKeyValues } from '../core/prompt.js';
+import { color, detail, info, relativeTime, render, success, table, truncate } from '../core/output.js';
+/** App tokens accepted by `--app`; mirrors WorkspaceApplication on the backend. */
+const APPS = {
+    dataset: 'Dataset',
+    datasetimagegeneration: 'DatasetImageGeneration',
+    infinitecanvas: 'InfiniteCanvas',
+    canvas: 'InfiniteCanvas',
+    document: 'Document',
+    draw: 'Draw',
+    files: 'Files',
+    playscript: 'PlayScript',
+    batch: 'Batch',
+    digitalhost: 'DigitalHost',
+};
+const APP_TYPES = {
+    Dataset: 'DATASET',
+    DatasetImageGeneration: 'DATASET_IMAGE_GENERATION',
+    InfiniteCanvas: 'INFINITE_CANVAS',
+    Document: 'DOCUMENT',
+    Draw: 'DRAW',
+    Files: 'FILES',
+    PlayScript: 'PLAYSCRIPT',
+    Batch: 'BATCH',
+    DigitalHost: 'DIGITAL_HOST',
+};
+function resolveApp(token) {
+    const app = APPS[token.toLowerCase().replace(/[-_\s]/g, '')];
+    if (!app) {
+        throw new Error(`Unknown app "${token}". Known: ${Object.keys(APPS).sort().join(', ')}`);
+    }
+    return { app, type: APP_TYPES[app] };
+}
+export function workspaceCommand(globals) {
+    const ws = new Command('ws')
+        .aliases(['workspace'])
+        .description('Manage workspaces');
+    ws.command('list', { isDefault: true })
+        .description('List workspaces you can access')
+        .option('-k, --keyword <text>', 'match name or description')
+        .option('-s, --scope <scope>', 'all | me | shared | favorite', 'all')
+        .option('--page <n>', 'page number', '1')
+        .option('--limit <n>', 'page size (max 100; -1 returns at most 500)', '20')
+        .action(async (opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.get('/workspace/search', {
+            keyword: opts.keyword,
+            scope: opts.scope,
+            page: Number(opts.page),
+            limit: Number(opts.limit),
+        });
+        const current = client.workspace();
+        render(result, (r) => {
+            table(r.data || [], [
+                { header: '', value: (w) => (w.id === current ? color.green('*') : ' ') },
+                { header: 'id', value: (w) => w.id },
+                { header: 'name', value: (w) => truncate(w.name, 32) },
+                { header: 'type', value: (w) => w.workspaceType },
+                { header: 'ratio', value: (w) => w.aspectRatio },
+                { header: 'fav', value: (w) => (w.favoritedByMe ? '★' : '') },
+                { header: 'updated', value: (w) => relativeTime(w.updatedAt) },
+            ]);
+            info(color.dim(`${r.pagination?.total ?? 0} total · page ${r.pagination?.page}`));
+            // The server clamps page size, so "everything" may still span pages.
+            if (r.pagination?.hasNext) {
+                info(color.dim(`more: --page ${Number(r.pagination.page) + 1}`));
+            }
+        });
+    });
+    ws.command('get [id]')
+        .description('Show a workspace (defaults to the selected one)')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const w = await client.get(`/workspace/list/${client.requireWorkspace(id)}`);
+        render(w, () => detail([
+            ['id', w.id],
+            ['name', w.name],
+            ['description', w.description],
+            ['type', w.workspaceType],
+            ['aspectRatio', w.aspectRatio],
+            ['language', w.language],
+            ['uiVersion', w.uiVersion],
+            ['organization', w.organization?.id || w.organization || 'personal'],
+            ['deductionMode', w.deductionMode],
+            ['apps', (w.apps || []).map((a) => `${a.app}(${a.id})`).join(', ')],
+            ['createdAt', w.createdAt],
+        ]));
+    });
+    ws.command('use <id>')
+        .description('Set the default workspace for this profile')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const w = await client.get(`/workspace/list/${id}/basic`);
+        updateProfile(globals().profile, { workspace: id });
+        success(`Default workspace: ${w.name} (${id})`);
+    });
+    ws.command('create <name>')
+        .description('Create a workspace')
+        .option('-d, --description <text>', 'description')
+        .option('-r, --aspect-ratio <ratio>', '16:9 | 9:16 | 21:9', '16:9')
+        .option('-l, --language <lang>', 'dialogue language', 'auto')
+        .option('-t, --type <type>', 'workspaceType')
+        .option('-a, --app <app...>', 'apps to create, e.g. dataset files canvas')
+        .action(async (name, opts) => {
+        const client = new WjiClient(globals());
+        const apps = (opts.app || []).map((token) => {
+            const { app, type } = resolveApp(token);
+            return { app, type, name: app };
+        });
+        const created = await client.post('/workspace/create', {
+            name,
+            description: opts.description,
+            aspectRatio: opts.aspectRatio,
+            language: opts.language,
+            workspaceType: opts.type,
+            apps: apps.length ? apps : undefined,
+        });
+        render(created, (w) => success(`Created workspace ${w.name} (${w.id})`));
+    });
+    ws.command('update [id]')
+        .description('Update workspace fields')
+        .option('-n, --name <name>', 'new name')
+        .option('-d, --description <text>', 'new description')
+        .option('-r, --aspect-ratio <ratio>', 'new aspect ratio')
+        .option('-l, --language <lang>', 'new language')
+        .option('--set <key=value...>', 'arbitrary field, dotted keys allowed')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const body = {
+            name: opts.name,
+            description: opts.description,
+            aspectRatio: opts.aspectRatio,
+            language: opts.language,
+            ...parseKeyValues(opts.set),
+        };
+        const updated = await client.put(`/workspace/list/${client.requireWorkspace(id)}`, body);
+        render(updated, () => success('Workspace updated'));
+    });
+    ws.command('rm <id>')
+        .description('Delete a workspace (owner only)')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const w = await client.get(`/workspace/list/${id}/basic`).catch(() => ({ name: id }));
+        if (!(await confirm(`Delete workspace "${w.name}" (${id})?`, opts.yes))) {
+            return info('Aborted');
+        }
+        const result = await client.delete(`/workspace/list/${id}`);
+        render(result, () => success(`Deleted ${id}`));
+    });
+    ws.command('favorite <id>')
+        .description('Favorite or unfavorite a workspace')
+        .option('--off', 'remove from favorites')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.put(`/workspace/list/${id}/favorite`, { favorite: !opts.off });
+        render(result, () => success(opts.off ? 'Removed from favorites' : 'Favorited'));
+    });
+    ws.command('fs [id]')
+        .description('Show the workspace file tree (optionally for one app)')
+        .option('-a, --app <appId>', 'workspace app id to scope the tree')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const wsId = client.requireWorkspace(id);
+        const path = opts.app
+            ? `/workspace/list/${wsId}/fs/${opts.app}`
+            : `/workspace/list/${wsId}/fs`;
+        const root = await client.get(path);
+        render(root, (node) => printTree(node));
+    });
+    // ── apps ───────────────────────────────────────────────────────────────────
+    const apps = ws.command('app').description('Manage workspace apps');
+    apps
+        .command('list [id]')
+        .description('List apps in a workspace')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const w = await client.get(`/workspace/list/${client.requireWorkspace(id)}`);
+        render(w.apps || [], (rows) => table(rows, [
+            { header: 'id', value: (a) => a.id },
+            { header: 'app', value: (a) => a.app },
+            { header: 'type', value: (a) => a.type },
+            { header: 'name', value: (a) => a.name },
+        ]));
+    });
+    apps
+        .command('add <app> [id]')
+        .description('Add an app (dataset, files, canvas, document, draw, …)')
+        .option('-n, --name <name>', 'display name')
+        .action(async (app, id, opts) => {
+        const client = new WjiClient(globals());
+        const resolved = resolveApp(app);
+        const created = await client.post(`/workspace/list/${client.requireWorkspace(id)}/apps`, { app: resolved.app, type: resolved.type, name: opts.name || resolved.app });
+        render(created, (a) => success(`Added ${a.app} (${a.id})`));
+    });
+    apps
+        .command('rm <appId> [id]')
+        .description('Remove an app from a workspace')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (appId, id, opts) => {
+        if (!(await confirm(`Remove app ${appId}?`, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.delete(`/workspace/list/${client.requireWorkspace(id)}/apps/${appId}`);
+        render(result, () => success(`Removed ${appId}`));
+    });
+    // ── members ────────────────────────────────────────────────────────────────
+    const members = ws.command('member').description('Manage workspace members');
+    members
+        .command('list [id]')
+        .description('List members')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const w = await client.get(`/workspace/list/${client.requireWorkspace(id)}`);
+        render(w.members || [], (rows) => table(rows, [
+            { header: 'memberId', value: (m) => m.id },
+            { header: 'user', value: (m) => m.user?.id || m.user },
+            { header: 'name', value: (m) => m.user?.name },
+            { header: 'role', value: (m) => m.role },
+        ]));
+    });
+    members
+        .command('add <userId> [id]')
+        .description('Add a member (editor by default)')
+        .option('-r, --role <role>', 'editor | viewer', 'editor')
+        .action(async (userId, id, opts) => {
+        const client = new WjiClient(globals());
+        const result = await client.post(`/workspace/list/${client.requireWorkspace(id)}/member/add`, { user: userId, role: opts.role });
+        render(result, () => success(`Added ${userId} as ${opts.role}`));
+    });
+    members
+        .command('role <memberId> <role> [id]')
+        .description('Change a member role')
+        .action(async (memberId, role, id) => {
+        const client = new WjiClient(globals());
+        const result = await client.put(`/workspace/list/${client.requireWorkspace(id)}/member/${memberId}/role`, { role });
+        render(result, () => success(`${memberId} is now ${role}`));
+    });
+    members
+        .command('rm <memberId> [id]')
+        .description('Remove a member')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (memberId, id, opts) => {
+        if (!(await confirm(`Remove member ${memberId}?`, opts.yes)))
+            return info('Aborted');
+        const client = new WjiClient(globals());
+        const result = await client.delete(`/workspace/list/${client.requireWorkspace(id)}/member/${memberId}`);
+        render(result, () => success(`Removed ${memberId}`));
+    });
+    // ── quota / stats ──────────────────────────────────────────────────────────
+    ws.command('quota [id]')
+        .description('Show credit quota usage')
+        .option('--set <key=value...>', 'update quota, e.g. monthlyLimit=1000')
+        .action(async (id, opts) => {
+        const client = new WjiClient(globals());
+        const wsId = client.requireWorkspace(id);
+        if (opts.set?.length) {
+            const updated = await client.put(`/workspace/list/${wsId}/quota`, parseKeyValues(opts.set));
+            return render(updated, () => success('Quota updated'));
+        }
+        const usage = await client.get(`/workspace/list/${wsId}/quota-usage`);
+        render(usage, (u) => detail(Object.entries(u)));
+    });
+    ws.command('stats [id]')
+        .description('Show workspace stats (owner only)')
+        .action(async (id) => {
+        const client = new WjiClient(globals());
+        const stats = await client.get(`/workspace/list/${client.requireWorkspace(id)}/stats`);
+        render(stats, (s) => detail(Object.entries(s)));
+    });
+    ws.command('templates')
+        .description('List workspace templates you can clone')
+        .action(async () => {
+        const client = new WjiClient(globals());
+        const templates = await client.get('/workspace/start/templates');
+        render(templates, (rows) => table(rows || [], [
+            { header: 'id', value: (t) => t.id },
+            { header: 'name', value: (t) => t.name },
+            { header: 'type', value: (t) => t.workspaceType },
+            { header: 'description', value: (t) => truncate(t.description, 40) },
+        ]));
+    });
+    ws.command('clone <templateId>')
+        .description('Create a workspace from a template')
+        .action(async (templateId) => {
+        const client = new WjiClient(globals());
+        const created = await client.post(`/workspace/create/${templateId}`);
+        render(created, (w) => success(`Created workspace ${w.name} (${w.id})`));
+    });
+    return ws;
+}
+export function printTree(node, prefix = '', connector = '') {
+    if (!node)
+        return;
+    const label = node.nickname ? `${node.name} ${color.dim(`(${node.nickname})`)}` : node.name;
+    const kind = node.type === 'folder' ? color.blue('/') : '';
+    process.stdout.write(`${prefix}${connector}${label}${kind} ${color.dim(node.id)}\n`);
+    const children = node.children || [];
+    // The root prints flush left; every level below it gets the box-drawing gutter.
+    const childPrefix = connector ? prefix + (connector === '└─ ' ? '   ' : '│  ') : prefix;
+    children.forEach((child, i) => printTree(child, childPrefix, i === children.length - 1 ? '└─ ' : '├─ '));
+}

package/dist/core/client.js

@@ -0,0 +1,252 @@
+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;
+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;
+        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)]), 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

@@ -0,0 +1,95 @@
+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 });
+}