@wji.ai/cli 0.1.0

package/dist/core/output.js

@@ -0,0 +1,143 @@
+const useColor = process.env.NO_COLOR == null && process.env.WJI_NO_COLOR == null && process.stdout.isTTY;
+const wrap = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
+export const color = {
+    dim: wrap('2'),
+    bold: wrap('1'),
+    red: wrap('31'),
+    green: wrap('32'),
+    yellow: wrap('33'),
+    blue: wrap('34'),
+    cyan: wrap('36'),
+};
+/** Global --json: when on, every command prints raw JSON and nothing else. */
+let jsonMode = false;
+export function setJsonMode(on) {
+    jsonMode = on;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+export function printJson(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + '\n');
+}
+/** Print `value` as JSON in --json mode, otherwise run `human`. */
+export function render(value, human) {
+    if (jsonMode)
+        return printJson(value);
+    human(value);
+}
+export function info(message) {
+    if (!jsonMode)
+        process.stderr.write(message + '\n');
+}
+export function success(message) {
+    if (!jsonMode)
+        process.stderr.write(color.green('✓ ') + message + '\n');
+}
+export function warn(message) {
+    process.stderr.write(color.yellow('! ') + message + '\n');
+}
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+/**
+ * Terminal cell width. CJK and emoji occupy two columns, so counting code
+ * points misaligns every table that holds Chinese text.
+ */
+function charWidth(code) {
+    if (code === 0x200d)
+        return 0;
+    if (code >= 0x0300 && code <= 0x036f)
+        return 0; // combining marks
+    if (code >= 0xfe00 && code <= 0xfe0f)
+        return 0; // variation selectors
+    return (code >= 0x1100 && code <= 0x115f) ||
+        (code >= 0x2e80 && code <= 0x303e) ||
+        (code >= 0x3041 && code <= 0x33ff) ||
+        (code >= 0x3400 && code <= 0x4dbf) ||
+        (code >= 0x4e00 && code <= 0x9fff) ||
+        (code >= 0xa000 && code <= 0xa4cf) ||
+        (code >= 0xa960 && code <= 0xa97f) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe10 && code <= 0xfe19) ||
+        (code >= 0xfe30 && code <= 0xfe6f) ||
+        (code >= 0xff00 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6) ||
+        (code >= 0x1f300 && code <= 0x1f64f) ||
+        (code >= 0x1f900 && code <= 0x1f9ff) ||
+        (code >= 0x20000 && code <= 0x3fffd)
+        ? 2
+        : 1;
+}
+export function displayWidth(text) {
+    let width = 0;
+    for (const char of stripAnsi(text))
+        width += charWidth(char.codePointAt(0));
+    return width;
+}
+const visibleLength = displayWidth;
+export function table(rows, columns) {
+    if (!rows.length) {
+        info(color.dim('(empty)'));
+        return;
+    }
+    const cells = rows.map((row) => columns.map((c) => {
+        const v = c.value(row);
+        return v == null ? color.dim('-') : String(v);
+    }));
+    const widths = columns.map((c, i) => Math.max(visibleLength(c.header), ...cells.map((r) => visibleLength(r[i]))));
+    const pad = (s, w) => s + ' '.repeat(Math.max(0, w - displayWidth(s)));
+    process.stdout.write(columns.map((c, i) => color.dim(pad(c.header.toUpperCase(), widths[i]))).join('  ').trimEnd() +
+        '\n');
+    for (const row of cells) {
+        process.stdout.write(row.map((v, i) => pad(v, widths[i])).join('  ').trimEnd() + '\n');
+    }
+}
+/** Key/value block for detail views. */
+export function detail(pairs) {
+    const width = Math.max(...pairs.map(([k]) => displayWidth(k)));
+    for (const [k, v] of pairs) {
+        if (v == null || v === '')
+            continue;
+        const text = typeof v === 'object' ? JSON.stringify(v) : String(v);
+        const padded = k + ' '.repeat(Math.max(0, width - displayWidth(k)));
+        process.stdout.write(`${color.dim(padded)}  ${text}\n`);
+    }
+}
+/** Truncate to `max` terminal columns, not `max` code points. */
+export function truncate(value, max = 48) {
+    if (value == null)
+        return null;
+    const s = String(value).replace(/\s+/g, ' ').trim();
+    if (displayWidth(s) <= max)
+        return s;
+    let out = '';
+    let width = 0;
+    for (const char of s) {
+        const next = width + charWidth(char.codePointAt(0));
+        if (next > max - 1)
+            break;
+        out += char;
+        width = next;
+    }
+    return out + '…';
+}
+export function relativeTime(value) {
+    if (!value)
+        return null;
+    const then = new Date(value).getTime();
+    if (Number.isNaN(then))
+        return null;
+    const diff = Date.now() - then;
+    const units = [
+        [86400000 * 365, 'y'],
+        [86400000 * 30, 'mo'],
+        [86400000, 'd'],
+        [3600000, 'h'],
+        [60000, 'm'],
+    ];
+    for (const [ms, label] of units) {
+        if (Math.abs(diff) >= ms)
+            return `${Math.round(diff / ms)}${label} ago`;
+    }
+    return 'just now';
+}

package/dist/core/prompt.js

@@ -0,0 +1,118 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+const ETX = '\u0003'; // Ctrl-C
+const BACKSPACE = '\u007f';
+export async function ask(question) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Read a secret without echoing it. Falls back to a normal read on a non-TTY stdin. */
+export async function askSecret(question) {
+    if (!stdin.isTTY)
+        return ask(question);
+    stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    return new Promise((resolve, reject) => {
+        let value = '';
+        const finish = (fn) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            stdout.write('\n');
+            fn();
+        };
+        const onData = (chunk) => {
+            for (const char of chunk) {
+                if (char === '\r' || char === '\n')
+                    return finish(() => resolve(value));
+                if (char === ETX)
+                    return finish(() => reject(new Error('Cancelled')));
+                if (char === BACKSPACE || char === '\b') {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                value += char;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+export async function confirm(question, force) {
+    if (force)
+        return true;
+    if (!stdin.isTTY) {
+        throw new Error(`Refusing to continue without confirmation on a non-TTY. Pass --yes. (${question})`);
+    }
+    const answer = (await ask(`${question} [y/N] `)).toLowerCase();
+    return answer === 'y' || answer === 'yes';
+}
+/** Read a value given inline, as `@file`, or as `-` for stdin. */
+export async function readValue(value) {
+    const { readFile } = await import('node:fs/promises');
+    if (value === '-') {
+        const chunks = [];
+        for await (const chunk of stdin)
+            chunks.push(chunk);
+        return Buffer.concat(chunks).toString('utf8');
+    }
+    if (value.startsWith('@'))
+        return readFile(value.slice(1), 'utf8');
+    return value;
+}
+/** Parse a JSON option that may be inline JSON, `@file` or `-`. */
+export async function readJson(value) {
+    if (value === undefined)
+        return undefined;
+    const text = await readValue(value);
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON: ${err.message}`);
+    }
+}
+/** Parse repeated `--set key=value` pairs into a nested object. */
+export function parseKeyValues(pairs = []) {
+    const out = {};
+    for (const pair of pairs) {
+        const index = pair.indexOf('=');
+        if (index === -1)
+            throw new Error(`Expected key=value, got "${pair}"`);
+        const key = pair.slice(0, index);
+        const raw = pair.slice(index + 1);
+        let value = raw;
+        if (raw === 'true')
+            value = true;
+        else if (raw === 'false')
+            value = false;
+        else if (raw === 'null')
+            value = null;
+        else if (raw !== '' && !Number.isNaN(Number(raw)))
+            value = Number(raw);
+        else if (raw.startsWith('{') || raw.startsWith('[')) {
+            try {
+                value = JSON.parse(raw);
+            }
+            catch {
+                /* leave it as a string */
+            }
+        }
+        // Dotted keys build nested objects, matching the API's qs allowDots parsing.
+        const path = key.split('.');
+        let cursor = out;
+        for (const segment of path.slice(0, -1)) {
+            if (typeof cursor[segment] !== 'object' || cursor[segment] === null)
+                cursor[segment] = {};
+            cursor = cursor[segment];
+        }
+        cursor[path[path.length - 1]] = value;
+    }
+    return out;
+}

package/dist/core/zip.js

@@ -0,0 +1,87 @@
+/**
+ * Minimal ZIP writer — "stored" (no compression) entries only.
+ *
+ * The backend's skill importer keeps just the `.md` files and re-parses them, so
+ * compression buys nothing here; storing avoids pulling a zip dependency into an
+ * otherwise dependency-light CLI. Enough of the spec is implemented to produce a
+ * archive JSZip (what the backend uses) reads back correctly.
+ */
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++)
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/** DOS date/time — a fixed, valid timestamp is fine; the backend ignores it. */
+function dosDateTime(date = new Date()) {
+    const time = (date.getHours() << 11) | (date.getMinutes() << 5) | (Math.floor(date.getSeconds() / 2));
+    const day = (((date.getFullYear() - 1980) & 0x7f) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+    return { time: time & 0xffff, day: day & 0xffff };
+}
+export function createZip(entries) {
+    const { time, day } = dosDateTime();
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const nameBuf = Buffer.from(entry.path.replace(/\\/g, '/'), 'utf8');
+        const data = Buffer.isBuffer(entry.content) ? entry.content : Buffer.from(entry.content, 'utf8');
+        const crc = crc32(data);
+        const local = Buffer.alloc(30 + nameBuf.length);
+        local.writeUInt32LE(0x04034b50, 0); // local file header signature
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0, 6); // flags
+        local.writeUInt16LE(0, 8); // method: store
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(day, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(data.length, 18); // compressed size
+        local.writeUInt32LE(data.length, 22); // uncompressed size
+        local.writeUInt16LE(nameBuf.length, 26);
+        local.writeUInt16LE(0, 28); // extra length
+        nameBuf.copy(local, 30);
+        locals.push(local, data);
+        const central = Buffer.alloc(46 + nameBuf.length);
+        central.writeUInt32LE(0x02014b50, 0); // central directory header signature
+        central.writeUInt16LE(20, 4); // version made by
+        central.writeUInt16LE(20, 6); // version needed
+        central.writeUInt16LE(0, 8); // flags
+        central.writeUInt16LE(0, 10); // method
+        central.writeUInt16LE(time, 12);
+        central.writeUInt16LE(day, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(data.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(nameBuf.length, 28);
+        central.writeUInt16LE(0, 30); // extra length
+        central.writeUInt16LE(0, 32); // comment length
+        central.writeUInt16LE(0, 34); // disk number
+        central.writeUInt16LE(0, 36); // internal attrs
+        central.writeUInt32LE(0, 38); // external attrs
+        central.writeUInt32LE(offset, 42); // local header offset
+        nameBuf.copy(central, 46);
+        centrals.push(central);
+        offset += local.length + data.length;
+    }
+    const centralDir = Buffer.concat(centrals);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0); // end of central directory signature
+    end.writeUInt16LE(0, 4); // disk number
+    end.writeUInt16LE(0, 6); // central dir start disk
+    end.writeUInt16LE(entries.length, 8); // entries on this disk
+    end.writeUInt16LE(entries.length, 10); // total entries
+    end.writeUInt32LE(centralDir.length, 12);
+    end.writeUInt32LE(offset, 16); // central dir offset
+    end.writeUInt16LE(0, 20); // comment length
+    return Buffer.concat([...locals, centralDir, end]);
+}

package/dist/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { ApiError } from './core/client.js';
+import { color, setJsonMode } from './core/output.js';
+import { authCommand } from './commands/auth.js';
+import { configCommand } from './commands/config.js';
+import { orgCommand } from './commands/org.js';
+import { workspaceCommand } from './commands/workspace.js';
+import { datasetCommand, fsCommand } from './commands/fsnode.js';
+import { assetCommand } from './commands/asset.js';
+import { genCommand, historyCommand } from './commands/gen.js';
+import { modelCommand } from './commands/model.js';
+import { agentCommand } from './commands/agent.js';
+import { profileCommand } from './commands/profile.js';
+import { presetCommand } from './commands/preset.js';
+import { skillCommand } from './commands/skill.js';
+import { canvasCommand } from './commands/canvas.js';
+const VERSION = '0.1.0';
+const program = new Command();
+program
+    .name('wji')
+    .description('Command line interface for the WJI AI platform')
+    .version(VERSION, '-v, --version')
+    .option('--profile <name>', 'config profile to use')
+    .option('--endpoint <url>', 'API base URL')
+    .option('--token <token>', 'bearer token or sk_ API key for this call')
+    .option('--org <orgId>', 'organization context (X-Org-Id)')
+    .option('--no-org', 'force personal context')
+    .option('--locale <locale>', 'response language (cht, chs, en)')
+    .option('--json', 'print raw JSON instead of tables')
+    .configureHelp({ sortSubcommands: true });
+/**
+ * Global flags live on the root command, but subcommand actions run before
+ * we can read them off `program.opts()` in a nested scope — so hand every
+ * command a getter instead of a snapshot.
+ */
+const globals = () => {
+    const opts = program.opts();
+    return {
+        profile: opts.profile,
+        endpoint: opts.endpoint,
+        token: opts.token,
+        org: typeof opts.org === 'string' ? opts.org : undefined,
+        // commander turns `--no-org` into org === false
+        personal: opts.org === false,
+        locale: opts.locale,
+    };
+};
+program.hook('preAction', () => {
+    setJsonMode(!!program.opts().json);
+});
+program.addCommand(authCommand(globals));
+program.addCommand(configCommand(globals));
+program.addCommand(orgCommand(globals));
+program.addCommand(workspaceCommand(globals));
+program.addCommand(fsCommand(globals));
+program.addCommand(datasetCommand(globals));
+program.addCommand(assetCommand(globals));
+program.addCommand(genCommand(globals));
+program.addCommand(historyCommand(globals));
+program.addCommand(modelCommand(globals));
+program.addCommand(agentCommand(globals));
+program.addCommand(profileCommand(globals));
+program.addCommand(presetCommand(globals));
+program.addCommand(skillCommand(globals));
+program.addCommand(canvasCommand(globals));
+program.addHelpText('after', `
+Examples:
+  wji auth login --email you@example.com
+  wji ws list
+  wji ws use 65f0a1b2c3d4e5f6a7b8c9d0
+  wji models list --feature image   # pass the MODEL column to -m
+  wji gen image -m nano-banana -p "a rainy alley at dusk" --ratio 16:9 --wait
+  wji fs tree $(wji ws get --json | jq -r .id) --depth 2
+  wji asset upload ./reference.png --workspace <id>
+  wji canvas status                 # after pressing the link button on a canvas
+
+Auth precedence: --token > $WJI_TOKEN / $WJI_API_KEY > profile apiKey > profile accessToken.
+Config lives in ~/.wji/config.json (chmod 600).`);
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            process.stderr.write(`${color.red('✗')} ${err.message}\n`);
+            process.stderr.write(color.dim(`  ${err.status} ${err.path}\n`));
+            process.exit(err.status === 401 || err.status === 403 ? 77 : 1);
+        }
+        process.stderr.write(`${color.red('✗')} ${err.message}\n`);
+        process.exit(1);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@wji.ai/cli",
+  "version": "0.1.0",
+  "description": "Command line interface for the WJI AI platform",
+  "license": "UNLICENSED",
+  "author": "WJI AI",
+  "homepage": "https://wji.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ultra-instinct-ai/wji-cli.git"
+  },
+  "keywords": [
+    "wji",
+    "cli",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "claude-code"
+  ],
+  "type": "module",
+  "bin": {
+    "wji": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "skill",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "dev": "tsc -p tsconfig.json --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}