@stevezhou/sisu 0.1.0

package/LICENSE

@@ -0,0 +1,6 @@
+UNLICENSED
+
+Copyright (c) 2026 SiSu (思溯). All rights reserved.
+
+This software is proprietary. See the SiSu product license.
+ Use, copying, and redistribution require permission from SiSu.

package/README.md

@@ -0,0 +1,49 @@
+# sisu
+
+Official publish channel for the SiSu CLI npm package.
+
+One login. Cloud quota. Local workspace. Auth lives in `~/.sisu`, shared with SiSu Desktop. Product development of the CLI still happens in the main SiSu repo; this repository is what `npm publish` and `npm install -g @stevezhou/sisu` use.
+
+## Install
+
+```bash
+npm install -g @stevezhou/sisu
+sisu --help
+sisu login
+```
+
+Requires Node.js 20 or newer. `npx sisu` works without a global install.
+
+## Login
+
+```bash
+sisu login
+sisu login --code <grant>
+sisu login --email you@example.com --password '…'
+sisu login --token <jwt>
+sisu status
+```
+
+Default API is `https://www.sisu.chat`. Override with `--api` or `SISU_API_BASE`.
+
+## Commands
+
+```
+sisu                 interactive TUI
+sisu open <dir> --project <id>
+sisu exec "<prompt>"
+sisu history
+sisu logout
+```
+
+## Publish
+
+1. Add repository secret `NPM_TOKEN` (npm automation token with publish rights to `sisu`).
+2. Tag a release and push:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The `Publish` workflow runs tests, packs, and `npm publish --access public`.

package/dist/client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SISU_CLIENT_VERSION = void 0;
+exports.clientStamp = clientStamp;
+const module_1 = require("module");
+const crypto_1 = require("crypto");
+const req = (0, module_1.createRequire)(__filename);
+exports.SISU_CLIENT_VERSION = String(req('../package.json').version || '0.1.0');
+function clientStamp(kind) {
+    return {
+        client: kind,
+        client_version: exports.SISU_CLIENT_VERSION,
+        client_request_id: (0, crypto_1.randomUUID)(),
+    };
+}

package/dist/commands.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+exports.logoutCommand = logoutCommand;
+exports.resolveVerificationUrl = resolveVerificationUrl;
+exports.openBrowserSafely = openBrowserSafely;
+exports.webLoginCommand = webLoginCommand;
+exports.formatQuota = formatQuota;
+exports.fetchBalance = fetchBalance;
+exports.statusCommand = statusCommand;
+exports.openCommand = openCommand;
+exports.resolveBoundWorkspace = resolveBoundWorkspace;
+exports.listLocalCommand = listLocalCommand;
+exports.execCommand = execCommand;
+exports.listConversationsCommand = listConversationsCommand;
+exports.openConversationCommand = openConversationCommand;
+exports.setTrainingCommand = setTrainingCommand;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const http_1 = require("./http");
+const sse_1 = require("./sse");
+const client_1 = require("./client");
+const store_1 = require("./store");
+async function loginCommand(input, http = http_1.defaultHttp) {
+    const apiBase = (input.apiBase || process.env.SISU_API_BASE || store_1.DEFAULT_API_BASE).replace(/\/+$/, '');
+    if (input.token) {
+        const me = await http(`${apiBase}/api/auth/me`, { headers: (0, http_1.authHeaders)(input.token) });
+        const user = await me.json().catch(() => ({}));
+        if (!me.ok)
+            throw new Error((0, http_1.errorDetail)(user, `login failed (${me.status})`));
+        (0, store_1.writeAuth)({
+            token: input.token,
+            email: user.email || '',
+            user_id: String(user.id || ''),
+            api_base: apiBase,
+            plan_code: user.plan_code || '',
+            name: user.name || '',
+        });
+        return user.email || 'authenticated';
+    }
+    if (!input.email || !input.password) {
+        throw new Error('login requires --email/--password, --token, or a web login');
+    }
+    const response = await http(`${apiBase}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: input.email, password: input.password }),
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        throw new Error((0, http_1.errorDetail)(body, `login failed (${response.status})`));
+    }
+    const token = String(body.access_token || '');
+    if (!token)
+        throw new Error('login response missing access_token');
+    (0, store_1.writeAuth)({
+        token,
+        email: body.user?.email || input.email,
+        user_id: String(body.user?.id || ''),
+        api_base: apiBase,
+        plan_code: body.user?.plan_code || '',
+        name: body.user?.name || '',
+    });
+    return body.user?.email || input.email;
+}
+function logoutCommand() {
+    (0, store_1.clearAuth)();
+}
+function resolveVerificationUrl(raw, apiBase) {
+    const base = new URL(apiBase.endsWith('/') ? apiBase : `${apiBase}/`);
+    const parsed = new URL(raw, base);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('verification URL must be http(s)');
+    }
+    parsed.protocol = base.protocol;
+    parsed.host = base.host;
+    return parsed.toString();
+}
+function openBrowserSafely(url, spawnFn = child_process_1.spawn, platform = process.platform) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return;
+    try {
+        const child = platform === 'darwin'
+            ? spawnFn('open', [parsed.toString()], { detached: true, stdio: 'ignore' })
+            : platform === 'win32'
+                ? spawnFn('explorer.exe', [parsed.toString()], { detached: true, stdio: 'ignore' })
+                : spawnFn('xdg-open', [parsed.toString()], { detached: true, stdio: 'ignore' });
+        child.on('error', () => undefined);
+        child.unref();
+    }
+    catch {
+        // printed URL is enough when no browser can open
+    }
+}
+function pendingPoll(status, body) {
+    if (status === 428)
+        return true;
+    return String(body.detail || '') === 'authorization_pending';
+}
+async function webLoginCommand(input = {}, http = http_1.defaultHttp) {
+    const apiBase = (input.apiBase || process.env.SISU_API_BASE || store_1.DEFAULT_API_BASE).replace(/\/+$/, '');
+    if (input.grantCode) {
+        const exchanged = await http(`${apiBase}/api/auth/cli/device/exchange`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ grant_code: input.grantCode }),
+        });
+        const body = await exchanged.json().catch(() => ({}));
+        if (!exchanged.ok)
+            throw new Error((0, http_1.errorDetail)(body, `grant exchange failed (${exchanged.status})`));
+        const token = String(body.access_token || '');
+        if (!token)
+            throw new Error('grant exchange missing access_token');
+        return loginCommand({ token, apiBase }, http);
+    }
+    const started = await http(`${apiBase}/api/auth/cli/device`, { method: 'POST' });
+    const startBody = await started.json().catch(() => ({}));
+    if (!started.ok)
+        throw new Error((0, http_1.errorDetail)(startBody, `device start failed (${started.status})`));
+    const deviceCode = String(startBody.device_code || '');
+    const userCode = String(startBody.user_code || '');
+    const rawVerify = String(startBody.verification_uri_complete || startBody.verification_uri || '');
+    if (!deviceCode || !userCode || !rawVerify)
+        throw new Error('device start missing fields');
+    const complete = resolveVerificationUrl(rawVerify, apiBase);
+    input.onStart?.({
+        verification_uri: String(startBody.verification_uri || complete),
+        verification_uri_complete: complete,
+        user_code: userCode,
+    });
+    try {
+        (input.openBrowser ?? openBrowserSafely)(complete);
+    }
+    catch {
+        // printed URL is enough when no browser can open
+    }
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const intervalSec = Math.max(1, Number(startBody.interval || 1));
+    const expiresIn = Math.max(intervalSec, Number(startBody.expires_in || 600));
+    const maxAttempts = input.maxAttempts ?? Math.max(1, Math.ceil(expiresIn / intervalSec));
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const polled = await http(`${apiBase}/api/auth/cli/device/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ device_code: deviceCode }),
+        });
+        const body = await polled.json().catch(() => ({}));
+        if (polled.ok) {
+            const token = String(body.access_token || '');
+            if (!token)
+                throw new Error('device token missing access_token');
+            return loginCommand({ token, apiBase }, http);
+        }
+        if (pendingPoll(polled.status, body)) {
+            await sleep(Number(startBody.interval || 1) * 1000);
+            continue;
+        }
+        if (String(body.detail || '') === 'access_denied')
+            throw new Error('login cancelled');
+        throw new Error((0, http_1.errorDetail)(body, `device poll failed (${polled.status})`));
+    }
+    throw new Error('login timed out');
+}
+function formatQuota(balance) {
+    if (balance.allowance?.unlimited)
+        return 'quota unlimited';
+    const total = Number(balance.total ?? 0);
+    const plan = Number(balance.plan?.balance ?? 0);
+    const wallet = Number(balance.wallet?.balance ?? 0);
+    const bonus = Number(balance.bonus?.balance ?? 0);
+    const name = balance.plan?.plan_name || balance.plan?.plan_code || 'plan';
+    const allowance = balance.allowance;
+    const ration = allowance
+        ? `allowance ${allowance.used ?? 0}/${allowance.limit ?? 0}`
+        : '';
+    return [`quota ${total} pts`, `${name} ${plan}`, `wallet ${wallet}`, `bonus ${bonus}`, ration].filter(Boolean).join(' · ');
+}
+async function fetchBalance(http = http_1.defaultHttp) {
+    const auth = (0, store_1.requireAuth)();
+    const response = await http(`${auth.api_base}/api/points/balance`, { headers: (0, http_1.authHeaders)(auth.token) });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error((0, http_1.errorDetail)(body, `balance failed (${response.status})`));
+    return body;
+}
+async function statusCommand(http) {
+    const status = (0, store_1.describeStatus)();
+    const lines = [
+        `home ${status.home}`,
+        status.logged_in ? `user ${status.email}${status.plan_code ? ` (${status.plan_code})` : ''}` : 'user logged out',
+        `api  ${status.api_base}`,
+    ];
+    if (status.logged_in && http) {
+        try {
+            lines.push(formatQuota(await fetchBalance(http)));
+        }
+        catch (error) {
+            lines.push(`quota unavailable (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    const entries = Object.entries(status.workspaces);
+    if (!entries.length) {
+        lines.push('workspaces none');
+    }
+    else {
+        for (const [projectId, workspacePath] of entries) {
+            lines.push(`workspace ${projectId} ${workspacePath}`);
+        }
+    }
+    return lines.join('\n');
+}
+function openCommand(projectId, dir) {
+    const resolved = dir === '.' ? process.cwd() : dir;
+    if (!fs_1.default.existsSync(resolved))
+        throw new Error('directory does not exist');
+    const bound = (0, store_1.bindWorkspace)(projectId, resolved);
+    const session = (0, store_1.readSession)();
+    (0, store_1.writeSession)({ ...session, last_project_id: bound.projectId });
+    return `opened ${bound.path} for ${bound.projectId}`;
+}
+function resolveBoundWorkspace(projectId) {
+    const workspaces = (0, store_1.readWorkspaces)();
+    const requested = (projectId || (0, store_1.readSession)().last_project_id || '').trim();
+    if (requested && workspaces[requested]) {
+        return { projectId: requested, path: workspaces[requested] };
+    }
+    const entries = Object.entries(workspaces);
+    if (entries.length === 1)
+        return { projectId: entries[0][0], path: entries[0][1] };
+    if (!entries.length)
+        throw new Error('no local workspace — run sisu open <dir> --project <id>');
+    throw new Error('multiple workspaces — pass --project');
+}
+function listLocalCommand(projectId) {
+    (0, store_1.requireAuth)();
+    const bound = resolveBoundWorkspace(projectId);
+    const names = fs_1.default.readdirSync(bound.path).filter((name) => !name.startsWith('.'));
+    if (!names.length)
+        return `${bound.path} (empty)`;
+    return names.map((name) => {
+        const full = path_1.default.join(bound.path, name);
+        const suffix = fs_1.default.statSync(full).isDirectory() ? '/' : '';
+        return `${name}${suffix}`;
+    }).join('\n');
+}
+async function execCommand(prompt, options = {}, http = http_1.defaultHttp) {
+    const auth = (0, store_1.requireAuth)();
+    const text = prompt.trim();
+    if (!text)
+        throw new Error('prompt is required');
+    const stamp = (0, client_1.clientStamp)(options.client || 'cli');
+    let conversationId = options.conversationId || (!options.newConversation ? (0, store_1.readSession)().last_conversation_id : '');
+    if (!conversationId) {
+        const created = await http(`${auth.api_base}/api/chat/conversations`, {
+            method: 'POST',
+            headers: (0, http_1.authHeaders)(auth.token),
+            body: JSON.stringify({
+                title: text.slice(0, 50),
+                model: options.model || undefined,
+                project_id: options.projectId || (0, store_1.readSession)().last_project_id || undefined,
+                client: stamp.client,
+                client_version: stamp.client_version,
+            }),
+        });
+        const body = await created.json().catch(() => ({}));
+        if (!created.ok)
+            throw new Error((0, http_1.errorDetail)(body, `create conversation failed (${created.status})`));
+        conversationId = String(body.id || '');
+        if (!conversationId)
+            throw new Error('create conversation missing id');
+    }
+    const sent = await http(`${auth.api_base}/api/chat/send`, {
+        method: 'POST',
+        headers: (0, http_1.authHeaders)(auth.token),
+        body: JSON.stringify({
+            conversation_id: conversationId,
+            message: text,
+            model: options.model || undefined,
+            task_category: 'coding',
+            client: stamp.client,
+            client_version: stamp.client_version,
+            client_request_id: stamp.client_request_id,
+        }),
+    });
+    if (!sent.ok) {
+        const body = await sent.json().catch(() => ({}));
+        throw new Error((0, http_1.errorDetail)(body, `exec failed (${sent.status})`));
+    }
+    const stream = await sent.text();
+    const output = (0, sse_1.extractSseText)(stream);
+    (0, store_1.writeSession)({
+        ...(0, store_1.readSession)(),
+        last_conversation_id: conversationId,
+        last_project_id: options.projectId || (0, store_1.readSession)().last_project_id,
+    });
+    return { conversationId, text: output };
+}
+async function listConversationsCommand(http = http_1.defaultHttp) {
+    const auth = (0, store_1.requireAuth)();
+    const response = await http(`${auth.api_base}/api/chat/conversations?limit=30`, {
+        headers: (0, http_1.authHeaders)(auth.token),
+    });
+    const body = await response.json().catch(() => []);
+    if (!response.ok)
+        throw new Error((0, http_1.errorDetail)(body, `history failed (${response.status})`));
+    const rows = Array.isArray(body) ? body : [];
+    if (!rows.length)
+        return 'no saved conversations';
+    return rows.map((row) => {
+        const client = row.client ? ` [${row.client}]` : '';
+        return `${row.id}  ${row.title || '(untitled)'}${client}`;
+    }).join('\n');
+}
+function openConversationCommand(conversationId) {
+    const id = conversationId.trim();
+    if (!id)
+        throw new Error('conversation id is required');
+    (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_conversation_id: id });
+    return `opened ${id}`;
+}
+async function setTrainingCommand(optIn, http = http_1.defaultHttp) {
+    const auth = (0, store_1.requireAuth)();
+    const response = await http(`${auth.api_base}/api/auth/profile`, {
+        method: 'PATCH',
+        headers: (0, http_1.authHeaders)(auth.token),
+        body: JSON.stringify({ training_opt_in: optIn }),
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error((0, http_1.errorDetail)(body, `training update failed (${response.status})`));
+    return optIn ? 'training opt-in on (new turns may be used if eligible)' : 'training opt-in off';
+}

package/dist/http.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authHeaders = authHeaders;
+exports.defaultHttp = defaultHttp;
+exports.errorDetail = errorDetail;
+function authHeaders(token) {
+    return {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+    };
+}
+async function* streamResponse(response) {
+    const body = response.body;
+    if (!body) {
+        yield await response.text();
+        return;
+    }
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                yield decoder.decode(value, { stream: true });
+        }
+        const tail = decoder.decode();
+        if (tail)
+            yield tail;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function defaultHttp(url, init) {
+    const response = await fetch(url, init);
+    return {
+        ok: response.ok,
+        status: response.status,
+        json: () => response.json(),
+        text: () => response.text(),
+        stream: () => streamResponse(response),
+    };
+}
+function errorDetail(body, fallback) {
+    if (typeof body?.detail === 'string')
+        return body.detail;
+    if (typeof body?.error === 'string')
+        return body.error;
+    if (typeof body?.message === 'string')
+        return body.message;
+    return fallback;
+}

package/dist/logo.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sisuMobiusArt = sisuMobiusArt;
+exports.sisuWordmark = sisuWordmark;
+exports.sisuBanner = sisuBanner;
+exports.stripAnsi = stripAnsi;
+const mobius_1 = require("./mobius");
+function sisuMobiusArt(columns = 80, phase = 0, color = false) {
+    return (0, mobius_1.renderMobiusFrame)({
+        cols: (0, mobius_1.mobiusFrameWidth)(columns),
+        rows: (0, mobius_1.mobiusFrameHeight)(columns),
+        phase,
+        color,
+    });
+}
+function sisuWordmark() {
+    return [
+        '                      思   溯',
+        '                      S I S U',
+    ].join('\n');
+}
+function sisuBanner(columns = 80, phase = 0, color = false) {
+    return [
+        '',
+        sisuMobiusArt(columns, phase, color),
+        '',
+        sisuWordmark(),
+        '',
+    ].join('\n');
+}
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/dist/main.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpText = helpText;
+exports.runCli = runCli;
+const commands_1 = require("./commands");
+const http_1 = require("./http");
+const store_1 = require("./store");
+const tui_1 = require("./tui");
+function helpText() {
+    return `sisu — SiSu local client
+
+One login. Cloud quota. Local workspace.
+
+Install:
+  npm install -g @stevezhou/sisu
+
+Usage:
+  sisu login                  open a browser (or print a URL) to sign in
+  sisu login --code <grant>   paste the grant code from the approve page
+  sisu login --email <email> --password <password> [--api <url>]
+  sisu login --token <jwt> [--api <url>]
+  sisu logout
+  sisu status
+  sisu open <dir> --project <project-id>
+  sisu ls [--project <project-id>]
+  sisu exec "<prompt>" [--project <id>] [--model <name>] [--new]
+  sisu history
+  sisu thread <conversation-id>
+  sisu training --on|--off
+  sisu                 interactive TUI (Möbius splash)
+  sisu help
+
+Auth and workspaces live in $SISU_HOME (default ~/.sisu), shared with Desktop.
+`;
+}
+function printHelp() {
+    process.stdout.write(helpText());
+}
+function flag(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function parseArgs(args) {
+    const flags = {};
+    const rest = [];
+    const switches = new Set();
+    for (let i = 0; i < args.length; i += 1) {
+        const item = args[i];
+        if (item === '--new') {
+            switches.add('new');
+            continue;
+        }
+        if (item.startsWith('--')) {
+            flags[item] = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        rest.push(item);
+    }
+    return { flags, rest, switches };
+}
+async function runCli(argv, deps = {}) {
+    const http = deps.http ?? http_1.defaultHttp;
+    const [command, ...args] = argv;
+    if (command === 'help' || command === '--help' || command === '-h') {
+        printHelp();
+        return 0;
+    }
+    if (!command || command === 'tui') {
+        return (0, tui_1.runTui)((0, tui_1.defaultTuiIo)());
+    }
+    if (command === 'status') {
+        process.stdout.write(`${await (0, commands_1.statusCommand)(http_1.defaultHttp)}\n`);
+        return 0;
+    }
+    if (command === 'logout') {
+        (0, commands_1.logoutCommand)();
+        process.stdout.write('logged out\n');
+        return 0;
+    }
+    if (command === 'login') {
+        const email = flag(args, '--email') || process.env.SISU_EMAIL || '';
+        const password = flag(args, '--password') || process.env.SISU_PASSWORD || '';
+        const token = flag(args, '--token') || process.env.SISU_TOKEN || '';
+        const grantCode = flag(args, '--code') || '';
+        const apiBase = flag(args, '--api') || process.env.SISU_API_BASE || store_1.DEFAULT_API_BASE;
+        const loggedIn = grantCode
+            ? await (0, commands_1.webLoginCommand)({
+                apiBase,
+                grantCode,
+                openBrowser: deps.http ? () => undefined : undefined,
+            }, http)
+            : (email && password) || token
+                ? await (0, commands_1.loginCommand)({ email, password, token, apiBase }, http)
+                : await (0, commands_1.webLoginCommand)({
+                    apiBase,
+                    openBrowser: deps.http ? () => undefined : undefined,
+                    onStart: (info) => {
+                        process.stdout.write(`Open ${info.verification_uri_complete}\n`);
+                        process.stdout.write(`Confirm code ${info.user_code} (or paste --code from the page)\n`);
+                    },
+                }, http);
+        process.stdout.write(`logged in as ${loggedIn}\n`);
+        process.stdout.write(`${await (0, commands_1.statusCommand)(http)}\n`);
+        return 0;
+    }
+    if (command === 'open') {
+        const dir = args.find((item) => !item.startsWith('--')) || '.';
+        const projectId = flag(args, '--project') || '';
+        if (!projectId) {
+            process.stderr.write('sisu open requires --project <project-id>\n');
+            return 2;
+        }
+        process.stdout.write(`${(0, commands_1.openCommand)(projectId, dir)}\n`);
+        return 0;
+    }
+    if (command === 'ls') {
+        process.stdout.write(`${(0, commands_1.listLocalCommand)(flag(args, '--project'))}\n`);
+        return 0;
+    }
+    if (command === 'exec') {
+        const parsed = parseArgs(args);
+        const prompt = parsed.rest.join(' ').trim();
+        if (!prompt) {
+            process.stderr.write('sisu exec requires a prompt\n');
+            return 2;
+        }
+        const result = await (0, commands_1.execCommand)(prompt, {
+            projectId: parsed.flags['--project'],
+            model: parsed.flags['--model'],
+            newConversation: parsed.switches.has('new'),
+        });
+        if (result.text)
+            process.stdout.write(`${result.text}\n`);
+        return 0;
+    }
+    if (command === 'history') {
+        process.stdout.write(`${await (0, commands_1.listConversationsCommand)(http_1.defaultHttp)}\n`);
+        return 0;
+    }
+    if (command === 'thread') {
+        const id = args.find((item) => !item.startsWith('--')) || '';
+        process.stdout.write(`${(0, commands_1.openConversationCommand)(id)}\n`);
+        return 0;
+    }
+    if (command === 'training') {
+        if (args.includes('--on')) {
+            process.stdout.write(`${await (0, commands_1.setTrainingCommand)(true)}\n`);
+            return 0;
+        }
+        if (args.includes('--off')) {
+            process.stdout.write(`${await (0, commands_1.setTrainingCommand)(false)}\n`);
+            return 0;
+        }
+        process.stderr.write('sisu training requires --on or --off\n');
+        return 2;
+    }
+    process.stderr.write(`unknown command: ${command}\n`);
+    printHelp();
+    return 2;
+}
+if (require.main === module) {
+    runCli(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}